Valójában az első két Fibonacci-szám előre meghatározott. Az első Fibonacci-szám 0, a második Fibonacci-szám pedig 1. Nulla alapú indexeléssel és feltételezve, hogy a Fibonacci-számok egy tömbben vannak, akkor:
indexnél 0 , a Fibonacci-szám az 0 , ( előre meghatározott ) ;indexnél 1 , a Fibonacci-szám az 1 , ( előre meghatározott ) ;
indexnél két , a Fibonacci-szám az 1 = 1 + 0 , ( definíció szerint ) ;
indexnél 3 , a Fibonacci-szám az két = 1 + 1 , ( definíció szerint ) ;
indexnél 4 , a Fibonacci-szám az 3 = két + 1 , ( definíció szerint ) ;
indexnél 5 , a Fibonacci-szám az 5 = 3 + két , ( definíció szerint ) ;
indexnél 6 , a Fibonacci-szám az 8 = 5 + 3 , ( definíció szerint ) ;
indexnél 7 , a Fibonacci-szám az 13 = 8 + 5 , ( definíció szerint ) ;
indexnél 8 , a Fibonacci-szám az huszonegy = 13 + 8 , ( definíció szerint ) ;
indexnél 9 , a Fibonacci-szám az 3. 4 = huszonegy + 13 , ( definíció szerint ) ;
stb.
A programozás során az n változót, és nem az i-t használjuk a Fibonacci-számok nulla alapú indexeihez. És ezzel az első tizenkét Fibonacci-szám:
| 0 | 1 | 1 | két | 3 | 5 | 8 | 13 | huszonegy | 3. 4 | 55 | 89 |
| 0 | 1 | két | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | tizenegy |
A táblázat második sora adja meg a nulla alapú indexeket, amelyek mindegyike az n változót tartalmazza a programozásban. Az első sor a megfelelő Fibonacci-számokat adja. Tehát a Fibonacci-számok nem akármilyen számok. A mag definíciója 0-val kezdődik az első Fibonacci szám és 1 a második Fibonacci szám esetében. A többi számot onnan állítják elő.
Fibonacci számok előállíthatók O(n) időben és O(1) időben is. O(n) időre, ha n például 12, akkor az első tizenkét Fibonacci-szám jön létre. O(1) időre csak egy Fibonacci-szám jön létre. Például, ha n 6, akkor a Fibonacci-szám 8 jön létre.
Ez a cikk a Fibonacci-számok Java nyelven történő előállításának két módját ismerteti.
A Fibonacci-szám képlete
Van egy matematikai képlet egy Fibonacci-számra. Ez a képlet három vagy egy sorba írható. Három sorban így írják:
ahol F n a Fibonacci-szám a nulla alapú n-ben th index. Így definiálható a Fibonacci-szám.
Fibonacci számok előállítása O(n) idő alatt
Ha a Fibonacci-számokat O(3)-szorosan állítjuk elő, akkor a 0, 1, 1 számokat állítjuk elő; ez az első három Fibonacci-szám. Az utolsó nulla alapú n th az index itt 2. Ha a Fibonacci-számokat O(7)-szeresben állítjuk elő, akkor a 0, 1, 1, 2, 3, 5, 8 számok jönnek létre; ez az első hét Fibonacci-szám. Az utolsó nulla alapú n th az index itt 6. Ha a Fibonacci-számokat O(n) alkalommal állítjuk elő, akkor a 0, 1, 1, 2, 3, 5, 8 – – - számok jönnek létre; ezek az első n Fibonacci-számok. Az utolsó nulla alapú n th az index itt n-1.
A Java metódus egy osztályban az első n Fibonacci szám előállításához a következő:
osztály Fibonacci {üres fibonacci ( int [ ] P ) {
int n = P. hossz ;
ha ( n > 0 )
P [ 0 ] = 0 ;
ha ( n > 1 )
P [ 1 ] = 1 ;
számára ( int én = két ; én < n ; én ++ ) { //n=0 és n=2 vették figyelembe
int currNo = P [ én - 1 ] + P [ én - két ] ;
P [ én ] = currNo ;
}
}
}
Az osztály, Fibonacci zártkörű. Az fibonacci () metódus veszi a P tömböt, és void-ot ad vissza. A módszer a tömb hosszának meghatározásával kezdődik. Ez az n hosszúság a szükséges Fibonacci-számok száma. Az első és a második Fibonacci-szám explicit módon van meghatározva, és a tömb első és második pozíciójába kerül.
A harmadiktól kezdődő Fibonacci-számok többi részét (index, n = 2) egy for-ciklusban határozzuk meg, és a tömbben a helyükre helyezzük. Tehát a függvénynek void-ot kell visszaadnia. A for-ciklus fő utasítása hozzáadja az előző két számot.
Az áttekinthetőség kedvéért n helyett az i indexváltozót használtuk.
A megfelelő Java Main osztály (a Java main metódussal) a következő:
nyilvános osztály Fő {nyilvános statikus üres fő- ( Húr args [ ] ) {
int m = 12 ;
int [ ] arr = új int [ m ] ;
Fibonacci obj = új Fibonacci ( ) ;
obj. fibonacci ( arr ) ;
számára ( int én = 0 ; én < m ; én ++ )
Rendszer . ki . nyomtatás ( arr [ én ] + ' ' ) ;
Rendszer . ki . println ( ) ;
}
}
Miután a számokat a fibonacci() metódussal előállítottuk, a Java main metódus kiolvassa azokat.
Egy Fibonacci szám előállítása állandó időben
Van egy matematikai képlet, amellyel Fibonacci-számot állíthatunk elő, ha megadjuk a megfelelő nulla alapú indexet, n. A képlet a következő:
ahol n a nulla alapú index és Fib n a megfelelő Fibonacci-szám. Figyeljük meg, hogy az egyenlet jobb oldalán nem az 5 négyzetgyökét emeljük n hatványra; a zárójelben lévő kifejezés az n hatványra emelkedik. Két ilyen kifejezés létezik.
Ha n értéke 0, Fib n 0 lenne. Ha n értéke 1, Fib n 1 lenne. Ha n 2, Fib n 1 lenne. Ha n 3, Fib n 2 lenne. Ha n értéke 4, Fib n 3 lenne – és így tovább. Az olvasó ezt a képletet matematikailag is ellenőrizheti, ha n-t különböző értékekkel helyettesít, és kiértékeli.
Kódolva ez a képlet csak egy Fibonacci-számot adna n-hez. Ha egynél több Fibonacci-számra van szükség, akkor a képlet kódját egyszer kell meghívni a különböző megfelelő indexekhez.
A Java nyelven csak egy Fibonacci szám előállításának módszere a következő:
import java.lang.* ;osztály Füllent {
kettős fibNo ( int n ) {
kettős FibN = ( Math . hadifogoly ( ( 1 + Math . sqrt ( 5 ) ) / két , n ) – Math . hadifogoly ( ( 1 - Math . sqrt ( 5 ) ) / két , n ) ) / Math . sqrt ( 5 ) ;
Visszatérés FibN ;
}
}
A java.lang.* csomagot a program elején kellett importálni. Ennek az az oka, hogy a csomagban van a Math osztály, amely a hatvány (pow) és négyzetgyök (sqrt) metódusokkal rendelkezik. Az itt található egyéni Java metódus közvetlenül valósítja meg a matematikai képletet.
Ennek a függvénynek az időbonyolultsága O(1), egy főművelet állandó szelídsége. Egy megfelelő Java Main osztály, Java main metódussal a fenti metódushoz:
nyilvános osztály Fő {nyilvános statikus üres fő- ( Húr args [ ] ) {
int N = tizenegy ;
Fib obj = új Füllent ( ) ;
kettős jobb = obj. fibNo ( N ) ;
Rendszer . ki . println ( jobb ) ;
}
}
A rendszer elküldi az n = 11 indexet, és visszaadja a 89-es Fibonacci-számot. A kimenet a következő:
89.00000000000003A felesleges decimális számjegyek eltávolíthatók, de erről majd máskor lesz szó.
Következtetés
A Fibonacci-számok egész számok meghatározott sorozata. Az aktuális szám megszerzéséhez adja hozzá az előző két megfelelő számot. Az első két Fibonacci-szám, a 0, majd az 1, előre deklarálva van a teljes sorozatra. A többi Fibonacci-számot onnan állítják elő.
Ha a 2-es indexből Fibonacci-számokat szeretne előállítani az n-1 indexnek megfelelő számra, használjon for-hurkot a fő utasítással:
int currNo = P [ én - 1 ] + P [ én – két ] ;ahol currNo az aktuális Fibonacci-szám, P pedig az n szám tárolására szolgáló tömb.
Ha csak egy Fibonacci-számot szeretne előállítani bármely nulla alapú n indexből, használja a matematikai képletet:
