SORTING

1. Selection Sort (Ascending):
Pengurutan dilakukan dengan memilih elemen terbesar dan menempatkan pada posisinya,
kemudian mencari element terbesar berikutnya dan menempatkan pada tempatnya, dan
seterusnya.

Proses pengurutan dengan menggunakan metode selection sort secara terurut naik adalah
1. Mencari data terkecil dari data pertama sampai data terakhir, kemunian di tukar   posisinya dengan data pertama.
2. mencari data terkecil dari data kedua sampai data terakhir, kemudian di tukar dengan posisinya dengan data kedua.
3. mencari data terkecil dari data ketiga sampai data terakhir, kemudian di tukar posisinya dengan data ketiga
4. dan seterusnya sampai semua data turut naik. apabila terdapat n buah data yang akan di urutkan, maka membutukan (n – 1) langkah pengurutan, dimana data terakhir yaitu data ke-n tidak perlu di urutkan karena hanya tinggal satu satunya.

 

2. Bubble Sort

Konsep Buble Sort
Metode pengurutan gelembung (Bubble Sort) diinspirasikan oleh gelembung sabun yang berada dipermukaan air. Karena berat jenis gelembung sabun lebih ringan daripada berat jenis air, maka gelembung sabun selalu terapung ke atas permukaan. Prinsip di atas dipakai pada pengurutan gelembung.
Bubble sort (metode gelembung) adalah metode/algoritma pengurutan dengan dengan cara melakukan penukaran data dengan tepat disebelahnya secara terus menerus sampai bisa dipastikan dalam satu iterasi tertentu tidak ada lagi perubahan. Jika tidak ada perubahan berarti data sudah terurut. Disebut pengurutan gelembung karena masing-masing kunci akan dengan lambat menggelembung ke posisinya yang tepat.

 

3. Metode Penyisipan Langsung (Insertion sort)
Data dicek satu per satu mulai dari yang kedua sampai dengan yang terakhir. Apabila
ditemukan data yang lebih kecil daripada data sebelumnya, maka data tersebut disisipkan
pada posisi yang sesuai. Akan lebih mudah apabila membayangkan pengurutan kartu.
Pertama-tama anda meletakkan kartu-kartu tersebut di atas meja, kemudian melihatnya
dari kiri ke kanan. Apabila kartu di sebelah kanan lebih kecil daripada kartu di sebelahkiri, maka ambil kartu tersebut dan sisipkan di tempat yang sesuai.

 

4.Metode Penggabungan (Merge Sort) 

Metode penggabungan biasanya digunakan pada pengurutan berkas. Prinsip dari
metode penggabungan sebagai berikut : mula-mula diberikan dua kumpulan data yang
sudah dalam keadaan urut. Kedua kumpulan data tersebut harus dijadikan satu table
sehingga dalam keadaan urut.

1. Divide

Memilah elemen – elemen dari rangkaian data menjadi dua bagian.

2. Conquer

Conquer setiap bagian dengan memanggil prosedur merge sort secara rekursif

3. Kombinasi

Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkan rangkaian data berurutan

Proses rekursi berhenti jika mencapai elemen dasar. Hal ini terjadi bilamana bagian yang akan diurutkan menyisakan tepat satu elemen. Sisa pengurutan satu elemen tersebut menandakan bahwa bagian tersebut telah terurut sesuai rangkaian.

5.Quick Sort

Algoritma ini berdasar pada pola divide-and-conquer. Berbeda dengan merge sort, algoritma ini hanya mengikuti langkah – langkah sebagai berikut :

1. Divide

Memilah rangkaian data menjadi dua sub-rangkaian A[p…q-1] dan A[q+1…r] dimana setiap elemen A[p…q-1] adalah kurang dari atau sama dengan A[q] dan setiap elemen pada A[q+1…r] adalah lebih besar atau sama dengan elemen pada A[q]. A[q] disebut sebagai elemen pivot. Perhitungan pada elemen q merupakan salah satu bagian dari prosedur pemisahan.

2. Conquer

Mengurutkan elemen pada sub-rangkaian secara rekursif. Pada algoritma quicksort, langkah ”kombinasi” tidak di lakukan karena telah terjadi pengurutan elemen – elemen pada sub-array

 

6. Shell Sort

Merupakan algoritma yang stau jenis dengan insertion sort, dimana pada setiap nilai i dalam n/i item diurutkan. Pada setiap pergantian nilai, i dikurangi sampai 1 sebagai nilai terakhir

Circular Doubly Linked List

Circular Doubly Linked List adalah sederetan elemen yang saling berhubungan satu dengan yang lain, dimana pointer kiri simpul pertama menunjuk simpul terakhir dan pointer kanan simpul terakhi menunjuk simpul pertama. Semua simpul berhak menjadi simpul pertama. Jika suatu simpul dibuat menjadi simpul depan maka simpul yang ada di sebelah kiri merupakan simpul belakang.

Pendeklarasian simpul untuk Circular Doubly Linked List sama dengan pendeklarasian pada Doubly Linked List. Operasi yang ada pada Doubly Linked List juga berlaku pada Circular Doubly Linked List, hanya saja pada Circular tidak mengandung NULL, perhatikan gambar 8.

Gambar 8. Circular Doubly Linked List dengan 3 Simpul

 

2.1. Operasi pada Circular Doubly Linked List

Operasi pada Circular Doubly Linked List juga dapat dilakukan penyisipan dan penghapusan simpul.

a. Operasi Penyisipan Simpul

Operasi penyisipan simpul ke suatu Linked List juga ada tiga, yaitu penyisipan simpul di depan, penyisipan simpul di belakang, dan penyisipan simpul di tengah. Karena semua simpul berhak menjadi simpul depan maka pointer penunjuk Linked List (CDL) dapat digerakkan ke seluruh simpul pada Linked List. Tetapi supaya kita tetap mempertahankan simpul yang ditunjuk CDL merupakan simpul depan maka kita dapat menggunakan suatu pointer bantu. Pointer bantu dapat digerakkan ke semua simpul pada Linked List. Di sini, simpul yang ditunjuk oleh CDL pertama sekali akan tetap dipertahankan sebagai simpul pertama atau simpul depan.

1. Penyisipan simpul depan

Langkah-langkah penyisipan simpul depan dapat dilakukan seperti berikut ini:

• Jika Linked List belum ada (NULL) maka simpul baru menjadi awal Linked List (CDL = Baru).
• Jika Linked List sudah ada maka penyisipan dilakukan dengan:
  • Pointer kanan simpul baru menunjuk CDL (Baru->Kanan = CDL).
  • Pointer kiri simpul baru menunjuk yang ditunjuk pointer kiri CDL (Baru->Kiri = CDL->Kiri).
  • Pointer kanan dari simpul yang ditunjuk pointer kiri CDL menunjuk simpul baru (CDL->Kiri->Kanan = Baru).
  • Pointer kiri CDL menunjuk simpul baru (CDL->Kiri = Baru).
  • Pointer CDL menunjuk simpul baru (CDL = Baru).

Misalkan kita memiliki Linked List yang terdiri dari tiga simpul dengan berisi masing-masing informasi A, B, dan C. Juga memiliki suatu simpul baru yang berisi informasi D. Simpul baru yang akan disisipkan di bagian depan Linked List. Skema penyisipan simpul depan dapat dilihat pada Gambar 9.

Gambar 9. Penyisipan Simpul Depan pada Circular Doubly Linked List

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

1. void Sisip_Depan(simpul &CDL, char elemen)
2. {
3. simpul baru;
4. baru = (simpul) malloc(sizeof(simpul));
5. baru->Isi = elemen;
6. baru->kanan = baru;
7. baru->kiri = baru;
8. if(CDL == NULL) CDL=baru;
9. else
10. {
11. baru->kanan = CDL;
12. baru->kiri = CDL->kiri;
13. CDL->kiri->kanan = baru;
14. CDL->kiri = baru;
15. }
16. }

2. Penyisipan simpul belakang

Langkah-langkah penyisipan simpul baru pada Linked List di posisi belakang dapat dilakukan seperti berikut ini:

• Jika Linked List belum ada (NULL) maka simpul baru menjadi awal Linked List (CDL = Baru).
• Jika Linked List sudah ada maka penyisipan dilakukan dengan:
  • Pointer kanan simpul baru menunjuk CDL (Baru->Kanan =CDL).
  • Pointer kiri simpul baru menunjuk yang ditunjuk pointer kiri CDL (Baru->Kiri = CDL->Kiri).
  • Pointer kanan dari simpul yang ditunjuk pointer Kiri CDL menunjuk simpul baru (CDL->Kiri->Kanan = Baru).
  • Pointer kiri CDL menunjuk simpul baru (CDL->Kiri = Baru).

Misalkan kita memiliki Linked List yang terdiri dari tiga simpul dengan berisi masing-masing informasi A, B, dan C, juga memiliki suatu simpul baru yang berisi informasi D. Simpul Baru akan disisipkan di bagian belakang Linked List. Skema penyisipan simpul belakang dapat dilihat pada Gambar 9.

Circular Singly Linked List

Hampir sama dengan Singly Linked List, hanya saja simpul terakhir akan dihubungkan ke simpul pertama sehingga berbentuk melingkar. Pendeklarasian dan operasi yang ada di Singly Linked List juga berlaku di Circular Singly Linked List, yang perlu dijaga adalah bahwa simpul terakhir harus selalu terhubung ke simpul pertama yang ditunjuk oleh CL seperti pada gambar 1.  

Gambar 1. Circular Singly Linked List dengan 4 Simpul

 

1.1. Penyisipan simpul

Penyisipan simpul adalah operasi menyisipkan suatu simpul baru ke dalam suatu Linked List. Operasi penyisipan dapat dilakukan di posisi depan, posisi belakang, atau di posisi tengah.

a. Penyisipan simpul depan

Simpul yang disisipkan selalu berada di posisi depan dari Linked List (CL). Misalkan kita memiliki suatu Linked List CL dengan empat simpul di mana masing-masing berisi informasi A, B, C, dan D, dan kita juga memiliki suatu simpul baru yang berisi informasi E yang akan disisipkan di posisi depan dari Linked List CL. Langkah-langkah penyisipan simpul baru dapat dilakukan sebagai berikut:

• Jika Linked List CL belum ada maka simpul baru menjadi awal Linked List CL (CL = Baru).
• Jika Linked List CL sudah ada maka penyisipan dilakukan:
  • Pointer bantu menunjuk CL (Bantu = CL).
  • Gerakkan bantu hingga ke simpul belakang (while(Bantu->Kanan != CL) Bantu = Bantu->Kanan).
  • Kanan baru menunjuk CL (Baru->Kanan = CL).
  • Kanan bantu menunjuk baru (Bantu->Kanan = Baru).
  • Pindahkan CL ke simpul yang ditunjuk oleh baru (CL = Baru).

Skema penyisipan simpul depan dapat dilihat pada gambar 2.

Gambar 2. Penyisipan Simpul Depan pada Circular Singly Linked List

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

1. void Sisip_Depan(simpul &CL, char elemen)
2. {
3. simpul bantu, baru;
5. baru = (simpul) malloc(sizeof(simpul));
6. baru->Isi = elemen;
7. baru->kanan = baru;
8. if(CL == NULL)
9. CL=baru;
10. else
11. {
12. bantu = CL;
13. while(bantu->kanan != CL) bantu=bantu->kanan;
14. baru->kanan = CL;
15. bantu->kanan = baru;
16. CL = baru;
17. }
18. }

b. Penyisipan simpul belakang

Penyisipan belakang sebenarnya hampir sama dengan penyisipan depan. Yang membedakan hanyalah pemindahan CL ke simpul yang ditunjuk oleh baru untuk penyisipan belakang tidak ada. Walaupun dalam penyisipan depan juga tidak harus dilakukan pemindahan CL, karena dalam Circular semua simpul berhak menjadi depan.

Misalkan kita memiliki suatu Linked List CL dengan empat simpul dimana masing-masing berisi informasi A, B, C, dan D, dan kita juga memiliki suatu simpul baru yang berisi informasi E yang akan disisipkan di posisi belakang dari Linked List CL. Langkah-langkah penyisipan simpul baru dapat dilakukan sebagai berikut:

• Jika Linked List CL belum ada maka simpul baru menjadi awal Linked List CL (CL = Baru).
• Jika Linked List CL sudah ada maka penyisipan dilakukan.
  • Pointer bantu menunjuk CL (Bantu = CL).
  • Gerakkan bantu hingga ke simpul belakang (while(Bantu->Kanan != CL) Bantu = Bantu->Kanan).
  • Pointer kanan bantu menunjuk baru (Bantu->Kanan = Baru).
  • Pointer kanan baru menunjuk CL (Baru->Kanan = CL).

Skema penyisipan simpul belakang dapat dilihat pada Gambar 3.

Gambar 3. Penyisipan Simpul Belakang pada Circular Singly Linked List

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

1. void Sisip_Belakang(simpul &CL, char elemen)
2. {
3. simpul bantu, baru;
4. baru = (simpul) malloc(sizeof(simpul));
5. baru->Isi = elemen;
6. baru->kanan = baru;
7. if(CL == NULL)
8. CL=baru;
9. else
10. {
11. bantu = CL;
12. while(bantu->kanan != CL) bantu=bantu->kanan;
13. baru->kanan = CL;
14. bantu->kanan = baru;
15. }
16. }

c. Penyisipan simpul tengah

Dalam melakukan penyisipan simpul tengah, maka Linked List harus dijamin tidak boleh kosong. Penyisipan tengah dapat dilakukan pada sebelum atau setelah simpul tertentu. Yang akan dilakukan di sini adalah hanya penyisipan simpul setelah simpul tertentu. Penyisipan tengah dapat dilakukan dengan menggunakan pointer bantu atau tanpa menggunakan pointer bantu. Jika tidak menggunakan pointer bantu maka, yang harus digerakkan adalah CL dan CL dapat dikembalikan ke simpul semula ataupun tidak dikembalikan (karena prinsip semua simpul berhak menjadi simpul depan). Yang dilakukan di sini adalah juga dengan menggunakan pointer bantu.

Misalkan kita memiliki suatu Circular Linked List yang terdiri dari 4 simpul dan masing-masing simpul berisi informasi A, B, C, dan D. Kita juga memiliki simpul baru yang berisi informasi ‘X’. Simpul baru akan disisipkan setelah simpul yang berisi informasi ‘C’. Adapun langkah-langkah penyisipan tengah tersebut adalah sebagai berikut:

• Pointer bantu menunjuk simpul depan (Bantu = CL).
• Gerakkan pointer bantu hingga simpul yang berisi informasi ‘C’ (while(Bantu->Isi !=’C’) Bantu = Bantu->Kanan).
• Pointer kanan baru menunjuk kanan bantu (Baru->Kanan = Bantu->Kanan).
• Pointer kanan bantu menunjuk baru (Bantu->Kanan = Baru).

Skema penyisipan simpul tengah dapat dilihat pada Gambar 4.

Gambar 4. Penyisipan Simpul Tengah pada Circular Singly Linked List

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

1. void Sisip_Tengah(simpul &CL, char elemen1, char elemen2)
2. {
3. simpul bantu, baru;
4. baru = (simpul) malloc(sizeof(simpul));
5. baru->Isi = elemen1;
6. baru->kanan = baru;
7. if(CL == NULL)
8. cout<<"List Kosong ............."<<endl;
9. else
10. {
11. bantu = CL;
12. while(bantu->Isi != elemen2) bantu=bantu->kanan;
13. baru->kanan = bantu->kanan;
14. bantu->kanan = baru;
15. }
16. }

 

1.2. Penghapusan Simpul

Yang dimaksud dengan penghapusan simpul adalah operasi penghapusan simpul dari Linked List. Jika kita akan melakukan penghapusan simpul maka pastikan bahwa Linked List tidak boleh kosong. Penghapusan pada Circular Singly Linked List juga dapat dilakukan pada simpul yang berada di posisi depan, posisi tengah, maupun yang berada pada posisi belakang.

a. Penghapusan simpul depan

Menghapus simpul yang ada pada posisi depan. Langkah-langkah penghapusan simpul pada posisi depan adalah sebagai berikut:

• Simpul depan yang ditunjuk oleh CL ditunjuk juga oleh pointer bantu (Bantu = CL).
• Gerakkan pointer bantu hingga simpul belakang (while(Bantu->Kanan != CL) Bantu = Bantu->Kanan).
• Simpul depan yang ditunjuk oleh CL juga ditunjuk oleh hapus (Hapus = CL).
• Pindahkan pointer CL ke simpul berikutnya (CL = CL->Kanan).
• Pointer kanan dari bantu menunjuk CL (Bantu->Kanan = CL).
• Pointer kanan hapus menunjuk hapus (Hapus->Kanan = Hapus).

Gambar 5. Penghapusan Simpul Depan Pada Circular Singly Linked List

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

1. void Hapus_Depan(simpul &CL)
2. {
3. simpul bantu, Hapus;
4. if(CL == NULL)
5. cout<<"Linked List Kosong ............";
6. else
7. {
8. bantu = CL;
9. while(bantu->kanan != CL) bantu=bantu->kanan;
10. Hapus = CL;
11. CL = CL->kanan;
12. bantu->kanan = CL;
13. Hapus->kanan = Hapus;
14. free(Hapus);
15. }
16. }

b. Penghapusan simpul belakang

Menghapus simpul yang ada pada posisi belakang. Langkah-langkah penghapusan simpul pada posisi belakang adalah sebagai berikut:

• Simpul depan yang ditunjuk oleh CL ditunjuk juga oleh pointer bantu (Bantu = CL).
• Gerakkan pointer bantu hingga satu simpul sebelum simpul belakang (while(Bantu->Kanan->Kanan != CL) Bantu = Bantu->Kanan).
• Simpul belakang ditunjuk oleh pointer hapus (Hapus = Bantu->Kanan).
• Pointer kanan dari bantu menunjuk CL (Bantu->Kanan = CL).
• Pointer kanan hapus menunjuk hapus (Hapus->Kanan = Hapus).

Skema penghapusan simpul belakang dapat dilihat pada Gambar 6.

Gambar 6. Penghapusan Simpul Belakang pada Circular Singly Linked List

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

1. void Hapus_Belakang(simpul &CL)
2. {
3. simpul hapus, bantu;
4. if(CL==NULL)
5. cout<<"Linked List Kosong ..............";
6. else
7. {
8. bantu = CL;
9. while(bantu->kanan->kanan != CL) bantu= bantu->kanan;
10. hapus = bantu->kanan;
11. bantu->kanan = CL;
12. hapus->kanan = hapus;
13. free(hapus);
14. }
15. }

c. Penghapusan simpul tengah

Yang dimaksud dengan penghapusan simpul tengah adalah menghapus simpul tertentu yang ada pada posisi tengah. Misalkan kita memiliki suatu Circular Singly Linked List yang terdiri dari 5 simpul dan masing-masing simpul berisi informasi A, B, C, D, dan E. Kita akan menghapus simpul yang berada di posisi tengah, yaitu simpul yang berisi informasi D. Adapun langkah-langkah penghapusan tengah tersebut adalah sebagai berikut:

• Simpul depan yang ditunjuk oleh CL ditunjuk juga oleh pointer bantu (Bantu = CL).
• Gerakan pointer bantu hingga satu simpul sebelum simpul yang akan dihapus (while(Bantu->Kanan->Isi != ‘D’) Bantu = Bantu->Kanan).
• Simpul berikutnya ditunjuk pointer hapus (Hapus = Bantu->Kanan).
• Pointer kanan dari bantu menunjuk kanan hapus (Bantu->Kanan = Hapus->Kanan).
• Pointer kanan hapus menunjuk hapus (Hapus->Kanan = Hapus).

Skema penghapusan simpul tengah dapat dilihat pada Gambar 7.

Gambar 7. Penghapusan Simpul Tengah pada Circular Singly Linked List

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

1. void Hapus_Tengah(simpul &CL, char elemen)
2. {
3. simpul hapus, bantu;
4. if(CL == NULL)
5. cout<<"Linked List Kosong ...............";
6. else
7. {
8. bantu = CL;
9. while(bantu->kanan->Isi != elemen)bantu=bantu->kanan;
10. hapus = bantu->kanan;
11. bantu->kanan = hapus->kanan;
12. hapus->kanan = hapus;
13. free(hapus);
14. }
15. }

 

Berikut ini program lengkap untuk operasi pada Circular Singly Linked List yaitu operasi untuk penyisipan depan, penyisipan belakang, penyisipan tengah, penghapusan simpul depan, penghapusan simpul tengah, dan penghapusan simpul belakang, serta pencetakan elemen simpul.

1. /*
2. ==PROGRAM CIRCULAR SINGLY LINKED LIST==
3. ==========BY : lAMHOT SITORUS==========
4. ======================================= */
6. #include<iostream.h>
7. #include<conio.h>
8. #include<stdlib.h>
9. typedef struct node *simpul;
10. struct node
11. {
12. char Isi;
13. simpul kanan;
14. };
15. //======================
16. //==Prototype Function==
17. //======================
18. void Sisip_Depan(simpul &CL, char elemen);
19. void Sisip_Belakang(simpul &CL, char elemen);
20. void Sisip_Tengah(simpul &&CL, char elemen1, char elemen2);
21. void Hapus_Depan(simpul &CL);
22. void Hapus_Belakang(simpul &CL);
23. void Hapus_Tengah(simpul &CL, char elemen);
24. void Cetak(simpul CL);
26. //=================
27. //==Function Main==
28. //=================
29. main()
30. {
31. char huruf, huruf2;
32. simpul CL = NULL; //Pastikan bahwa DL kosong
33. int i;
34. cout<<"\t\t==OPERASI PADA CIRCULAR SINGLE LINKED LIST==\n\n";
35. //===============
36. //==Sisip Depan==
37. //===============
38. cout<<"Penyisipan Simpul Di Depan\n\n";
39. for(i=1; i<=4; i++)
40. {
41. cout<<"Masukkan Huruf :"; cin>>huruf;
42. Sisip_Depan(CL, huruf);
43. }
44. Cetak(CL);
45. //==================
46. //==Sisip Belakang==
47. //==================
48. cout<<"\nPenyisipan Simpul Di Belakang \n\n";
49. for(i=1; i<=4; i++)
50. {
51. cout<<"Masukkan Huruf :"; cin>>huruf;
52. Sisip_Belakang(CL, huruf);
53. }
54. cetak(CL);
55. //========================================
56. //==Sisip Simpul Setelah Simpul Tertentu==
57. //========================================
58. cout<<"\nMasukkan Huruf :"; cin>>huruf;
59. cout<<"Disisip Setelah Huruf :"; cin>>huruf2;
60. cout<<huruf<<" Disisip Setelah "<<huruf2<<endl;
61. Sisip_Tengah(CL, huruf, huruf2);
62. Cetak(CL);
63. //=========================
64. //==Hapus Simpul Belakang==
65. //=========================
66. cout<<"\nSetelah Hapus Simpul Belakang \n";
67. Hapus_Belakang(CL);
68. Cetak(CL);
69. //=======================
70. //==Hapus Simpul TENGAH==
71. //=======================
72. cout<<"\nMasukkan Huruf Tengah Yang Akan Dihapus :"; cin>>huruf;
73. Hapus_Tengah(CL,huruf);
74. Cetak(CL);
75. getch;
76. }
78. //**********************************
79. //**FUNCTION SISIP SIMPUL DI DEPAN**
80. //**********************************
81. void Sisip_Depan(simpul &CL, char elemen)
82. {
83. simpul bantu, baru;
84. baru = (simpul) malloc(sizeof(simpul));
85. baru->Isi = elemen;
86. baru->kanan = baru;
87. if(CL == NULL)
88. CL=baru;
89. else
90. {
91. bantu = CL;
92. while(bantu->kanan != CL) bantu=bantu->kanan;
93. baru->kanan = CL;
94. bantu->kanan = baru;
95. CL = baru;
96. }
97. }
99. //*************************************************
100. //**FUNCTION SISIP SIMPUL SETELAH SIMPUL TERTENTU**
101. //*************************************************
102. void Sisip_Tengah(simpul &CL, char elemen1, char elemen2)
103. {
104. simpul bantu, baru;
105. baru = (simpul) malloc(sizeof(simpul));
106. baru->Isi = elemen1;
107. baru->kanan = baru;
108. if(CL == NULL)
109. cout<<"List Kosong .............."<<endl;
110. else
111. {
112. bantu = CL;
113. while(bantu->Isi != elemen2) bantu=bantu->kanan;
114. baru->kanan = bantu->kanan;
115. bantu->kanan = baru;
116. }
117. }
119. //*************************************
120. //**FUNCTION SISIP SIMPUL DI BELAKANG**
121. //*************************************
122. void Sisip_Belakang(simpul &CL, char elemen)
123. {
124. simpul bantu, baru;
125. baru = (simpul) malloc(sizeof(simpul));
126. baru->Isi = elemen;
127. baru->kanan = baru;
128. if(CL == NULL)
129. CL=baru;
130. else
131. {
132. bantu = CL;
133. while(bantu-> != CL) bantu=bantu->kanan;
134. baru->kanan = CL;
135. bantu->kanan = baru;
136. }
137. }
139. //*************************************
140. //**FUNCTION MENCETAK ISI LINKED LIST**
141. //*************************************
142. void Cetak(simpul CL)
143. {
144. simpul bantu;
145. if(CL==NULL)
146. cout<<"Linked List Kosong ........"<<endl;
147. else
148. {
149. bantu = CL;
150. cout<<"Isi Linked List : ";
151. while (bantu->kanan != CL)
152. {
153. cout<<bantu->Isi<<"-->";
154. bantu=bantu->kanan;
155. }
156. cout<<bantu->Isi;
157. }
158. }
160. //*******************************
161. //**FUNCTION HAPUS SIMPUL DEPAN**
162. //*******************************
163. void Hapus_Depan(simpul &CL)
164. {
165. simpul bantu, Hapus;
166. if(CL == NULL)
167. cout<<"Linked List Kosong ..............";
168. else
169. {
170. bantu = CL;
171. while(bantu->kanan != CL) bantu=bantu->kanan;
172. Hapus = CL;
173. CL = CL->kanan;
174. bantu->kanan = CL;
175. Hapus->kanan = Hapus;
176. free(Hapus);
177. }
178. }
180. //**********************************
181. //**FUNCTION HAPUS SIMPUL BELAKANG**
182. //**********************************
183. void Hapus_Belakang(simpul &CL)
184. {
185. simpul hapus, bantu;
186. if(CL==NULL)
187. cout<<"Linked List Kosong ...............";
188. else
189. {
190. bantu = CL;
191. while(bantu->kanan->kanan != CL) bantu=bantu->kanan;
192. hapus = bantu->kanan;
193. bantu->kanan = CL;
194. hapus->kanan = hapus;
195. free(hapus);
196. }
197. }
199. //***********************************
200. //**FUNCTION HAPUS SIMPUL DI TENGAH**
201. //***********************************
202. void Hapus_Tengah(simpul &CL, char elemen)
203. {
204. simpul hapus, bantu;
205. if(CL == NULL)
206. cout<<"Linked List Kosong ..............";
207. else
208. {
209. bantu = CL;
210. while(bantu->kanan->Isi != elemen) bantu=bantu->kanan;
211. hapus = bantu->kanan;
212. bantu->kanan = hapus->kanan;
213. hapus->kanan = hapus;
214. free(hapus);
215. }
216. }
217. //====================eof====================