Tipe dan Struktur Data

Setiap pembolehubah memerlukan jenis data — jenis nilai yang dipegangnya dan operasi yang dibenarkan:

• INTEGER — nombor bulat (42, -7). Untuk kiraan, indeks, ID.
• REAL — nombor dengan bahagian pecahan (3.14). Untuk wang, ukuran.
• STRING — watak dalam petikan ("Hello"). Untuk teks.
• CHAR — satu watak tunggal ('A').
• BOOLEAN — TRUE atau FALSE. Untuk flag.
• DATE — tarikh kalendar.

Pilih jenis yang paling tepat dan kecil yang sesuai: INTEGER untuk kiraan bulat, BOOLEAN untuk flag (bukan string "yes"/"no").

Jadual "berikan jenis data yang sesuai" ditentukan oleh bagaimana nilai digunakan: purata markah kelas ialah REAL (ia mempunyai bahagian pecahan); alamat emel ialah STRING; bilangan pelajar ialah INTEGER; sama ada pelajar telah membayar ialah BOOLEAN; tarikh lahir ialah DATE; indeks array sentiasa INTEGER; satu huruf gred ialah CHAR; nombor telefon ialah satu STRING, kerana ia bermula dengan 0 dan tidak pernah digunakan dalam aritmetik. Satu BOOLEAN digunakan untuk flag dengan hanya dua keadaan: sama ada carian telah menemui targetnya, sama ada ahli telah membayar, sama ada kerusi ditempah. Untuk jadual pengenal pasti, nama pembolehubah mesti bermakna juga: NumberOfPeople, bukan n.

Satu rekod (struktur rekod) memegang beberapa medan dengan jenis berbeza di bawah satu nama — berguna apabila beberapa nilai menggambarkan sesuatu.

TYPE TStockItem
    DECLARE ItemID : INTEGER
    DECLARE Category : STRING
    DECLARE ItemCost : REAL
    DECLARE InStock : BOOLEAN
ENDTYPE

Ini mentakrifkan jenis TStockItem; nyatakan pembolehubah daripadanya:

DECLARE Item1 : TStockItem
DECLARE Items : ARRAY[1:100] OF TStockItem

Gunakan notasi titik untuk mencapai setiap medan:

Item1.Category ← "Fruit"
OUTPUT Item1.Category, " costs ", Item1.ItemCost

Gunakan record ketika nilai selalu bersama (pelanggan, item stok); gunakan variabel terpisah untuk nilai yang tidak terkait.

Contoh terpecahkan. Sebuah klub menyimpan, untuk setiap siswa, ID siswa (string), nama, tanggal lahir, dan hingga tiga nomor klub (integer). Tulis pseudocode untuk mendeklarasikan tipe record, array untuk menampung $3000$ siswa, dan pernyataan yang menyimpan nama di elemen pertama.

TYPE Student
    DECLARE StudentID : STRING
    DECLARE Name : STRING
    DECLARE DateOfBirth : DATE
    DECLARE Club : ARRAY[1:3] OF INTEGER
ENDTYPE

DECLARE Membership : ARRAY[1:3000] OF Student
Membership[1].Name ← "Li Wei"

Nilai: TYPE dengan pengenal dan ENDTYPE; setiap field dideklarasikan dengan tipe yang sesuai; array dideklarasikan dengan batasnya dan OF Student; field dicapai dengan indeks dan titik. Pertanyaan "nyatakan kesalahan dalam deklarasi record" biasanya menunjuk pada missing ENDTYPE, field tanpa tipe, atau field yang dideklarasikan sebagai STRING yang harus menampung aritmatika. Dua konvensi mendapat nilai sendiri: elemen yang tidak digunakan ditandai dengan nilai yang tidak mungkin menjadi data asli (string kosong, -1, ID 0), dan praktik baik adalah menggunakan marker yang sama di mana saja agar setiap modul dapat mengenali slot yang tidak digunakan; field klub yang tidak digunakan adalah 0. Manfaat array dari record, untuk "nyatakan tiga manfaat": semua data satu entitas disimpan di bawah satu pengenal; field dapat memiliki tipe data berbeda; satu array menggantikan beberapa array paralel yang harus dijaga kesesuaiannya; seluruh set dapat diproses oleh satu loop atau dilewatkan sebagai satu parameter; dan menambahkan field hanya mengubah definisi tipe. Untuk satu pelanggan, struktur yang sesuai adalah record (field dengan tipe berbeda di bawah satu nama); untuk semua pelanggan adalah array dari record.

Sebuah array adalah kumpulan items yang teratur dari tipe yang sama, di bawah satu nama, dicapai melalui indeks.

• elemen — satu item dalam array.
• batas — indeks valid terendah dan tertinggi.
• dimensi — 1-D (daftar), 2-D (tabel), dll.
• batas bawah dan batas atas — indeks valid pertama dan terakhir; jumlah elemen adalah batas atas dikurangi batas bawah ditambah satu, dan untuk array 2-D adalah hasil kali kedua jumlah tersebut.

Jadi dalam ThisArray[n] ← 42 array memiliki satu dimensi, indeks adalah variabel n (sebuah INTEGER), dan elemen pada indeks itu menerima 42. Sebelum array dapat dideklarasikan Anda perlu tipe data-nya serta batasnya. Untuk mendeklarasikan $120$ nilai yang mungkin mencakup desimal: DECLARE Data : ARRAY[1:120] OF REAL; tabel string $150$-baris, dua-kolom: DECLARE Data : ARRAY[1:150, 1:2] OF STRING, yang memiliki $300$ elemen. Manfaat array dibandingkan variabel terpisah, untuk menjelaskan bernilai dua: satu pengenal daripada tiga puluh; elemen dapat diproses oleh loop dengan indeks sebagai counter; ukuran mudah diubah; dan seluruh set dapat dilewatkan ke modul sebagai satu parameter. Array juga dapat menggantikan rantai pernyataan seleksi: DaysInMonth[Month] melihat jawaban langsung alih-alih十二个 IF klausa, yang lebih pendek, lebih cepat ditulis, dan lebih mudah dirawat.

Array 1-D

DECLARE Names : ARRAY[1:5] OF STRING
Names[3] ← "Cara"
OUTPUT Names[3]

Proses setiap elemen dengan loop FOR:

FOR i ← 1 TO 5
    OUTPUT Names[i]
NEXT i

Array 2-D (array 2D)

DECLARE Grid : ARRAY[1:3, 1:4] OF INTEGER
Grid[2, 3] ← 99

Indeks pertama adalah baris, kedua adalah kolom. Gunakan loop bersarang untuk mengunjungi setiap sel. Gunakan 1-D untuk satu urutan tunggal, 2-D untuk dua dimensi alami (grid, baris × kolom).

Operasi umum

Sebuah pencarian linear memeriksa setiap elemen hingga ditemukan:

FOR i ← 1 TO n
    IF A[i] = Target THEN
        OUTPUT "Found at ", i
    ENDIF
NEXT i

Untuk menemukan jumlah, hitungan, maksimum, atau minimum, atur variabel berjalan lalu sikat melintasinya:

Max ← A[1]
FOR i ← 2 TO n
    IF A[i] > Max THEN
        Max ← A[i]
    ENDIF
NEXT i

Sebuah bubble sort mengurutkan array: lewati membandingkan setiap pasangan bersebelahan dan menukar apa pun yang tidak sesuai urutan; ulangi lewatan hingga satu lewatan tidak melakukan penukaran.

Ujian Paper 2 meminta algoritma ini baik sebagai pseudocode maupun sebagai langkah-langkah dalam kata-kata, dan terkadang dalam bentuk "efisien" mereka:

• Nilai terbesar: atur Largest ke elemen pertama; untuk setiap elemen tersisa, jika lebih besar dari Largest, simpan dalam Largest; setelah loop output Largest. Untuk posisi terbesar, simpan variabel kedua yang menyimpan indeks setiap kali Largest berubah.
• Pencarian linear mengembalikan posisi: atur FoundAt ← -1 sebelum loop (nilai yang tidak pernah bisa menjadi indeks valid, sehingga berarti "tidak ditemukan"); loop melintasi array; ketika elemen cocok, simpan indeks dan tinggalkan loop; setelah loop uji FoundAt.
• Hitung atau output elemen non-blank: bandingkan setiap elemen dengan marker elemen tidak digunakan ("" atau -1) dan hitung atau output hanya yang berbeda.
• Hapus item: temukan indeksnya dengan pencarian linear; geser setiap elemen berikutnya satu tempat menuju awal, sehingga celah tertutup; tandai elemen terakhir sebagai tidak digunakan (atau kurangi hitungan).
• Sisipkan ke array terurut: temukan indeks pertama yang elemennya lebih besar; geser elemen itu dan setiap elemen berikutnya satu tempat menuju akhir; simpan nilai baru di celah.
• Bubble sort efisien: flag Swapped agar lewatan berhenti segera setelah lewatan tidak melakukan penukaran, dan batas atas yang turun satu setiap lewatan karena nilai terbesar telah mencapai ujung.

REPEAT
    Swapped ← FALSE
    FOR Index ← 1 TO Limit - 1
        IF Data[Index] > Data[Index + 1] THEN
            Temp ← Data[Index]
            Data[Index] ← Data[Index + 1]
            Data[Index + 1] ← Temp
            Swapped ← TRUE
        ENDIF
    NEXT Index
    Limit ← Limit - 1
UNTIL Swapped = FALSE

Nilai diberikan untuk loop luar yang berulang hingga tidak ada lagi pertukaran, penanda yang diatur di dalam IF, tiga baris pertukaran dengan variabel sementara, dan batas yang menyusut. Pengurutan dalam "langkah" (penyempurnaan bertahap) adalah: ulangi hingga terurut; pada setiap kali lewat bandingkan pasangan bersebelahan; tukar pasangan yang tidak sesuai urutan; setelah setiap kali lewat nilai terbesar yang belum terurut berada di posisi terakhir. Dua array 1-D berisi rekaman atau data paralel diproses dengan satu loop dan satu indeks; array 2-D memerlukan loop bersarang, loop luar untuk baris dan loop dalam untuk kolom, dan pencarian di satu baris menetapkan indeks baris dan melakukan loop melalui kolom.

Sebuah berkas adalah data yang disimpan pada penyimpanan sekunder, tersimpan antar jalannya program. Variabel di RAM hilang saat program berakhir, jadi untuk menyimpan data secara permanen (skor tertinggi, catatan, pengaturan), program menulis ke sebuah berkas. Berkas juga memungkinkan program berbagi data dan memulai ulang dari keadaan yang tersimpan.

*Variabel di RAM lenyap saat program berakhir; berkas di disk bertahan antar jalannya

Sebuah berkas teks berisi satu atau lebih baris karakter yang dapat dibaca; program membaca dan menulis berkas teks per baris. Buka berkas sebelum digunakan dan tutup setelahnya:

OPENFILE "data.txt" FOR READ      // or FOR WRITE, FOR APPEND
WHILE NOT EOF("data.txt") DO
    READFILE "data.txt", LineString
    OUTPUT LineString
ENDWHILE
CLOSEFILE "data.txt"

EOF menguji akhir berkas sebelum membaca. Untuk menulis:

OPENFILE "log.txt" FOR WRITE
FOR i ← 1 TO 100
    WRITEFILE "log.txt", "Event " & i
NEXT i
CLOSEFILE "log.txt"

Selalu tutup setiap berkas—jika tidak, penulisan yang terbuffer mungkin hilang dan program lain mungkin terkunci.

Mengapa berkas (dua nilai): data tersimpan setelah program berakhir, sehingga tersedia saat program dijalankan berikutnya; dapat dibagikan dengan program lain; dan dapat menampung lebih banyak daripada muatan memori. Ciri khas berkas teks yang memungkinkan program memprosesnya adalah bahwa berkas tersebut merupakan sekuens baris, dibaca satu per satu dari awal. Tiga mode: READ untuk membaca dari awal; WRITE untuk membuat berkas baru, yang menghapus semua isi yang ada, sehingga tidak dapat digunakan untuk menambahkan ke berkas; APPEND untuk menambahkan baris di akhir berkas yang sudah ada. Uji EOF sebelum setiap pembacaan, dan buka berkas hanya sekali, bahkan ketika beberapa modul menggunakannya.

Contoh pengerjaan. Tulis pseudokode untuk prosedur LastLines(FileName : STRING) yang menampilkan tiga baris terakhir dari sebuah berkas teks, dalam urutan.

PROCEDURE LastLines(BYVAL FileName : STRING)
    DECLARE LineX, LineY, LineZ : STRING
    LineX ← ""
    LineY ← ""
    LineZ ← ""
    OPENFILE FileName FOR READ
    WHILE NOT EOF(FileName) DO
        LineX ← LineY
        LineY ← LineZ
        READFILE FileName, LineZ
    ENDWHILE
    CLOSEFILE FileName
    OUTPUT LineX
    OUTPUT LineY
    OUTPUT LineZ
ENDPROCEDURE

Setiap baris baru mendorong tiga baris sebelumnya, sehingga saat berkas berakhir, tiga variabel memegang tiga baris terakhirnya; berkas dengan baris kurang akan menampilkan string kosong. Untuk menampilkan lima baris pertama, hitung jumlah baris yang dibaca dan hentikan loop pada lima atau pada EOF, mana yang terjadi lebih dulu; berkas yang kosong dideteksi oleh EOF sebagai TRUE segera setelah dibuka.

Bidang dalam baris. Sebuah berkas teks berisi string, jadi rekaman ditulis sebagai satu baris dengan bidangnya digabungkan oleh karakter pemisah, dan setiap angka atau Boolean dikonversi dengan NUM_TO_STR (dan dibaca kembali dengan STR_TO_NUM, atau dengan membandingkan dengan "TRUE"). Pilih pemisah yang tidak pernah muncul dalam data: koma atau | untuk nama dan angka, jangan gunakan spasi ketika nama mungkin mengandung spasi. Jika suatu bidang dapat berisi karakter apa pun, pemisah dapat tertukar dengan data; solusinya adalah meletakkan setiap bidang di barisnya sendiri, atau menulis panjang bidang sebelum isinya. Satu item per baris mudah dibaca kembali tetapi memakan lebih banyak baris dan membuat rekaman sulit terlihat sebagai satu kesatuan. Membaca berkas yang barisnya memiliki urutan yang diketahui (naik berdasarkan ID) memungkinkan pencarian berhenti segera setelah ID yang lebih besar dibaca, alih-alih membaca sampai akhir. Berkas simpan yang dibuat setiap kali permainan disimpan memerlukan nama berkas yang bermakna, misalnya nama pemain dan tanggal serta waktu, sehingga simpanan sebelumnya dapat dikembalikan.

*Satu baris berkas teks adalah satu rekaman: bidang-bidang digabungkan oleh pemisah, dikonversi ke jenisnya saat dibaca kembali

*Daftar terhubung: sisipkan dengan menyambungkan ulang pointer

*Tumpukan vs antrean: LIFO dan FIFO

Sebuah Tipe Data Abstrak (ADT) adalah kumpulan data beserta operasi di atasnya, didefinisikan oleh apa yang dilakukannya, bukan bagaimana cara menyimpannya. Pengguna hanya bekerja melalui operasi; implementasinya disembunyikan, sehingga dapat berubah tanpa mempengaruhi kode yang menggunakan ADT. Hafal tiga: tumpukan, antrean, daftar terhubung.

Definisi satu nilai: ADT adalah kumpulan data bersama dengan set operasi pada data tersebut. Tumpukan, antrean, daftar terhubung, pohon biner, dan array semuanya adalah ADT. Untuk membenarkan pilihan: antrean ketika item harus ditangani dalam urutan kedatangannya (pekerjaan cetak, penekanan tombol, pelanggan di toko), karena sifat first in, first out; tumpukan ketika item terbaru harus ditangani pertama (undo, menjelajahi halaman web kembali, membalikkan urutan, alamat return dari pemanggilan bersarang), karena sifat last in, first out; daftar terhubung ketika item disisipkan dan dihapus di tengah urutan yang sering terjadi, karena hanya pointer yang berubah dan tidak ada yang perlu digeser. Untuk membandingkan tumpukan dan antrean: keduanya adalah struktur linear dari item dengan urutan, keduanya diimplementasikan dengan array dan pointer, dan keduanya memerlukan pengecekan penuh sebelum menambahkan dan kosong sebelum menghapus; tumpukan memiliki satu pointer dan menambahkan serta menghapus di ujung yang sama, antrean memiliki dua pointer dan menambahkan di satu ujung serta menghapus di ujung lainnya.

Tumpukan

Sebuah tumpukan bekerja dalam urutan LIFO (Last In, First Out). Operasi: push (tambahkan ke atas), pop (hapus dari atas), peek (lihat bagian atas), dan tes untuk kosong/penuh. Kegunaan: riwayat undo, alamat return pemanggilan fungsi, parsing ekspresi, backtracking.

Contoh terpecahkan. Sebuah tumpukan karakter menyimpan, dari bawah, 'P', 'N', 'Z', 'X', 'Y', 'W', dengan pointer top-of-stack di 'W' (lokasi memori 202 dari 200–207). Operasi POP, POP, PUSH 'A', PUSH 'B', POP dilakukan. Apa yang ada di tumpukan, dan ke mana pointer menunjuk?

Dua pops menghapus 'W' kemudian 'Y'; pushes menambahkan 'A' kemudian 'B' menggantinya; pop terakhir menghapus 'B'. Stack sekarang berisi 'P', 'N', 'Z', 'X', 'A' dan pointer berada di 'A', lokasi 203. Nilai yang telah berada di stack paling lama adalah item terendah, 'P'; maksimal lima pops tambahan mungkin dilakukan sebelum stack kosong, dan pop pada stack kosong adalah kesalahan, oleh karena itu Pop() memeriksa apakah kosong terlebih dahulu. Fungsi Push() yang mengembalikan TRUE jika berhasil pertama-tama memeriksa apakah pointer berada di bagian atas array (penuh) dan mengembalikan FALSE jika ya. Elemen array tidak perlu diinisialisasi sebelum digunakan, karena pointer saja menunjukkan elemen mana yang sedang digunakan.

Antrean

Sebuah antrean bekerja dalam urutan FIFO (First In, First Out). Operasi: enqueue (tambahkan ke belakang), dequeue (hapus dari depan), dan tes untuk kosong/penuh. Kegunaan: spooling pencetakan, penjadwalan, pencarian breadth-first, buffering.

Untuk mendeskripsikan penambahan item: periksa bahwa antrean tidak penuh; simpan item di posisi yang diberikan oleh pointer akhir-antrean; tingkatkan pointer akhir (dan hitung). Untuk mendeskripsikan penghapusan: periksa bahwa antrean tidak kosong; baca item di pointer depan; tingkatkan pointer depan (dan kurangi hitung). Nyatakan konvensi yang Anda gunakan: jika pointer akhir menandai ruang bebas berikutnya, front dan end pointer yang sama berarti antrean kosong; jika menandai item terakhir, pointer yang sama berarti satu item. Dalam antrean linear, pointer depan hanya pernah bergerak maju, sehingga sel di belakangnya terbuang; itulah yang diperbaiki oleh antrean melingkar di bawah ini. Dua fitur antrean untuk dinyatakan: item ditambahkan di belakang dan dihapus dari depan, sehingga item pertama yang ditambahkan adalah yang pertama dihapus.

Daftar terhubung

Sebuah daftar terhubung menyimpan data sebagai sequence dari node. Setiap node memegang nilai dan pointer ke node berikutnya; pointer head menandai awal, dan pointer node terakhir adalah sentinel (mis. NULL). Operasi: insert, delete, search, dan traverse ( kunjungi setiap node secara berurutan). Keunggulannya dibandingkan array adalah inserci/deletion murah (cukup sesuaikan pointer); kekurangannya adalah akses acak lambat (Anda harus mengikuti pointer dari head).

Menyisipkan node secara berurutan (empat poin): telusuri daftar dari kepala, mengikuti pointer, hingga node sebelum posisi ditemukan (node terakhir yang nilainya lebih kecil); ambil node bebas dan simpan nilai baru di dalamnya; atur pointer node baru ke alamat yang ditunjuk oleh node sebelumnya; atur pointer node sebelumnya ke node baru. Jika nilai baru harus berada di depan, pointer kepala diubah sebagai gantinya. Menghapus node: cari node sebelumnya, lalu atur pointer node tersebut ke alamat yang ditunjuk oleh node yang dihapus, sehingga daftar melewatinya; node yang dibebaskan kembali ke daftar bebas. Dibandingkan dengan array 1-D, menyisipkan atau menghapus pada linked list tidak memerlukan pergeseran item lainnya, dan daftar dapat tumbuh hingga memori habis; biayanya adalah pointer tambahan yang disimpan bersama setiap item, serta fakta bahwa mengakses item ke-$n$ berarti mengikuti $n$ pointer, karena tidak ada indeks langsung.

Stack menggunakan array

Simpan item dalam Stack[1:MaxSize] dengan integer Top (0 saat kosong).

• Push(x): jika Top = MaxSize stack penuh (overflow); selain itu Top ← Top + 1; Stack[Top] ← x.
• Pop(): jika Top = 0 maka stack kosong (underflow); sebaliknya kembalikan Stack[Top] dan Top ← Top - 1.

Queue menggunakan array melingkar

Queue sederhana memungkinkan Front dan Rear berjalan melewati akhir, memboroskan bagian awal. Solusinya adalah array melingkar — ketika pointer mencapai MaxSize ia akan melingkari kembali ke 1:

• Enqueue(x): cek penuh; selain itu Rear ← (Rear MOD MaxSize) + 1; Queue[Rear] ← x.
• Dequeue(): cek kosong; selain itu kembalikan Queue[Front] dan Front ← (Front MOD MaxSize) + 1.

Lacak hitungan terpisah untuk membedakan antara kosong dan penuh.

Algoritma untuk pointer akhir, dalam kata-kata: jika hitungan sama dengan ukuran, laporkan bahwa queue penuh dan hentikan; selain itu tambahkan satu pada pointer akhir; jika sekarang melebihi indeks terakhir, tetapkan ke indeks pertama; simpan item di sana dan tambahkan satu pada hitungan. Deklarasi yang diperlukan untuk jawaban "deskripsikan deklarasinya dan inisialisasinya" bernilai lima poin: array dengan ukurannya dan tipe elemennya; pointer front dan pointer end, keduanya diinisialisasi ke indeks pertama (atau front ke indeks pertama dan end ke ruang bebas berikutnya); dan hitungan item, diinisialisasi ke $0$.

Sebagai contoh, dengan MaxSize = 6: jika Rear = 5, maka (5 MOD 6) + 1 = 6, sehingga item berikutnya masuk ke sel 6; jika Rear = 6, maka (6 MOD 6) + 1 = 1, sehingga pointer berlingkari kembali ke sel 1.

Linked list menggunakan array

Gunakan array dari record, masing-masing memiliki Next indeks:

TYPE TNode
    DECLARE Value : INTEGER
    DECLARE Next : INTEGER     // index of the next node, or -1 for end
ENDTYPE

DECLARE Nodes : ARRAY[1:MaxSize] OF TNode
DECLARE Head : INTEGER         // index of first node, -1 if empty
DECLARE FreeListHead : INTEGER // first available free node

Daftar bebas merantai slot yang tidak terpakai, sama seperti daftar data merantai slot yang digunakan. Untuk menyisipkan: ambil slot dari FreeListHead, atur nilai dan Next node baru, dan perbarui Next node sebelumnya (atau Head). Untuk menghapus: putuskan rantai node dan kembalikan slotnya ke daftar bebas. Ini memberikan fleksibilitas struktur linked dengan alokasi statis array.

Contoh terpecahkan. Daftar terhubung disimpan dalam array Data dan array Pointer, dengan Start menunjuk ke indeks 1. Daftar tersebut adalah 1 → 3 → 4 (indeks 1 berisi D40, indeks 3 berisi D32, indeks 4 berisi D11, pointer-nya adalah $\emptyset$); daftar bebas dimulai dari indeks 2 dan berlanjut 2 → 5. Masukkan D6 di antara D32 dan D11.

Ambil node bebas pertama, indeks 2, dan atur FreeStart ke pointer-nya, yaitu 5; simpan D6 dalam Data[2]; atur Pointer[2] ke nilai Pointer[3] yang dipegang, yaitu 4; atur Pointer[3] menjadi 2. List membaca 1 → 3 → 2 → 4 dan free list adalah 5 → $\emptyset$. Jawaban untuk "bagaimana linked list dapat diimplementasikan" adalah tepat bagian-bagian ini: array (atau array dari record) untuk data, array paralel untuk pointer yang memegang indeks, pointer mulai, pointer daftar bebas, dan nilai null seperti $-1$ untuk akhir.

Contoh terpecahkan. Antrian melingkar disimpan dalam array berukuran 5 (indeks 0 hingga 4) dengan Front = 3, Rear = 3, dan satu item tersimpan. Dua item ditambahkan, lalu dua item dihapus. Di mana letak pointer-nya, dan mengapa menggunakan antrian melingkar sama sekali? Setiap perpindahan menggunakan (pointer + 1) MOD size, sehingga pointer berlipat. Menambahkan dua kali memindahkan Rear: $3 \rightarrow 4$, kemudian $4 \rightarrow 0$ (karena $(4+1) \bmod 5 = 0$), sehingga Rear = 0 dan tiga item tersimpan. Menghapus dua kali memindahkan Front dengan cara yang sama: $3 \rightarrow 4$, kemudian $4 \rightarrow 0$, menyisakan Front = 0 dan satu item. Lipatan adalah inti utamanya: dalam antrian array linear, pointer bergerak menuju akhir dan ruang yang dibebaskan di bagian depan terbuang meskipun antrian kosong. Ingat bahwa antrian menghapus dari Front dan menambahkan di Rear — stack hanya menggunakan satu pointer untuk keduanya.

Pertanyaan definisi dinilai berdasarkan kata-kata tetap. Hafalkan ini persis.

• Pilih struktur data yang tepat dan berikan alasannya (record untuk bidang campuran, array 2-D untuk grid).
• Pahami cara mengimplementasikan stack, queue dan linked list menggunakan array dan pointer (top; front/rear; next).
• Bedakan ADT ( perilakunya ) dari implementasinya (array plus pointer).

Kesalahan umum

• Deklarasi record tanpa ENDTYPE, atau bidang tanpa tipe. Setiap bidang adalah baris DECLARE dengan sebuah tipe.
• Membaca melebihi akhir file, atau menulis dengan WRITE ketika file harus mempertahankan isinya. Uji EOF sebelum setiap baca; gunakan APPEND untuk menambahkan.
• Menulis angka ke file teks tanpa dikonversi. File berisi string: NUM_TO_STR keluar, STR_TO_NUM kembali.
• Melupakan pengecekan. Push dan enqueue menguji penuh terlebih dahulu; Pop dan dequeue menguji kosong terlebih dahulu, dan jawaban menyatakan hal itu.
• Kehilangan sisa daftar saat menyisipkan node. Atur pointer node baru ke node next lama sebelum mengubah pointer node sebelumnya.
• Linear search yang tidak pernah mengatakan "tidak ditemukan". Inisialisasi posisi ke $-1$ dan uji setelah loop.