Bagaimana cara membuat node awal untuk double linked list ?

Daftar Isi

1. Deklarasi Doubly Linked List

Table of Contents Show

1. Deklarasi Doubly Linked List
2. Operasi Pada Doubly Linked List
2.1. Penyisipan Simpul
2.2. Penghapusan Simpul
2.3.Pencetakan Simpul
2.4. Mencetak Linked List Secara Mundur

2. Operasi Pada Doubly Linked List

2.1. Penyisipan Simpul

2.2. Penghapusan Simpul

2.3.Pencetakan Simpul

2.4. Mencetak Linked List Secara Mundur

1. Deklarasi Doubly Linked List

typedef struct node *simpul; struct node { char Isi; simpul kanan; simpul kiri; };

Baca juga : Pengertian dan Contoh Program Struct pada C++

2. Operasi Pada Doubly Linked List

Semua operasi pada Singly Linked List juga terdapat pada operasi Doubly Linked List, yaitu Penyisipan, Penghapusan, dan Pencetakan.

2.1. Penyisipan Simpul

Penyisipa simpul adalah operasi penyisipan suatu simpul baru ke dalam suatu Doubly Linked List. Penyisipan dapat dilakukan di posisi depan, tengah, dan belakang.

1. Penyisipan Simpul Depan

Penyisipan simpul baru selalu berada di posisi paling depan. Penyisipan simpul depan dapat dilakukan dengan langkah berikut:

Ciptakan simpul baru.
Jika Linked List (DL) belum ada maka simpul baru menjadi Linked List (DL=Baru).
Tetapi jika Linked List (DL) sudah ada maka penyisipan dilakukan dengan:
- Pointer kanan dari baru menunjuk DL (Baru->Kanan = DL).
- Pointer kiri dari DL menunjuk baru (DL->Kiri = Baru).
- Pointer DL dipindahkan menunjuk simpul baru (DL = Baru).

Gambar 3. Penyisipan Simpul Depan dengan DL. Tidak Kosong

Fungsi penyisipan simpul depan dengan mengikuti langkah-langkah dan gambar 3 di atas dapat dilihat berikut ini.

void Sisip_Depan(simpul &DL, char elemen) { simpul baru; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) DL=baru; else { baru->kanan = DL; DL->kiri = baru; DL=baru; } }

2. Penyisipan Simpul Belakang

Penyisipan simpul baru selalu berada di posisi paling belakang. Penyisipan simpul belakang dapat dilakukan dengan dua cara, yaitu dengan menggunakan pointer bantu dan tanpa pointer bantu. Penyisipan simpul pada Doubly Linked List tidak mengharuskan menggunakan pointer bantu karena walaupun menggerakkan DL tidak mengakibatkan adanya simpul yang hilang. Hal ini dapat terjadi karena semua simpul saling menunjuk atau saling berhubungan.

a. Penyisipan dengan pointer bantu

Ciptakan simpul baru.
Jika Linked List (DL) belum ada maka simpul baru menjadi Linked List (DL=Baru).
Tetapi jika Linked Lis (DL) sudah ada maka penyisipan dilakukan dengan:
- Buat pointer bantu yang dapat digerakkan (Bantu=DL).
- Gerakkan pointer bantu hingga simpul terakhir (while(Bantu->Kanan != NULL) Bantu=Bantu->Kanan).
- Pointer kanan simpul bantu menunjuk baru (Bantu->Kanan = Baru).
- Pointer kiri baru menunjuk bantu (Baru->Kiri = Bantu).

Penyisipan simpul belakang dengan DL kosong sama seperti penyisipan simpul depan dengan DL kosong (Gambar 3), tetapi operasi penyisipan simpul belakang untuk kasus DL tidak kosong dapat dilihat pada gambar 4.

Gambar 4. Operasi Penyisipan Simpul Belakang dengan Pointer Bantu

Fungsi penyisipan simpul belakang dengan mengikuti langkah-langkah dan gambar 4 di atas dapat dilihat berikut ini.

void Sisip_Belakang(simpul &DL, char elemen) { simpul baru, Bantu; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) DL=baru; else { Bantu = DL; while (Bantu->kanan!=NULL) Bantu=Bantu->kanan Bantu->kanan = baru; baru->kiri = Bantu; } }

b. Penyisipan tanpa pointer bantu

Ciptakan simpul baru.
Jika Linked List (DL) belum ada maka simpul baru menjadi Linked List (DL=Baru).
Tetapi jika Linked List (DL) sudah ada maka penyisipan dilakukan dengan:
- Gerakkan Pointer DL hingga simpul terakhir (while(DL->Kanan != NULL) DL=DL->Kanan).
- Pointer kanan DL menunjuk baru (DL->Kanan = Baru).
- Pointer kiri b aru menunjuk DL(Baru->Kiri = DL).
- Gerakkan Pointer DL hingga simpul pertama (while(DL->Kiri != NULL) DL=DL->Kiri).

Gambar 5. Operasi Penyisipan Simpul Tanpa Pointer Bantu

Fungsi penyisipan simpul belakang dengan mengikuti langkah-langkah dan gambar 5 di atas dapat dilihat berikut ini.

void Sisip_Belakang(simpul &DL, char elemen) { simpul baru; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) DL=baru; else { while (DL->kanan!=NULL) DL=DL->kanan; DL->kanan = baru; baru->kiri = DL; while (DL->kiri!=NULL) DL=DL->kiri; } }

3. Penyisipan Simpul Tengah

Menyisipkan suatu simpul Baru diantara dua simpul. Penyisipan simpul tengah hanya dapat dilakukan jika linked list (DL) tidak kosong. Misalkan kita mempunyai dobly linked list (DL) dengan 3 simpul yang masing-masing berisi informasi C, B dan A serta simpul Baru yang akan disisipkan ditengah yang berisi informasi D (karakter). Simpul Baru akan disisipkan setelah simpul yang berisi informasi B (elemen).

a. Penyisipan dengan pointer bantu

Ciptakan simpul baru.
Buat pointer bantu yang dapat digerakkan (Bantu=DL).
Gerakkan pointer bantu hingga simpl yang berisi informasi karakter.
Kanan simpul baru menunjuk kanan bantu (Baru->Kanan = Bantu->Kanan).
Pointer kiri dari kanan bantu menunjuk baru (Bantu->Kanan->Kiri = Baru).
Pointer kanan bantu menunjuk baru (bantu->Kanan = Baru).
Pointer kiri baru menunjuk bantu (Baru->Kiri = Bantu).

Baca Juga Array pada C++ Pengertian dan Contoh Program

Gambar 6. Operasi Penyisipan Simpul Tengah dengan Pointer Bantu

Fungsi penyisipan simpul tengah dengan mengikuti langkah-langkah dan gambar 6 di atas dapat dilihat berikut ini.

void Sisip_Tengah(simpul &DL, char elemen1, char elemen2) { simpul bantu, baru; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen1; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) cout<<"List Kosong ............"<<endl; else { bantu = DL; while(bantu->kanan->Isi != elemen2) bantu=bantu->kanan; baru->kanan = bantu->kanan; baru->kiri = bantu; bantu->kanan->kiri = baru; bantu->kanan = baru; } }

b. Penyisipan simpul tengah tanpa pointer bantu

Ciptakan simpul baru.
Gerakkan pointer DL hingga simpul yang berisi informasi karakter.
Kanan simpul baru menunjuk kanan DL (Baru->Kanan = DL->Kanan).
Pointer kiri dari kanan DL menunjuk baru (DL->Kanan->Kiri = Baru).
Pointer kiri baru menunjuk DL (Baru->Kiri = DL).
Gerakkan pointer DL hingga simpul pertama.

Gambar 7. Operasi Penyisipan Simpul Tengah Tanpa Pointer Baru

Fungsi penyisipan simpul tengah dengan mengikuti langkah-langkah dan gambar 7 di atas dapat dilihat berikut ini.

void Sisip_Tengah2(simpul &DL, char elemen1, char elemen2) { simpul baru; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen1; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) cout<<"List Kosong ..........."<<endl; else { while(DL->kanan->Isi != elemen2) DL = DL->kanan; baru->kanan = DL->kanan; baru->kiri = DL; DL->kanan->kiri = baru; DL->kanan = baru; } while(DL->kiri != NULL) DL = DL->kiri; }

2.2. Penghapusan Simpul

Operasi menghapus suatu simpul dari suatu Linked List pada Doubly Linked List hampir sama dengan penghapusan simpul pada Singly Linked List, yaitu Linked List (DL) tidak boleh dalam keadaan kosong. Penghapusan simpul juga dapat dilakukan terhadap simpul depan, simpul belakang, dan simpul tengah.

1. Penghapusan simpul depan

Simpul yang dihapus selalu yang berada pada posisi depan. Misalkan kita memiliki Linked List DL, akan dilakukan penghapusan simpul depan yaitu simpul yang berisi informasi C. Langkah-langkah penghapusan simpul depan adalah sebagai berikut:

Simpul depan ditunjuk oleh pointer hapus (Hapus = DL).
Pointer DL digerakkan satu simpul ke kanan (DL = DL->Kanan).
Putuskan pointer Kiri DL dari hapus (DL->Kiri = NULL).
Putuskan pointer kanan hapus dari Linked List DL (Hapus->Kanan=NULL).

Gambar 8. Operasi Penghapusan Simpul Depan

Fungsi penghapusan simpul depan dengan mengikuti langkah-langkah dan gambar 8 di atas dapat dilihat berikut ini.

void Hapus_Depan(simpul &DL) { simpul Hapus; if(DL==NULL) cout<<"Linked List Kosong ..............."; else { Hapus = DL; DL = DL->kanan; DL->kiri = NULL; Hapus->kanan = NULL; free(Hapus); } }

2. Penghapusan Simpul Belakang

Simpul yang dihapus selalu yang berada pada posisi belakang. Misalkan kita memiliki Linked List DL terdiri dari 4 simpul dengan masing-masing berisi informasi C, B, D, dan A, akan dilakukan penghapusan simpul belakang yaitu simpul yang berisi informasi A. Dalam menghapus simpul belakang, kita dapat lakukan dengan dua cara, yaitu dengan menggunakan pointer atau tanpa menggunakan pointer bantu. Langkah-langkah penghapusan simpul belakang dengan dan tanpa bantu dapat dilakukan seperti berikut.

a. Penghapusan Simpul Belakang dengan Pointer Bantu

Buatlah pointer bantu yang menunjuk simpul pertama yang ditunjuk oleh pointer DL (Bantu = DL).
Gerakkan pointer bantu hingga satu simpul sebelum simpul belakang (while(Bantu->Kanan->Kanan != NULL) Bantu = Bantu->Kanan).
Simpul belakang yang ditunjuk pointer kanan bantuk ditunjuk juga oleh pointer hapus(Hapus = Bantu->Kanan).
Putuskan pointer kanan bantu dari simpul yang ditunjuk pointer hapus (Bantu->Kanan=NULL).
Putuskan pointer kiri hapus dari Linked List (Hapus->Kiri = NULL).

Skema penghapusan simpul belakang dapat dilihat pada Gambar 9.

Gambar 9. Operasi Penghapusan Simpul Belakang dengan Pointer Bantu

Fungsi penghapusan simpul belakang dengan mengikuti langkah-langkah dan gambar 9 di atas dapat dilihat berikut ini.

void Hapus_Belakang(simpul &DL) { simpul bantu, hapus; if(DL==NULL) cout<<"Linked List Kosong .............."; else { bantu = DL; while(bantu->kanan->kanan != NULL) bantu=bantu->kanan; hapus = bantu->kanan; bantu->kanan = NULL; hapus->kiri = NULL; free(hapus); } }

b. Penghapusan Simpul Belakang Tanpa Pointer Bantu (Versi 1)

Menghapus simpul belakang tanpa pointer bantu, dengan demikian kita cukup menggerakkan pointer DL hingga ke satu simpul sebelum simpul belakang. Setelah selesai menghapus simpul belakang kemudian pointer DL dipindahkan kembali hingga ke simpul depan.

Gerakkan pointer DL hingga simpul sebelum simpul belakang (while(DL->Kanan->Kanan != NULL) DL = DL->Kanan).
Simpul terakhir yang ditunjuk oleh pointer kanan DL ditunjuk juga oleh hapus (Hapus = DL->Kanan).
Putuskan pointer kanan DL dari simpul yang ditunjuk hapus (DL->Kanan=NULL).
Putuskan pointer kiri hapus dari simpul yang ditunjuk DL (Hapus->Kiri = NULL).
Gerakkan pointer DL hingga simpul pertama (while(DL->Kiri != NULL) DL = DL->Kiri).

Skema penghapusan simpul belakang dapat dilihat pada Gambar 10.

Gambar 10. Operasi Penghapusan Simpul Belakang Tanpa Pointer Bantu

Fungsi penghapusan simpul belakang dengan mengikuti langkah-langkah dan gambar 10 di atas dapat dilihat berikut ini.

void Hapus_Belakang(simpul &DL) { simpul hapus; if(DL==NULL) cout<<"Linked List Kosong ..............."; else { while(DL->kanan->kanan != NULL) DL=DL->kanan; hapus = DL->kanan; DL->kanan = NULL; hapus->kiri = NULL; free(hapus); while(DL->kiri != NULL) DL=DL->kiri; } }

c. Penghapusan Simpul Belakang Tanpa Menggunakan Pointer Bantu (Versi 2)

Menghapus simpul belakang tanpa menggunakan pointer bantu dan tanpa menggerakkan pointer DL. Dalam versi 2 ini kita menggerakkan pointer hapus mulai simpul depan hingga simpul belakang.

Pointer hapus menunjuk simpul depan (Hapus = DL).
Gerakkan pointer hapus hingga simpul belaakng (while(Hapus->kanan != NULL) Hapus=Hapus->Kanan;).
Putuskan pointer kanan dari kiri hapus dari hapus (Hapus->kiri->kanan = NULL).
Putuskan pointer kiri hapus (Hapus->kiri = NULL).

Gambar 11. Operasi Penghapusan Simpul Belakang Tanpa Pointer Bantu (versi 1)

Fungsi penghapusan simpul belakang dengan mengikuti langkah-langkah dan gambar 11 di atas dapat dilihat berikut ini.

void Hapus_Belakang(simpul &DL) { simpul Hapus; if(DL==NULL) cout<<"Linked List Kosong .............."; else { Hapus = DL; while(Hapus->Kanan != NULL) Hapus=Hapus->Isi; Hapus->kiri->kanan = NULL; Hapus->kiri = NULL; free(Hapus); } }

3. Penghapusan Simpul Tengah

Berbeda dengan penghapusan simpul depan dan penghapusan simpul belakang, simpul yang akan dihapus adalah pasti yang ada di depan atau yang ada di belaakng dan hanya ada masing-masing satu. Tetapi karena simpul tengah mungkin lebih dari satu simpul maka harus diketahui simpul yang mana yang akan dihapus. Misalkan kita memiliki Linked List DL terdiri dari 4 simpul dengan masing-masing berisi informasi C, B, D, dan A, akan dilakukan penghapusan simpul yang ada di posisi tengah (simpul yang berisi informasi B atau D) yaitu simpul yang berisi informasi D (elemen). Dalam menghapus simpul belakang, kita dapat lakukan dengan dua cara juga, yaitu dengan menggunakan pointer bantu atau tanpa menggunakan pointer bantu. Langkah-langkah penghapusan simpul belakang dengan dan tanpa bantu dapat dilakukan seperti berikut.

Baca Juga Pointer pada C++ Pengertian dan Contoh Program

a. Penghapusan Simpul Tengah dengan Pointer Bantu

Buatlah pointer bantu yang menunjuk simpul pertama yang ditunjuk DL (Bantu = DL).
Gerakkan pointer bantu satu simpul sebelum yang akan dihapus yaitu simpul yang berisi informasi “elemen” (while(Bantu->Kanan->Isi != “elemen”) Bantu=Bantu->Kanan).
Simpul yang akan dihapus yaitu simpul yang ditunjuk pointer kanan bantu ditunjuk oleh pointer hapus (Hapus = Bantu->Kanan).
Sambungkan pointer kanan bantu terhadap simpul yang ditunjuk pointer kanan hapus (Bantu->Kanan = Hapus->Kanan atau juga Bantu->Kanan = Bantu->Kanan->Kanan).
Sambungkan pointer kiri dari simpul setelah hapus terhadap bantu (Bantu->Kanan->Kanan->Kiri = Bantu atau Hapus->Kanan->Kiri = Bantu).
Putuskan pointer kanan hapus dari Linked List (Hapus->Kanan = NULL).
Putuskan pointer kiri hapus dari Linked List (Hapus->Kiri = NULL).

Skema penghapusan simpul tengah dengan pointer bantu dapat dilihat pada Gambar 12.

Gambar 12. Operasi Penghapusan Simpul Tengah dan Pointer Bantu (versi 2)

Fungsi penghapusan simpul tengah dengan mengikuti langkah-langkah dan gambar 12. di atas dapat dilihat berikut ini.

void Hapus_Tengah(simpul &DL, char elemen) { simpul bantu, hapus; if(DL==NULL) cout<<"Linked List Kosong .............."; else { bantu = DL; while(bantu->kanan->Isi != elemen) bantu=bantu->kanan; hapus = bantu->kanan; bantu->kanan->kanan->kiri = bantu; bantu->kanan = bantu->kanan->kanan; hapus->kanan = NULL; hapus->kiri = NULL; free(hapus); } }

b. Penghapusan Simpul Tengah Tanpa Pointer Bantu (versi 1)

Menghapus simpul tertentu yang ada pada posisi tengah Linked List tanpa menggunakan pointer bantu, tetapi menggerakkan pointer DL ke satu simpul sebelum simpul yang akan dihapus. Simpul yang akan dihapus (simpul berikutnya dari DL) ditunjuk oleh pointer hapus. Setelah selesai proses penghapusan kemudian kembalikan pointer DL ke simpul depan.

Gerakkan pointer DL satu simpul sebelum simpul yang akan dihapus yaitu simpul yang berisi informasi “ele“en” (while(DL->Kanan->Isi != “elemen”) DL=DL->Kanan).
Simpul yang akan dihapus yaitu simpul yang ditunjuk pointer kanan DL ditunjuk oleh pointer hapus (Hapus = DL->Kanan).
Sambungkan pointer Kanan DL terhadap simpul yang ditunjuk pointer kanan hapus (DL->Kanan = Hapus->Kanan atau juga DL->Kanan = DL->Kanan->Kanan).
Sambungkan pointer kiri dari simpul setelah hapus terhadap DL (DL->Kanan->Kanan->Kiri = DL atau Hapus->Kanan->Kiri = DL).
Putuskan pointer kiri hapus dari Linked List (Hapus->Kiri = NULL).
Putuskan pointer kanan hapus dari Linked List (Hapus->Kanan = NULL).
Gerakkan pointer DL hingga simpul pertama (while(DL->Kiri != NULL) DL=DL->Kiri).

Skema penghapusan simpul tengah tanpa pointer bantu dapat dilihat pada Gambar 13.

Gambar 13. Operasi Penghapusan Simpul Tengah Tanpa Pointer Bantu (versi 1)

Fungsi penghapusan simpul tengah dengan mengikuti langkah-langkah dan gambar 13 di atas dapat dilihat berikut ini.

void Hapus_Tengah(simpul &DL, char elemen) { simpul hapus; if(DL==NULL) cout<<"Linked List Kosong ............"; else { while(DL->kanan->Isi != elemen) DL=DL->kanan; hapus = DL->kanan; DL->kanan->kanan->kiri = DL; DL->kanan = DL->kanan->kanan; hapus->kanan = NULL; hapus->kiri = NULL; free(hapus); while(DL->kiri != NULL) DL=DL->kiri; } }

c. Penghapusan Simpul Tengah Tanpa Pointer Bantu (versi 2)

Menghapus simpul tertentu yang ada di posisi tengah Linked List tanpa menggunakan pointer bantu dan tanpa menggerakkan pointer DL. Kita hanya cukup menggerakkan pointer hapus mulai simpul depan hingga simpul yang akan dihapus, kemudian lakukan operasi penghapusan.

Pointer hapus menunjuk simpul depan (Hapus = DL).
Gerakkan pointer hapus hingga simpul yang berisi informasi “elemen” yaitu simpul yang akan dihapus (while(Hapus->Isi != “elemen”) Hapus=Hapus->Kanan;).
Pointer kanan dari simpul sebelum hapus menunjuk simpul setelah hapus (Hapus->Kiri->Kanan = Hapus->Kanan).
Pointer kiri dari simpul setelah hapus menunjuk simpul sebelum hapus (Hapus->Kanan->Kiri = Hapus->Kiri).
Putuskan pointer kanan hapus (Hapus->Kanan = NULL).
Putuskan pointer kiri hapus (Hapus->Kiri = NULL).

Skema penghapusan simpul tengah tanpa pointer bantu dapat dilihat pada Gambar 14.

Gambar 14. Operasi Penghapusan Simpul Tengah Tanpa Pointer Bantu (versi 2)

Fungsi penghapusan simpul tengah dengan mengikuti langkah-langkah dan gambar 14 di atas dapat dilihat berikut ini.

void Hapus_Tengah(simpu &DL, char elemen) { simpul Hapus; if(DL==NULL) cout<<"Linked List Kosong .............."; else { Hapus = DL; while(Hapus->Isi != elemen) Hapus=Hapus->Isi; Hapus->kanan->kiri = Hapus->kiri; Hapus->kiri->kanan = Hapus->kanan; Hapus->kanan = NULL; Hapus->kiri = NULL; free(Hapus); } }

2.3.Pencetakan Simpul

void Ceta(simpul DL) { if(DL==NULL) cout<<"Linked List Kosong ..........."<<endl; else { cout<<"Isi Linked List : "; while (DL != NULL) { cout<<DL->Isi<<" "; DL=DL->kanan; } } }

2.4. Mencetak Linked List Secara Mundur

Mencetak mundur artinya mencetak elemen Linked List mulai dari elemen simpul belakang ke depan.

void Cetak_Mundur(simpul DL) { if(DL != NULL) { Cetak_Mundur(DL->kanan); cout<<DL->Isi<<" "; } }

Berikut ini merupakan program lengkap untuk operasi Doubly Linked List, yaitu menyisipkan simpul depan, simpul tengah, simpul belakang, menghapus simpul depan, menghapus simpul tengah dan menghapus simpul belakang.

/* =============================== == PROGRAM DOUBLE LINKED LIST== ======BY : LAMHOT SITORUS====== =============================== */ #include<iostream.h> #include<conio.h> #include<stdlib.h> #define true 1 #define true 0 typedef struct node *simpul; struct node { char Isi; simpul kanan; simpul kiri; }; //====================== //==Prototype Function== //====================== void Sisip_Depan(simpul &DL, char elemen); void Sisip_Belakang(simpul &DL, char elemen); void Sisip_Tengah2(simpul &DL, char elemen1, char elemen2); void Sisip_Tengah2(simpul &DL, char elemen1, char elemen2); void Hapus_Depan(simpul &DL); void Hapus_Belakang(simpul &DL); void Hapus_Tengah(simpul &DL, char elemen); void Cetak(simpul DL); //================== //==Function Matin== //================== main() { char huruf, huruf2; simpul DL = NULL; //Pastikan bahwa DL kosong int i; cout<<"\t\t=OPERASI PADA DOUBLE LINKED LIST==\n\n"; //=============== //==Sisip Depan== //=============== cout<<"Penyisipan Simpul Di Deppan"<<endl<<endl; for(i=1; i<=4; i++) { cout<<"Masukkan Huruf :"; cin>>huruf; Sisip_Depan(DL, huruf); } Cetak(DL); //================== //==Sisip Belakang== //================== cout<<"\n\nPenyisipan Simpul Di Belakang \n\n"; for(i=1; i<=4; i++) { cout<<"Masukkan Huruf :"; cin>>huruf; Sisip_Belakang(DL, huruf); } Cetak(DL); //======================================== //==Sisip Simpul Setelah Simpul Tertentu== //======================================== cout<<endl<<endl<<"Masukkan Huruf :"; cin>>huruf; cout<<"Disisip Setelah Huruf:" cin>>huruf2; cout<<huruf<<" Disisip Setelah "<<huruf2<<endl; Sisip_Tengah2(DL, huruf, huruf2); Cetak(DL); //======================================== //==Sisip Simpul Sebelum Simpul Tertentu== //======================================== cout<<"\n\nMasukkan Huruf :"; cin>>huruf; cout<<"Disisip Sebelum Huruf :"; cin>>huruf2; cout<<huruf<<" Disisip Sebelum "<<huruf2<<endl; Sisip_Tengah2(DL, huruf, huruf2); Cetak(DL); //====================== //==Hapus Simpul Depan== //====================== cout<<"\n\nSetelah Hapus Simpul Depan \n"; Hapus_Depan(DL); Cetak(DL); //========================= //==Hapus Simpul Belakang== //========================= cout<<"\n\nSetelah Hapus Simpul Belakang "<<endl; Hapus_Belakang(DL); Cetak(DL); //======================= //==Hapus Simpul Tengah== //======================= cout<<"\n\nMasukkan Huruf Tengah Yang Akan Dihapus :"; cin>>huruf; Hapus_Tengah(DL,huruf); Cetak(DL); getch(); } //********************************** //**FUNCTION SISIP SIMPUL DI DEPAN** //********************************** void Sisip_Depan(simpul &DL, char elemen) { simpul baru; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) DL=baru; else { baru->kanan = DL; DL->kiri = baru; DL=baru; } } //************************************************* //**FUNCTION SISIP SIMPUL SETELAH SIMPUL TERTENTU** //************************************************* void Sisip_Tengah2(simpul &DL, char elemen1, char elemen2) { simpul bantu, baru; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen1; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) cout<<"List Kosong ................"<<endl; else { bantu = DL; while(bantu->Isi != elemen2) bantu=bantu->kanan; baru->kanan = bantu->kanan; baru->kiri = baru; baru->kiri = bantu; bantu->kanan->kiri = baru; bantu->kanan = baru; } } //************************************************* //**FUNCTION SISIP SIMPUL SEBELUM SIMPUL TERTENTU** //************************************************* void Sisip_Tengah2(simpul &DL, char elemen1, char elemen2) { simpul bantu, baru; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen1; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) cout<<"List Kosong ............."<<endl; else { bantu = DL; while(bantu->kanan->Isi != elemen2) bantu=bantu->kanan; baru->kanan = bantu->kanan; baru->kiri = bantu; bantu->kanan->kiri = baru; bantu->kanan = baru; } } //************************************* //**FUNCTION SISIP SIMPUL DI BELAKANG** //************************************* void Sisip_Belakang(simpul &DL, char elemen) { simpul bantu, baru; baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) DL=baru; else { bantu=DL; while(bantu->kanan != NULL) bantu=bantu->kanan; bantu->kanan=baru; baru->kiri = bantu; } } //************************************* //**FUNCTION MENCETAK ISI LINKED LIST** //************************************* void Cetak(simpul DL) { simpul bantu; if(DL==NULL) cout<<"Linked List Kosong ........."<<endl; else { bantu=DL; cout<<"Isi Linked List : "; while (bantu->kanan != NULL) { cout<<bantu->Isi<<"<= =>"; bantu=bantu->kanan; } cout<<bantu->Isi; } } //******************************* //**FUNCTION HAPUS SIMPUL DEPAN** //******************************* void Hapus_Depan(simpul &DL) { simpul Hapus; if(DL==NULL) cout<<"Linked List Kosong ............"; else { Hapus = DL; DL = DL->kanan; DL->kiri = NULL; Hapus->kanan = NULL; free(Hapus); } } //********************************** //**FUNCTION HAPUS SIMPUL BELAKANG** //********************************** void Hapus_Belakang(simpul &DL) { simpul bantu, hapus; if(DL==NULL) cout<<"Linked List Kosong ..............."; else { bantu = DL; while(bantu->kanan->kanan != NULL) bantu=bantu->; hapus = bantu->kanan; bantu->kanan = NULL; hapus->kiri = NULL; free(hapus); } } //*********************************** //**FUNCTION HAPUS SIMPUL DI TENGAH** //*********************************** void Hapus_Tengah(simpul &DL, char elemen) { simpul bantu, hapus; if(DL==NULL) cout<<"Linked List Kosong ................"; else { bantu = DL; while(bantu->kanan->Isi != elemen) bantu=bantu->kanan; hapus = bantu->kanan; bantu->kanan->kanan->kiri=bantu; bantu->kanan = bantu->kanan->kanan; hapus->kanan = NULL; hapus->kiri = NULL; free(hapus); } } //=========================eof=========================

Berikut ini merupakan program penghapusan simpul tengah dan simpul belakang tanpa menggunakan pointer bantu dan tanpa menggerakkan pointer DL.

/* ===================================================== ============ PROGRAM DOUBLE LINKED LIST ============= ===== Sisip Depan, Hapus Tengah, Hapus Belakang ===== ================ Tanpa Pointer Bantu ================ ================ BY : LAMHOT SITORUS ================ ===================================================== */ #include<iostream.h> #include<conio.h> #include<stdlib.> #define true 1 #define false 0 typedef struct node *simpul; struct node { char Isi; simpul kanan; simpul kiri; }; //====================== //==Prototype Function== //====================== void Sisip_Depan(simpul &DL, char elemen); void Hapus_Belakang(simpul &DL); void Hapus_Tengah(simpul &DL, char elemen); void Cetak(simpul DL); //================= //==Function Main== //================= main() { char huruf; simpul DL = NULL; //Pastikan bahwa DL kosong int i; cout<<"\t\t==OPERASI PADA DOUBLE LINKED LIST==\n\n"; //=============== //==Sisip Depan== //=============== cout<<"Penyisipan Simpul Di Depan\n\n"; for(i=1; i<=6; i++) { cout<<"Masukkan Huruf :"; cin>>huruf; Sisip_Depan(DL,huruf); } Cetak(DL); //========================= //==Hapus Simpul Belakang== //========================= cout<<"\nSetelah Hapus Simpul Belakang \n"; Hapus_Belakang(DL); Cetak(DL); cout<<"\nSetelah Hapus Simpul Belakang \n"; Hapus_Belakang(DL); Cetak(DL); //======================= //==Hapus Simpul TENGAH== //======================= cout<<"\nMasukkan Huruf Tengah Yang Akan Dihapus :"; cin>>huruf; Hapus_Tengah(DL,huruf); Cetak(DL); cout<<"\nMasukkan Huruf Tengah Yang Akan Dihapus :"; cin>>huruf; Hapus_Tengah(DL,huruf); Cetak(DL); getch(); } //********************************** //**FUNCTION SISIP SIMPUL DI DEPAN** //********************************** void Sisip_Depan(simpul &DL, char elemen) { simpul baru; //simpul baru = new simpul; maka baris berikut dihapus baru = (simpul) malloc(sizeof(simpul)); baru->Isi = elemen; baru->kanan = NULL; baru->kiri = NULL; if(DL == NULL) DL=baru; else { baru->kanan = DL; DL->kiri = baru; DL=baru; } } //************************************ //**FUNTION MENCETAK ISI LINKED LIST** //************************************ void Cetak(simpul DL) { if(DL==NULL) cout<<"Linked List Kosong ........."<<endl; else { cout<<"Isi Linked List : "; while (DL->kanan != NULL) { cout<<DL->Isi<<"<==>"; DL=DL->kanan; } cout<<DL->Isi; } } //********************************** //**FUNCTION HAPUS SIMPUL BELAKANG** //********************************** void Hapus_Belakang(simpul &DL) { simpul Hapus; if(DL==NULL) cout<<"Linked List Kosong ............"; else { Hapus = DL; while(Hapus->kanan != NULL) Hapus=Hapus->kanan; Hapus->kiri->kanan = NULL; Hapus->kiri = NULL; free(Hapus); } } //*********************************** //**FUNCTION HAPUS SIMPUL DI TENGAH** //*********************************** void Hapus_Tengah(simpul &DL, char elemen) { simpul Hapus; if(DL==NULL) cout<<"Linked List Kosong ............"; else { Hapus = DL; while(Hapus->Isi != elemen) Hapus=Hapus->kanan; Hapus->kanan->kiri = Hapus->kiri; Hapus->kiri->kanan = Hapus->kanan; Hapus->kanan = NULL; Hapus->kiri = NULL; free(Hapus); } } //===========================eof===========================

Berikut ini program pembentukan suatu Doubly Linked List yang nilainya selalu terurut secara menaik.

/* ============================================= ======== PROGRAM DOUBLE LINKED LIST ========= ==Membentuk Linked List Yang Selalu Terurut== =============BY : LAMHOT SITORUS============= ============================================= */ #include<iostream.h> #include<conio.h> #include<stdlib.h> #define true 1 #define false 0 typedef struct node *simpul; struct node { char Isi; simpul kanan; simpul kiri; }; //====================== //==Prototype Function== //====================== void Sisip_Urut(simpul &DL, char elemen); void Cetak(simpul DL); //====================== main() { char huruf; simpul DL = NULL; //Pastikan bahwa DL kosong int i; cout<<"\t\t==DOUBLE LINKED LIST SELALU TERURUT==\n\n"; //================ //==Sisip Elemen== //================ for(i=1; i<=10; i++) { cout<<"Masukkan Huruf :"; cin>>huruf; Sisip_Urut(DL, huruf); Cetak(DL); } Cetak(DL); getch(); } //********************************************* //**FUNCTION PENYISIPAN SIMPUL SECARA TERURUT** //********************************************* void Sisip_Urut(simpul &DL, char elemen) { simpul Bantu, Baru; bool Ketemu; Baru = (simpul) malloc(sizeof(simpul)); Baru->Isi = elemen; Baru->kanan = NULL; Baru->kiri = NULL; if(DL == NULL) DL=Baru; else { if(DL->Isi > elemen) { Baru->kanan = DL; DL->kiri = Baru; DL=Baru; } else { Bantu = DL; Ketemu = false; while((Bantu->kanan != NULL) && (!Ketemu)) { if(elemen < Bantu->kanan->Isi) { Baru->kanan = Bantu->kanan; Baru->kiri = Bantu; Bantu->kanan->kiri = Baru; Bantu->kanan = Baru; Ketemu = true; } Bantu=Bantu->kanan; } if(!(Ketemu)) Bantu->kanan = Baru; } } } //************************************* //**FUNCTION MENCETAK ISI LINKED LIST** //************************************* void Cetak(simpul DL) { if(DL==NULL) cout<<"Linked List Kosong ........."<<endl; else { cout<<"\nIsi Linked List : "; while (DL != NULL) { cout<<DL->Isi<<" "; DL=DL->kanan; } } } //======================oef======================