Apa sih perbedaan IsUnerLeft dengan IsSkewLeft?

• isUnerLeft:
• Hanya mengecek hubungan akar dan anak langsungnya.
• Fokus pada apakah akar memiliki anak kiri saja, tanpa memedulikan keseluruhan struktur pohon.

• Contoh: A / B

  • isUnerLeft(A): True, karena A hanya punya anak kiri (B).

  A / B / \ C D - isUnerLeft(A): Tetap True, karena hanya A yang dicek, dan A hanya punya anak kiri (B), tanpa memperhatikan apa yang ada di bawah B.

• isSkewLeft:
• Memeriksa seluruh pohon.
• Pastikan semua simpul dalam pohon hanya memiliki anak kiri, secara rekursif.
• Contoh: A / B / C
  • isSkewLeft(A): True, karena semua simpul hanya memiliki anak kiri. A / B \ C
  • isSkewLeft(A): False, karena B punya anak kanan (C).

Kesimpulan:

• isUnerLeft: Hanya fokus pada simpul akar dan anak langsungnya (lokal).
• isSkewLeft: Mengevaluasi keseluruhan pohon biner secara rekursif, memastikan miring ke kiri sepenuhnya.

WOY BACA HIGHLIGHT IS UNER LEFT

bisa unerleft/biner, dua duanya punya subpohon kiri maka solusi dijadikan satu

kalo unerright gapunya subpohon kiri

Basis 1. btw untuk menentukan basis (kondisi dasar) apa yg dipake bisa dikira-kira, berhubungan daun selalu 1 btw

input output karena p AKAN BERUBAH

dihiitung tinggi kiri dan kanan, bandingkan mana yg tertinggi, pilih tertinggi lalu tambah 1 (akar)

Pakai basis 0

sama aja kaya nb element tapi akar == 0

ini baru rekursif, basis 1 karena memang hanya memproses berdasarkan basis 1, basis 0 udh di handle

ini bukan rekursif karena gaada pemanggilan diri dia sendiri, hanya analisis kasus biasa

daun itu terujung

Fungsi dibuat seperti ini untuk mencegah NbElmt dengan basis 0.Oke, mari kita sederhanakan penjelasannya.

Kenapa Basis 1 Butuh unerleft, unerright, dan isbiner?

• Basis 1 adalah aturan di mana rekursi hanya berhenti kalau pohon punya satu simpul (akar saja).
• Untuk memastikan rekursi tetap berjalan sesuai aturan basis 1, kita perlu tahu bentuk struktur pohon yang sedang diproses:
• Pohon punya anak kiri saja (unerleft).
• Pohon punya anak kanan saja (unerright).
• Pohon punya dua anak (isbiner).

Dengan kata lain, kita pecah bentuk pohon menjadi 3 kategori supaya fungsi bisa tahu ke mana rekursi harus berjalan (kiri saja, kanan saja, atau kiri dan kanan).

Kenapa Bukan Basis 0?

• Basis 0 berhenti kalau pohon kosong (NIL).
• Tapi di basis 1, kita tidak menganggap pohon kosong sebagai bagian dari logika. Kita hanya peduli pada pohon yang punya minimal satu simpul.
• Jadi, logika basis 1 menghindari pohon kosong dan memaksa fungsi hanya berhenti kalau pohon punya satu simpul saja.

Contoh Sederhana

Misalkan ada pohon seperti ini:

A / \ B C / D

Dengan Basis 1:

1. Kalau pohon punya satu simpul (seperti D), langsung hitung dan berhenti.
2. Kalau pohon punya anak kiri saja, lanjut ke kiri (contoh: B).
3. Kalau pohon punya anak kanan saja, lanjut ke kanan.
4. Kalau pohon punya dua anak (contoh: A), proses keduanya.

Kode Sederhana

c function NbElmt(p: BinTree) -> integer IF isOneElmt(p) THEN RETURN 1 ELSE IF unerleft(p) THEN RETURN 1 + NbElmt(LEFT(p)) ELSE IF unerright(p) THEN RETURN 1 + NbElmt(RIGHT(p)) ELSE IF isbiner(p) THEN RETURN 1 + NbElmt(LEFT(p)) + NbElmt(RIGHT(p))

• isOneElmt(p): Kalau pohon cuma satu simpul, berhenti di situ.
• unerleft(p): Kalau pohon cuma punya anak kiri, hitung akar + rekursi ke kiri.
• unerright(p): Kalau pohon cuma punya anak kanan, hitung akar + rekursi ke kanan.
• isbiner(p): Kalau pohon punya dua anak, hitung akar + rekursi kiri + rekursi kanan.

Simpulan

• Basis 1 fokus ke pohon dengan minimal satu simpul, bukan pohon kosong.
• unerleft, unerright, dan isbiner membantu memecah struktur pohon supaya rekursi berjalan dengan aturan basis 1, tanpa kembali ke logika basis 0 (pohon kosong).

Perbedaan utama antara pohon biner basis 0 dan pohon biner basis 1 terletak pada cara definisi kondisi dasar (basis) dalam proses rekursi dan bagaimana pohon tersebut direpresentasikan secara logis dalam setiap operasi. Mari kita perjelas:

1. Basis 0: Kondisi Kosong

Pada basis 0, pohon dianggap kosong jika tidak ada simpul sama sekali. Kondisi berhenti dalam rekursi adalah ketika pohon mencapai kondisi kosong.

Ciri-ciri Pohon Basis 0:

• Kondisi Terminasi: IsTreeEmpty(p) == true (artinya simpul p == NIL).
• Basis 0 digunakan untuk kasus di mana: ** - Pohon tidak memiliki simpul sama sekali (kosong)**.
• Proses rekursi berhenti saat mencapai simpul kosong.
• Definisi Rekursif:
• Pohon biner basis 0 didefinisikan sebagai:
  • Pohon kosong, atau
  • Sebuah simpul akar dengan dua sub-pohon kiri dan kanan yang juga pohon biner basis 0.

Ilustrasi Basis 0

Pohon Basis 0: Pohon Kosong -> Tidak ada simpul

Kondisi rekursi:

- Jika pohon kosong, berhenti. - Jika tidak kosong, proses akar, lalu lanjutkan ke sub-pohon kiri dan kanan.

2. Basis 1: Kondisi Satu Elemen

Pada basis 1, pohon dianggap memiliki satu elemen jika hanya ada satu simpul (simpul akar) tanpa sub-pohon kiri dan kanan. Kondisi berhenti dalam rekursi adalah ketika pohon memiliki hanya satu simpul.

Ciri-ciri Pohon Basis 1:

• Kondisi Terminasi: isOneElmt(p) == true (artinya simpul p adalah akar, dan LEFT(p) == NIL serta RIGHT(p) == NIL).
• Basis 1 digunakan untuk kasus di mana:
• Pohon memiliki satu elemen (akar saja), tanpa sub-pohon.

  ** - Proses rekursi berhenti saat mencapai simpul tunggal.**

• Definisi Rekursif:
• Pohon biner basis 1 didefinisikan sebagai:
  • Sebuah simpul akar tanpa sub-pohon kiri dan kanan, atau
  • Sebuah simpul akar dengan dua sub-pohon kiri dan kanan yang juga pohon biner basis 1.

Ilustrasi Basis 1

Pohon Basis 1: Pohon dengan Satu Simpul A / \ NIL NIL

Kondisi rekursi: - Jika pohon hanya memiliki satu elemen, berhenti. - Jika memiliki lebih dari satu elemen, proses akar, lalu lanjutkan ke sub-pohon kiri dan kanan.

Perbandingan

| Aspek | Basis 0 | Basis 1 | |-----------------------|----------------------------------------|----------------------------------------| | Kondisi Terminasi | IsTreeEmpty(p) == true | isOneElmt(p) == true | | Definisi Kosong | Pohon benar-benar kosong (tidak ada) | Pohon kosong hanya setelah 1 elemen | | Definisi Rekursif | Pohon kosong atau memiliki simpul akar dan dua sub-pohon basis 0. | Pohon satu elemen, atau akar dengan dua sub-pohon basis 1. | | Contoh Pohon | Kosong: NIL | Satu elemen: simpul dengan LEFT = NIL dan RIGHT = NIL | | Penggunaan Rekursi| Berhenti saat pohon kosong | Berhenti saat pohon terdiri dari satu simpul. |

Contoh dalam Rekursi

Basis 0 (Kosong)

Fungsi menghitung jumlah elemen pohon basis 0: c function nbElmt(p: BinTree) -> integer { KAMUS LOKAL } { ALGORITMA } IF IsTreeEmpty(p) THEN RETURN 0 ELSE RETURN 1 + nbElmt(LEFT(p)) + nbElmt(RIGHT(p)) - Basis 0: Jika pohon kosong (IsTreeEmpty(p)), kembalikan 0. - Rekursi berlanjut sampai semua simpul diakses.

Basis 1 (Satu Elemen)

Fungsi menghitung jumlah elemen pohon basis 1: c function nbElmt(p: BinTree) -> integer { KAMUS LOKAL } { ALGORITMA } IF IsTreeEmpty(p) THEN RETURN 0 ELSE IF isOneElmt(p) THEN RETURN 1 ELSE RETURN 1 + nbElmt(LEFT(p)) + nbElmt(RIGHT(p)) - Basis 1: Jika pohon hanya memiliki satu elemen (isOneElmt(p)), kembalikan 1. - Rekursi berlanjut jika pohon memiliki lebih dari satu simpul.

Kesimpulan

• Basis 0: Fokus pada kondisi pohon kosong. Rekursi berhenti ketika tidak ada simpul lagi.
• Basis 1: Fokus pada kondisi pohon dengan satu simpul. Rekursi berhenti ketika simpul tunggal ditemukan.
• Pilihan antara basis 0 atau basis 1 tergantung pada konteks operasi dan cara definisi pohon biner yang diinginkan.

TIDAK AKAN PERNAH BERTEMU POHON KOSONG

akar

ini urutannya pokonya ngikutin requirement nya aja

proses akar ada di tengah

ini tuh berarti kaya kondisi terminasi ya. Penjelasan, Ya, Anda benar! Dalam contoh kode PrintPreOrder dari PDF, basis 0 bertindak sebagai kondisi terminasi dari proses rekursi. Basis 0 memastikan bahwa traversal berhenti saat mencapai sub-pohon kosong (atau simpul tanpa anak).

Penjelasan Rekursi PrintPreOrder

1. Pola Traversal PreOrder

Traversal pre-order dilakukan dengan urutan: 1. Proses akar. 2. Traversal sub-pohon kiri. 3. Traversal sub-pohon kanan.

Pada setiap langkah, rekursi dipanggil untuk sub-pohon kiri terlebih dahulu, lalu sub-pohon kanan.

2. Basis 0 sebagai Kondisi Terminasi

• Basis 0 diartikan sebagai kondisi di mana simpul pohon yang sedang diproses adalah kosong (NULL).
• Ketika simpul pohon bernilai NULL, fungsi atau prosedur rekursi akan berhenti untuk cabang tersebut dan kembali ke level rekursi sebelumnya.
• Hal ini mencegah rekursi tanpa akhir dan menjaga traversal tetap valid.

3. Alur Rekursi

• Dari akar pohon:
• Cetak nilai akar.
• Rekursi ke sub-pohon kiri (terus ke bawah sampai mencapai simpul kosong).
• Rekursi ke sub-pohon kanan (terus ke bawah sampai simpul kosong).
• Basis 0 memastikan bahwa jika simpul yang sedang diproses adalah NULL, tidak ada lagi pemanggilan rekursif, sehingga traversal "berbalik" ke simpul di atasnya.

Kode PrintPreOrder

Berikut adalah cuplikan kode dari PDF pada halaman 23: c procedure PrintPreOrder(p: BinTree) /* I.S. p terdefinisi */ /* F.S. Semua node pohon dicetak secara pre-order */ { KAMUS LOKAL } { ALGORITMA } IF NOT IsTreeEmpty(p) THEN Print(INFO(p)) /* Proses simpul akar */ PrintPreOrder(LEFT(p)) /* Proses sub-pohon kiri */ PrintPreOrder(RIGHT(p)) /* Proses sub-pohon kanan */

• Kondisi IsTreeEmpty(p) memeriksa apakah simpul p adalah NULL. Jika ya, maka traversal untuk simpul ini berhenti (basis 0).
• Jika tidak kosong, simpul diproses (dicetak), lalu rekursi dipanggil untuk sub-pohon kiri dan kanan.

Ilustrasi Traversal

Misalkan pohon biner seperti berikut:

A / \ B C / \ D E

Traversal pre-order: 1. Cetak A. 2. Rekursi ke sub-pohon kiri B: - Cetak B. - Rekursi ke sub-pohon kiri D: - Cetak D. - Basis 0: D tidak memiliki anak, kembali ke B. - Rekursi ke sub-pohon kanan E: - Cetak E. - Basis 0: E tidak memiliki anak, kembali ke B, lalu ke A. 3. Rekursi ke sub-pohon kanan C: - Cetak C. - Basis 0: C tidak memiliki anak.

Hasil pre-order: A, B, D, E, C.

Kesimpulan

• Basis 0 memastikan rekursi berhenti pada simpul kosong, sehingga traversal "berbalik" ke simpul di atasnya.
• Dalam traversal pre-order, rekursi terjadi dari akar → kiri → kanan, dengan basis 0 menjadi kondisi terminasi untuk setiap cabang sub-pohon.

ini proses(p) kalau print pre order

mulai dari baris terbawah. C karna gaada subpohon kiri, subpohon kanan maka C doang, lalu pindah ke kanannya (D), terus pindah ke sub pohon kanan

pasti sub pohon salah satunya ga kosong, kalo yg basis 0 bisa kosong

tidak akan pernah ketemu pohon kosong di basis 1

Basisnya hanya akar doang, kalau IsOneElement(p) == true

dealokasi pohon P

info dari sebuah node

ada 2 bentuk, fungsi dan prosedur. Perbedaan utama antara fungsi dan prosedur dalam pembuatan pohon biner terletak pada cara mereka mengembalikan hasilnya:

1. Fungsi (function):
2. Fungsi menghasilkan BinTree sebagai nilai kembalian (return value).
3. Hasilnya langsung berupa pohon biner yang terbentuk, dan fungsi tersebut tidak memodifikasi parameter input secara langsung.

4. Contoh: Pada halaman 15, fungsi Tree mengembalikan pohon biner yang dibuat dari akar dan dua sub-pohon kiri dan kanan, tanpa memanipulasi argumen input: c function Tree(akar: ElType, l: BinTree, r: BinTree) → BinTree

5. Prosedur (procedure):

6. Prosedur menggunakan parameter output (seperti p atau BinTree) untuk memberikan hasilnya.
7. Parameter output ini biasanya dapat dimodifikasi lebih lanjut di luar prosedur.
8. Contoh: Pada halaman 15, prosedur CreateTree memanfaatkan parameter output untuk memberikan hasil pohon biner: c procedure CreateTree(input akar: ElType, input l, r: BinTree, output p: BinTree)

Kapan Menggunakan Fungsi atau Prosedur?

• • Gunakan fungsi ketika hasil akhir hanya berupa sebuah pohon biner, tanpa perlu manipulasi lebih lanjut.
• • Gunakan prosedur ketika pohon biner yang dihasilkan memerlukan penanganan lebih lanjut (misalnya, manipulasi node).

Pendekatan ini membantu membedakan tujuan kode Anda: apakah untuk mendapatkan hasil langsung (immutable seperti fungsi) atau untuk manipulasi lanjutan (mutable seperti prosedur).

3 parameter sama, tapi sebagai outputnya kalau tadi berbentuk BinTree kalau ini berbentuk p yang bisa di passing/assign

nanti fungsi Tree akan menyambungkan antara inputan Akar ke subpohon kiri L dan subphon kanan R

bintree yang dihasilkan di representasikan oleh sebuah parameter output P

akan menghasilkan bintree

bisa disebut BinTree juga pada dasarnya BinTree di definisikan juga sebagai Address

Cara akses nya: Akar(P), Left(P), Right(P)

pointer terhadap sbuah simple

tidak pernah punya subpohon kiri

tidak pernah punya subpohon kanan

anak dari simpul makk 2 gabisa lebih

intinya bisa punya akar yang di dalamnya ada subpohon kiri dan subpohon kanan

jir

dari subpohon kiri, subpohon kanan, lalu akar

prefix simbol akar di awal, diikuti subpohon kiri, dan subpohon kanan

Misal pada level 2 maxnya 2, level 3 maxnya 4

Maksimum sub-pohon = N-aire

yg paling atas

subpohon kalau diambil sebenernya pohon juga, yang punya akar, dan subpohon juga

ini berarti untuk MK_DOS

• relasi ⟨Dosen, MataKuliah⟩ {atau relasi mengajar}.
• struktur nodenya, elemen satu nunjuk ke matkul, 2 ke dosen, 3 next

INI MK_DOS

relasi hubungan mengajar dipisah

Sebuah mata kuliah bisa diajar lebih dari 1 dosen

• List biru: list dosen
• List hijau: penghubung yang menunjukkan hubungan "mengajar" ke mata kuliah
• List merah: mata kuliah

kinerja sama aja

kinerja lebih baik

akan memberikan kinerja yg lebih baik untuk fitur ini

ada kondisional cek apakah ortu nya sama dengan pegawai yang lagi di iterasi

first ada dua biji

ada pointer ke ayah

FirstPeg menunjuk ke pegawai pertama

• Pegawai A akan mempunyai anak X dan Y, maka list anak akan kebawah muncul dari list pegawai
• Jadi ada dua pointer, satu buat hubungan dan satu buat next. Tapi list disatukan

Kalo ini list anak dan pegawai dipisahkan, list anak akan menunjuk ke list pegawai yang sesuai. Jadi ada dua pointer, satu buat hubungan dan satu buat next.

REgular graph dan graph lain yang ga ngestate jenis directed/undirected berarti APPLY KE KEDUA JENIS TERSEBUT.

alokasi node

ada 3 node yang masuk ke no 5

tidak ada 1 busur yang masuk ke node 1

• karena simpul ada 5, maka punya leader list yang elemennya ada 5. trailer list itu kotak dua kbawah yang ada 4 dan 1 di paling bawah.

• trailer list akan menyatakan seluruh busur yang menghubungkan antara node tersebut ke node yang lain

• contohnya node 1, nunjuk ke 2 dan 3. maka akan punya 2 trailer list yang menunjuk ke 2 dan 3

meyimpan simpul dan list simpul yang terhubung dengannya

jumlah simpul ada 6, maka node ada 6

karna banyak node 6, maka matriks nya 6x6

menghasilkan list of node yang berisi daftar simpul yang bertetangga dengan v

parameter

kebalikan dari undirected graph (ga ada arah), a->k k->a diasumsikan sama aja

contoh string

setelah selesai buat phon kanan akan menunjuk kurung tutup, dan harus di advance lagi

kalo udh ketemu kurung buka sudah siap memanggil fungsi yang sama dengan parameter left dari T, setelah left terbentuk panggil dengan parameter right

maju ke idx slanjutnya, dalam representasi list ini setelah abjad adalah karakter kurung buka,

ciptakan node dengan abjad yang ditunjuk idx

abjad

mirip ADV

idx menunjuk ke index dari string st, index akan berada di awal string. seiring dipanggilnya void yg sama, idx bergerak ke kanan dan pohon dibangun secara rekursif

string yg digunakan

yg tadi ya jadi diluar build tree

akan memanggil prosedur yg sama dengan parameter Left dari T dan setelah selesai untuk Right dari T.

abjad

start mesin karakter akan dipanggil oleh prosedur yang memanggil build tree (di kode lain sblm fungsi ini)

dalam typedef gaada parent: Address

currentParrent == Nil artinya ptr akan menjadi akar dari pohon kita

awal pembangunan pohon

naik

sebenarnya sudah selesai dengan subpohon kanan, waktunya naik

kondisi insertkiri, C1 != ')' kalo kanan berarti sama dengan

abjad

apakah node akan disisipkan sebagai subpohon kiri atau subpohon kanan

valuenya x

alokasi

jadi ada dua window di mesin karakter (mesin couple)

TAMBAHAN

BARIS KEDUA

subpohon kanan DIBARIS KEDUA

pokonya kalo baris pertama selalu kiri, max ada 2 baris dan di baris kedua itu sub pohon kanan

subpohon kanan A

subphon kiri A

sub phon kanan kosong

subpohon kiri kosong

janlup ini juga

ketika dah ditemukan anak terbesar

supaya dapat anak terbesar

akan mencari anak terbesar dari subpohon kiri yang dimiliki oleh q

q punya subpohon kiri, set p jadi kiri dari q (anak dari subpohon kiri dari q akan dimasukkan kedalam p)

q punya subpohon kanan, set p jadi right dari q (anak dari subpohon kanan dari q akan dimasukkan kedalam p)

cek apakah q dgn kondisi dibawah

kalo daun, set p jadi NIL

kiri mas

node yang akan dihapus

copy nilai 8 ke 10 lalu hapus node 8

sama, node 3 dicopy ke posisi 5, lalu yg node 3 dihapus

lebih rumit karena 13 harus dipindah menggantikan posisi node bervalue 15, caranya 1. copy nilai node 13 ke 15 2. hapus node 13

p itu akar, kiri kalo lebih kecil dari p, kanan kalo lebih gede dari p

kalo sama (muncul lebih dari sekali) count di increment

value dari node

melakukan insert node pada BST

kalau key muncul > 1 ada field count yang akan mencatat banyaknya kemunculan nilai tersebut

value

urutan isi elmen itu kiri < akar <= kanan

jadi definisi rekursif

pohon biner

Menyambungkan dengan elemen akar yang dibuat setelah subpohon terbuat

• 1 (akar)

alokasi berhasil

banyak node di sisi kiri L dan sisi kanan R

basis0

banyak node yang akan dibuat

apa ini lek

apa

maksud mengubah apa?

banyak blok yang di kosongkan

indeks awal yang akan dijadikan kosong

beda sama FF di case C yaitu yang di dealokasi yang <17,3> karena better (Sama dengan)

ini kalo ga nemu samsek

intinya bedanya FF dan BF itu kalo FF lgsg stop pas nemu yang fit kalo BF dibandingin dulu lalu dipilih yang terbaik untuk fit

cari sluruh elemen kosong di block apakah ada yang memenuhi syarat >= x, kalo gaada yg mendekati x aja

• Awalnya kosong smua Nb = 20 lalu dialkoasi 3 jadi 17 (kasus 1)
• Kasus kedua ada yg exact sama, jadi <5,10> di dealokasi sehingga list zone kosong berubah
• Hanya ada yang lebih besar, jadi dikurang di bagian <5,10>

Akses isian alamat Aw(P) (harusnya index)

Nb(P) = Nb(P) - x * Aw(P) di set karena ketemu* *

update ukuran tsb - x

bentuk utama list berkait (satu kesatuan dianggap zone). ketika diawal karena semua kosong jadi <1,NB> (nb semua blok kosong) <blok ke berapa, jmlh blok kosong>

banyak blok dalam zone kosong

indeks awal

tipe block untuk sebuah zone

ISINYA LIST ZONE KOSONG AJA, tiap zone akan jadi elemen list

BEDANYA YANG DISIMPAN ITU HANYA BLOK KOSONG NYA

jadi kaya swap, kosong bakal dituker ke kiri, yang true otomatis ke kumpul ke kanan

cari dulu berapa banyak NKosong

hitung banyak block kosong per zona kosong

beneran cari traversal ke seluruh blok sampe ada yg sama atau mendekati ke X

intinya kalo dah ketemu yg cukup lgsg gas

begitu ketemu sama zone yang sesuai dengan yang diharapkan (ada aja yg kosong, misal X 5 dan zonenya tersedia), langsung pake zone tersbut untuk di alokasikan. tanpa ada pengecekan mana yg paling ok (efisien)

IAw (indeks awaL) merupakan alamat indeks awal dari memori yg berhasil di alokasikan

menyatakan banyaknya blok yang akan di alokasikan

banyak blok memori

blok kosong yg false smua (kondisi awal)

Alokasi: mengurangi zone bebas Dealokasi: menambah zone bebas

• F: memori kosong/blok kosong
• T : terisi
• NB Blok: banyak blok yg dikelola

jadi kalo ada request 2 blok bakal cari emang exact 2 blok (kalo 4 blok diambil 2 doang gaakan mau karena bakal ga efisien dan ngerusak selanjutnya) jadi dicari yang eksak sama. (ini bestfit)

yg langsung ketemu di awal (firstfit)

best bakal iterasi sampe ujung kalo first yaudah sampe yang ada fit doang

isinya loop yg berisi pilihan dan user milih mau make operasi yang mana

mengisi dengan 0

buat sisip elemen

Alokasi dan dealokasi

menunjuk ke suku pertama

TANYAIN DAH KAPAN BISA PAKE MAKRO GINI KAPAN HARUS ->

GOBLOK WKWK TERNYATA PANAH KE ATAS KHUSUS TIPE DATA ADDRESS

kontigu/array

insertLast

koefisien jadi minus karena P2 dikurang basically 0-P2 jadi mines (-)

Bergantian sesuai urutan

P2 ga next karena degree ga sama

Operasi penjumlahan kalau degree sama

bergerak ke elemen selanjutnya masing masing (P1 dan P2)

PENYISIPAN SESUAI URUTAN MENURUN

menempati posisi pertama karna SELALU TERURUT MENURUN

MARK

kita punya list yang beneran kosong, kalo array kan di declare dulu semuanya tapi gaada isinya aje/0

Maka gaakan efisien dengan berkait karena tiap degree yang sama jika muncul kembali akan disimpan di tempat terpisah.

kenapa P3 gaperlu di populate?

ini emang jadi array baru (yang berbeda)

degree terbesar bisa berubah kalo derajat 9 jadi 0/habis (berubah jadi 8)

karena derajat paling tinggi

index sekalian derajat pollinom

koefisien polinom

menyatakan pangkat tertinggi yang dapat disimpan dalam polinom ini

x^3 sebenernya ada tapi 0, tapi mending ga ditulis biar kalo pangkat nya gede banget ga ribet nulisnya

dequeue bakal sama aja intinya

SELALU INGET KALO BIKIN NEWNODE BIKIN CASE KALO ALOKASI GAGAL (p == NIL)

list biasa yang cocok, first menunjuk ke elemen pertama list, first nil kalau kosong, first berubah menjadi top dan top menunjuk ke top stack, top bernilai nil kalau stack kosong

selalu ada di satu elemen di belakang last

mencari first beneran

bukan elemen terakhir

selama last bukan Last beneran (karna di traversal sampe last beneran dari awal/first)

hanya satu elemen, next ke diri dia sendiri

LAST

Elemen pertamanya dikenali oleh First(L) sedangkan elemen terakhir memiliki next ke elemen pertama (First(L))

NEXT ELEMEN SBLM LAST