Searching and Sorting

Nama : Edhy Wilieyanto

Nomor : 412013003

Sorting and Searching

Sorting and Searching adalah salah satu penerapan dasar dalam konsep
pemrograman, dan juga bagian yang sangat penting dalam pemrograman.
I.

Searching
Pencarian (Searching) merupakan proses yang fundamental dalam pemrograman,
guna menemukan data (nilai) tertentu di dalam sekumpulan data yang bertipe
sama. Fungsi pencarian itu sendiri adalah untuk memvalidasi (mencocokkan) data.
Sebagai contoh, untuk menghapus atau mengubah sebuah data di dalam
sekumpulan nilai, langkah pertama yang harus di tempuh adalah mencari data
tersebut, lalu menghapus atau mengubahnya. Contoh lain adalah penyisipan data
ke dalam kumpulan data, jika data telah ada, maka data tersebut tidak akan
disisipkan, selainnya akan disisipkan ke kumpulan data tersebut. Jenis-jenis
Searching:
A. Sequential Search
Konsep yang digunakan dalam metode ini adalah membandingkan data-data
yang ada dalam kumpulan tersebut, mulai dari elemen pertama sampai elemen
ditemukan, atau sampai elemen terakhir.
Kelemahan dari Sequential Search: Proses pencarian lamban.
Kelebihan dari Sequential Search: Metode pencarian yang paling sederhana.
Perhatikan alur di bawah ini:
Misalkan kumpulan data tersebut adalah sebagai berikut:
13 16 14 21 76 21
Data yang akan dicari adalah X, misal X = 21, maka elemen yang diperiksa
mulai dari 13 16 14 21. Pada saat nilai yang dicari sama dengan nilai dimana
posisi kursor pencarian berada, maka pencarian dihentikan. Hasil pencarian
bisa berupa nilai dari indeks ataupun nilai kebenaran.

Contoh Algoritma Sequential Search :

Algortima Sequential Search
Procedure CARI(input L:lari, input N:integer, input X:integer, output
IDX:integer)
DEKLARASI
k:integer
DESKRIPSI
k1
while(k<N) and (L[k]X) do
kk+1
endwhile
if L[k]=x then
IDXK
else IDX0
endif

Contoh Pemrograman Sequential Search

//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include <conio.h>
//--------------------------------------------------------------------------#pragma argsused
int main(int argc, char* argv[])
{
int X,i,k;
int L[10] = {20,15,22,14,12,10,24,19,18,16};
printf("Data yang akan dicari = ");scanf("%d",&X);
k = 0;
for(i=0;i<=9;i++)
{
if(L[i]==X)
{
printf("Data ditemukan di elemen %d \n",i);
k++;
}
}
if(k==0)
{
printf("Data tidak ditemukan \n");
}
printf("Jumlah data yang ditemukan = %d",k);
getch();
return 0;
}
//---------------------------------------------------------------------------

B. Binary Search
Metode ini diterapkan pada sekumpulan data yang sudah terurut (menaik atau
menurun). Metode ini lebih cepat dibandingkan metode pencarian beruntun.
Data yang sudah terurut menjadi syarat mutlak untuk menggunakan metode
ini.
Konsep dasar metode ini adalah membagi 2 jumlah elemennya, dan
menentukan apakah data yang berada pada elemen paling tengah bernilai sama,
lebih dari atau kurang dari nilai data yang akan dicari. Jika bernilai sama, maka
langsung data yang dicari ditemukan. Jika data di elemen terurut naik, maka
jika data yang berada di tengah kurang dari data yang dicari, maka pencarian
selanjutnya berkisar di elemen tengah ke kanan, dan begitu seterusnya sampai
ketemu atau tidak sama sekali. Dan sebaliknya untuk nilai data yang berada di
tengah lebih dari data yang dicari, maka pencarian selanjutnya berkisar di
elemen tengah ke kiri, dan begitu seterusnya sampai ketemu atau tidak sama
sekali. Dan demikian sebaliknya untuk data yang terurut menurun. Dalam hal
ini tentukan indeks paling awal dan indeks paling akhir, untuk membagi 2
elemen tersebut.
Misalkan ada kumpulan data sebagai berikut:
13, 16, 14, 21, 76, 21
Jika seandainya nilai yang dicari adalah 21, maka elemen yang diperiksa mulai
dengan membagi dari penjumlahan indeks awal dan akhir. Lalu dibandingkan
nilai yang dicari dengan nilai dari indeks hasil pembagian tadi. Jika tidak
cocok, dilakukan pengecekan lagi baik dari kanan maupun kiri. Penentuan
pengecekan dari kanan maupun kiri ditentukan dari apakah nilai yang dicari
lebih besar dari nilai yang dicari

Contoh algoritma Binary Search:

procedure

BS(input

L:Larik,

input

N:integer,

input

X:integer,output

IDX:integer)
DEKLARASI
i,j:integer
k:integer
ketemu:boolean
DESKRIPSI
i1
jN
ketemufalse
while (not ketemu) and (ij) do
k(i+j)div2
if(L[k]=X) then
ketemutrue
else

if(L[k]>X) then
ik+1
else
jk-1
endif

endif
endwhile
if(ketemu) then
IDXk
else
IDX0
endif

Contoh pemrograman Binary Search:

//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include <conio.h>
//---------------------------------------------------------------------------

#pragma argsused
int main(int argc, char* argv[])
{
int X,i,j,k,p;
Int L[10] = {12,14,15,17,23,25,45,67,68,70};
printf("Data yang akan dicari = ");scanf("%d",&X);
i = 0;
j = 9;
do
{
k = (i + j) / 2;
if (L[k]==X)
{
printf("Data ditemukan di elemen %d",k);
getch();
return 0;
}
else if (L[k]< X)
{
i = k;
}
else
{
j = k;
}
}
while(k!=0); // sampai nilai k = 0, iterasi berakhir
printf("Data tidak ditemukan!");
getch();
return 0;
}
//---------------------------------------------------------------------------

C. Interpolation Search
Teknik lain untuk mencari sebuah data adalah Interpolation Search. Metode ini
bahkan lebih efisien daripada Binary Search, jika unsur-unsur seragam
didistribusikan (atau diurutkan) dalam array A. Pertimbangkan sebuah array A
dari n unsur dan unsur-unsur yang merata (atau unsur-unsur tersebut diatur
dalam array yang diurutkan). Awalnya, seperti dalam Binary Search, low diatur
ke 0 dan high diatur ke n - 1. Sekarang kita sedang mencari kunci elemen
dalam array antara A [low] dan A [high]. Kunci ini akan diharapkan berada di
pertengahan, yang merupakan posisi yang kira-kira.
mid = low + (high - low) ((key - A [low]) / (A [high] - A [low]))
Jika kunci lebih rendah dari A [mid], maka high akan diulang hingga mid-1;
sebaliknya low akan diulang hingga mid+1. Ulangi proses sampai kunci telah
ditemukan atau low>high.
Contoh Algoritma Interpolation Search
DEKLARASI:
i := 1
j := n
LO := ai
HI := aj
DESKRIPSI:
if x < LO then return 0
end if
if x HI then i := j
loop invariant: x LO and x HI
end if
while (i<j) do
m := floor( i + (j-i)*(x-LO) / (HI-LO) )
MID := am
if (x > MID) then
i := m+1
LO := MID
else if (x < MID) then
j := m-1
HI := MID

else
return MID
end if
end if
end while
if (x ai) then i := 0
end if
return i
Contoh Program Interpolation Search
//--------------------------------------------------------------------------#include<conio.h>
#include<iostream.h>
class interpolation
{
int Key;
int Low,High,Mid;
public:
void InterSearch(int*,int);
};
void interpolation::InterSearch(int *Arr,int No)
{
int Key;
Low=0;High=No1;
cout<<\n\nEnter the Number to be searched = ;
cin>>Key;
while(Low < High)
{
Mid=Low+(HighLow)*((KeyArr[Low])/(Arr[High]Arr[Low]));
if (Key < Arr[Mid])
High=Mid1;
else if (Key > Arr[Mid])
Low=Mid+1;
else
{

cout<<\nThe key <<Key<< is found at the location <<Mid;

return;
}
};
cout<<\n\nThe Key <<Key<< is NOT found;
}
void main()
{
int *a,n,*b;
interpolation Ob;
clrscr();
cout<<\n\nEnter the number of elements : ;
cin>>n;
a=new int[n];
b=a;
for (int i=0;i<n;i++)
{
cout<<\nEnter the <<i<< element : ;
cin>>*a;
a++;
}
Ob.InterSearch(b,n);
cout<<\n\nPress any key to continue...;
getch();
}
//---------------------------------------------------------------------------

II.

Sorting
Pengurutan (sorting) adalah proses mengatur sekumpulan obyek menurut
urutan atau susunan tertentu [WIR76]. Urutan tersebut dapat menaik
(ascending) atau menurun (descending). Jika diberikan n buah elemen
disimpan di dalam larik L, maka:
- pengurutan menaik adalah L[0] L[1] L[2] ... L[n -1]
- pengurutan menurun adalah L[0] L[1] L[2] ... L[n -1].
A. Bubble Sort
Metode ini diinspirasi oleh gelembung sabun yang berada di permukaan air.
Karena berat jenis gelembung sabun lebih ringan dibandingkan dengan berat
jenis air, sehingga gelembung sabun selalu terapung di permukaan air. Prinsip
pengapungan inilah yang diterapkan ke metode ini, dimana nilai yang paling
rendah berada di posisi paling atas, melalui proses pertukaran.
Konsep dasar dari metode ini adalah setiap data yang ada di kumpulan,
dibandingkan dengan data-data lainnya, artinya jika jumlah data sebanyak 5,
maka akan terjadi pembandingan sebanyak (5-1)2 = 16 kali. Untuk satu data,
akan dibandingakan sebanyak 4 kali terhadap data yang lainnya.
Atau secara umum dapat ditarik rumus, untuk jumlah data sebanyak n buah,
maka:
Jumlah iterasi pembandingan = (n -1)2
Jika data-data tersebut disimpan di dalam lari L, maka:
1. untuk pengurutan menaik, pembandingannya sebagai berikut:
L[n] < L[n -1]
2. untuk pengurutan menurun, pembandingannya sebagai berikut:
L[n] > L[n -1] .
Jika kondisi di atas terpenuhi, maka nilai data yang ada di indeks n-1 akan
ditukar dengan nilai data yang ada di indeks n.

Contoh algoritma Bubble Sort

DEKLARASI
target, kiri, kanan, tukar1 : integer
item : array of integer {0..target}
selesai, tukar : boolean
DESKRIPSI
target = banyaknya elemen
selesai = false
while selesai = false
tukar = false
kiri = 1
kanan = 2
while kanan target
if item (kanan) < item (kiri)
swap item (kanan) dan item (kiri)
tukar = true
tukar1 = kiri
end_if
kiri = kiri + 1
kanan = kanan + 1
end_while
if tukar = false
selesai = true
else
target = tukar1
end_if
end_while

Contoh program Bubble Sort

//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include <conio.h>
//--------------------------------------------------------------------------#pragma argsused
int main(int argc, char* argv[])
{
int i,j,k;
int temp;
int L[10] = {20,15,22,14,12,10,24,19,18,16};
for(i=1;i<=9;i++)
{
for(j=9;j>=1;j--)
{
if(L[j]<L[j-1])
{
temp=L[j];
L[j]=L[j-1];
L[j-1]=temp;
}
}
}
for(i=0;i<=9;i++)
{
printf("%d ",L[i]);
}
getch();
return 0;
}
//---------------------------------------------------------------------------

B. Selection Sort
Metode ini memiliki konsep memilih data yang maksimum/minimum dari
suatu kumpulan data larik L, lalu menempatkan data tersebut ke elemen paling
akhir

atau

paling

awal

sesuai

pengurutan

yang

diinginkan.

Data

maksimum/minimum yang diperoleh, diasingkan ke tempat lain, dan tidak

diikutsertakan pada proses pencarian data maksimum/minimum berikutnya.
Perhatikan ilustrasi berikut:
Misalkan ada sekumpulan data acak berjumlah n elemen yang disimpan di
dalam larik L, akan diurut menaik,maka langkah-langkah yang harus dilakukan
adalah:
1. Menentukan jumlah iterasi, yaitu pass = n 2.
2. Untuk setiap pass ke-i = 0,1,2,...,pass, lakukan:
a. Cari elemen terbesar (maks) dari elemen ke-i sampai ke-(n-1).
b. Pertukarkan maks dengan elemen ke-i.
c. Kurangin n satu (n = n 1).
Rincian tiap-tiap pas adalah sebagai berikut:
- pass 0
Cari elemen maksimum di dalam L[0...(n-1)].
Pertukarakan elemen maksimum dengan elemen L[n-1].
- pass 1
Cari elemen maksimum di dalam L[0...(n-2)].
Pertukarakan elemen maksimum dengan elemen L[n-2].
- pass 2
Cari elemen maksimum di dalam L[0...(n-3)].
Pertukarakan elemen maksimum dengan elemen L[n-3].
- pass 3
Cari elemen maksimum di dalam L[0...1].
Pertukarakan elemen maksimum dengan elemen L[1].

Contoh algoritma Selection Sort

DEKLARASI
target, index, kecil, temp : integer
item : array of integer {0..target}
DESKRIPSI
target = banyaknya elemen
index = 1
while index < target do
kecil = index
temp = index + 1
while temp target do
if item(temp) < item(kecil) then
kecil = temp
end_if
temp = temp + 1
end_while
if kecil >< index then
swap item(index) dan item(kecil)
end_if
index = index + 1
end_while

Contoh program Selection Sort:

//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include <conio.h>
//--------------------------------------------------------------------------#pragma argsused
int main(int argc, char* argv[])
{
int i,j;
int Imaks,maks, temp;

int L[10] = {20,15,22,14,12,10,24,19,18,16};

for(i=9;i>=1;i--)
{
Imaks = 0;
maks = L[0];
for(j=1;j<=i;j++)
{
if(L[j]>maks)
{
Imaks = j;
maks = L[j];
}
}
temp=L[i];
L[i]=maks;
L[Imaks]=temp;
}
for(i=0;i<=9;i++)
{
printf("%d ",L[i]);
}
getch();
return 0;
}
//---------------------------------------------------------------------------

C. Insertion Search
Metode ini dilakukan dengan cara menyisipkan elemen larik pada posisi yang
tepat. Pencarian posisi yang tepat dilakukan dengan melakukan pencarian
beruntun di dalam larik.
Perhatikan tahap-tahap di bawah ini:
Misalkan ada sekumpulan data acak berjumlah n elemen yang disimpan di
dalam larik L, akan diurut menaik,maka langkah-langkah yang harus dilakukan
adalah:
1. Untuk setiap pass ke-i = 1,2,...,n-1 lakukan:
a. X = L[i]
b. Sisipkan x pada tempat yang sesuai anatara L[0]...L[i].
Rincian tiap-tiap pass adalah sebagai berikut:
Dianggap pass 0 : L[0] dianggap sudah pada tempatnya.
- pass 1
x = L[1] harus dicari tempatnya yang tepat pada L[0..1] dengan cara
menggeser elemen L[0..0] ke kanan bila L[0..0] lebih besar daripada
L[1]. Misalkan posisi yang tepat adalah k, sisipkan L[1] pada L[k].
- pass 2
x = L[2] harus dicari tempatnya yang tepat pada L[0..2] dengan cara
menggeser elemen L[0..1] ke kanan bila L[0..1] lebih besar daripada
L[2]. Misalkan posisi yang tepat adalah k, sisipkan L[2] pada L[k].
- pass n-1
x = L[n-1] harus dicari tempatnya yang tepat pada L[0..(n-1)] dengan
cara menggeser elemen L[0..(n-2)] ke kanan bila L[0..(n-2)] lebih besar
daripada L[n-1]. Misalkan posisi yang tepat adalah k, sisipkan L[n-1]
pada L[k].

Contoh algoritma Insertion Search

DEKLARASI
j,i,key : integer
A : array of integer {0..n}
DESKRIPSI
Inserion_Sort (A)
For j = 2 to length [A] do
key = A[j]
i j-1
while i > 0 and A[i] > key do
A[i+1] = A[i]
i = i-1
A[i+1] = key

Contoh program Insertion Sort:

//--------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include <conio.h>
//--------------------------------------------------------------------------#pragma argsused
int main(int argc, char* argv[])
{
int i,j;
int x;
bool ketemu;
int L[10] = {20,15,22,14,12,10,24,19,18,16};
for(i=1;i<=9;i++)
{
x = L[i];
j=i-1;
ketemu = false;
while ((j>=0)&&(!ketemu))

{
if(x < L[j])
{
L[j+1] = L[j];
j--;
}
else
{
ketemu = true;
}
}
L[j+1] = x;
}
for(i=0;i<=9;i++)
{
printf("%d ",L[i]);
}
getch();
return 0;
}
//---------------------------------------------------------------------------

D. Shell Sort
Shell Sort diperkenalkan untuk meningkatkan efisiensi sederhana Insertion
Sort. Shell Sort disebut juga Diminishing Increment Sort. Dalam metode ini,
sub-array, mengandung unsur k array asli, yang diurutkan.
Misalkan A sebuah array linier dari n bilangan A[1], A[2], A[3], ... A[n]
Langkah 1: array ini dibagi menjadi k sub-array yang terdiri dari setiap elemen
k . Katakanlah k = 5, maka lima sub-array, masing-masing berisi seperlima dari
elemen array asli .
Sub Array 1 A [ 0 ] A [ 5 ] A [ 10 ]
Sub Array 2 A [ 1 ] A [ 6 ] A [ 11 ]
Sub Array 3 A [ 2 ] A [ 7 ] A [ 12 ]
Sub Array 4 A [ 3 ] A [ 8 ] A [ 13 ]
Sub Array 5 A [ 4 ] A [ 9 ] A [ 14 ]
Catatan: Unsur i dari j sub array terletak sebagai A [ ( i- 1 ) k + j - 1 ]
Langkah 2: Setelah langkah pertama sub array yang k diurutkan (biasanya
dengan Insertion Sort ) , baru nilai yang lebih kecil dari k yang dipilih dan
array lagi dipartisi menjadi satu set baru sub array .
Langkah 3: Dan proses ini diulang dengan nilai yang lebih kecil dari k,
sehingga A[1], A[2], A[3], ... A[n] terurut.
Contoh algoritma Shell Sort
DEKLARASI
banyak, range, kiri, kanan, counter : integer
item : array of integer {0 .. N}
selesai : boolean
DESKRIPSI
banyak = N
range = banyak / 2
while range >< 0 do
counter = 1
target = banyak range
while counter >< target do
kiri = counter
selesai = false
while selesai = false do

kanan = kiri + range

if item(kiri) item(kanan) then
selesai = true
else
swap item(kiri) dan item(kanan)
if kiri > range then
kiri = kiri range
else
selesai = true
end_if
end_while
counter-counter + 1
end_while
range = range / 2
end_while

Contoh program Shell Sort

//--------------------------------------------------------------------------#include<conio.h>
#include<stdio.h>
#define MAX 20
void main()
{
int arr[MAX], i,j,k,n,incr;
clrscr();
printf (\nEnter the number of elements : ); scanf (%d,&n);
for (i=0;i < n;i++)
{
printf (\nEnter element %d : ,i+1); scanf (%d,&arr[i]);
}
printf (\nUnsorted list is :\n);
for (i = 0; i < n; i++)
printf (%d , arr[i]);
printf (\nEnter maximum increment (odd value) : );

scanf (%d,&incr);
while(incr>=1)
{
for (j=incr;j<n;j++)
{
k=arr[ j];
for(i = jincr; i > = 0 && k < arr[i]; i = iincr)
arr[i+incr]=arr[i];
arr[i+incr]=k;
}
printf (\nIncrement=%d \n,incr);
for (i = 0; i < n; i++)
printf(%d , arr[i]);
printf (\n);
incr=incr2;
}
printf (\nSorted list is :\n);
for (i = 0; i < n; i++)
printf (%d , arr[i]);
getch();
}
//--------------------------------------------------------------------------E. Quick Sort
Ini adalah salah satu dari banyak digunakan teknik pemilahan dan ia juga
disebut Partition Exchange Sort tersebut. Quick Sort adalah algoritma yang
efisien dan melewati kompleksitas waktu yang sangat baik dalam rata-rata
kasus. Ini dikembangkan oleh C.A.R. Hoare. Ini adalah algoritma jenis
pembagi dan pemecahan.
Contoh algoritma Quick Sort:
DEKLARASI
A : array of integer {0..n}
low high, n, pivot,location, leftwall : integer

DESKRIPSI
Sort(A)
Quicksort(A,1,n)
Quicksort(A, low, high)
if (low < high) then
pivot-location = Partition(A,low,high)
Quicksort(A, low, pivot-location-1)
Quicksort(A, pivot-location+1,high)
end if
Partition(A,low,high)
pivot = A[low]
leftwall = low
for i = low+1 to high
if (A[i] < pivot) then
leftwall = leftwall+1
swap(A[i],A[leftwall])
end if
swap(A[low],A[leftwall])
Contoh program Quick Sort
//--------------------------------------------------------------------------#include<conio.h>
#include<stdio.h>
#define MAX 30
enum bool {FALSE,TRUE};
void display(int arr[],int low,int up)
{
int i;
for(i=low;i<=up;i++)
printf (%d ,arr[i]);
}
void quick(int arr[],int low,int up)
{
int piv,temp,left,right;
enum bool pivot_placed=FALSE;
left=low;
right=up;
piv=low;
if (low>=up)
return;
printf (\nSublist : );

display(arr,low,up);
while(pivot_placed==FALSE)
{
while( arr[piv]<=arr[right] && piv!=right )
right=right1;
if ( piv==right )
pivot_placed=TRUE;
if ( arr[piv] > arr[right] )
{
temp=arr[piv];
arr[piv]=arr[right];
arr[right]=temp;
piv=right;
}
while( arr[piv]>=arr[left] && left!=piv )
left=left+1;
if (piv==left)
pivot_placed=TRUE;
if ( arr[piv] < arr[left] )
{
temp=arr[piv];
arr[piv]=arr[left];
arr[left]=temp;
piv=left;
}
}
printf (-> Pivot Placed is %d -> ,arr[piv]);
display(arr,low,up);
printf ("\n");
quick(arr,low,piv1);
quick(arr,piv+1,up);
}
void main()
{
int array[MAX],n,i;
clrscr();
printf (\nEnter the number of elements : ); scanf (%d,&n);
for (i=0;i<n;i++)
{
printf (\nEnter element %d : ,i+1); scanf (%d,&array[i]);
}
printf (\nUnsorted list is :\n);
display(array,0,n1);
printf (\n);
quick (array,0,n1);
printf (\nSorted list is :\n);
display(array,0,n1);
getch();
}
//---------------------------------------------------------------------------

F. Merge Sort
Penggabungan adalah proses menggabungkan dua atau lebih pengurutan array
menjadi bentuk ketiga pengurutan array. Itu adalah salah satu algoritma
pengurutan yang pertama kali digunakan pada komputer dan dikembangkan
oleh John Von Neumann. Membagi array menjadi sekitar n / 2 sub-array
ukuran dua dan mengatur elemen di setiap sub array. Penggabungan masingmasing sub-array dengan berdekatan sub-array akan mendapatkan lain
diurutkan sub-array ukuran empat. Ulangi proses ini sampai hanya ada satu
array sisa ukuran n.
Contoh algoritma Merge Sort
// a is an array of size n
mergeSort( a, n)
int * b := new int[n]
mSort( a, b, 0, n-1)
// a and b are arrays, l is left index, r is right index
mSort( a, b, l, r)
if r > l then
m := (r + l) / 2
mSort(a, b, l, m)
mSort(a, b, m+1, r)
end if
// copy lhs subarray of a to b
for i := l to m
b[i] := a[i]
// copy rhs subarray of a to b in reverse order
for j := m+1 to r
b[j] := a[r-j+m+1]
// merge the 2 sorted subarrays in b into one sorted array in a
for k := l to r
if b[i] < b[j] then
a[k] := b[i++ ]
else
a[k] := b[j--]
end if

Contoh program Merge Sort

//--------------------------------------------------------------------------#include<conio.h>
#include<stdio.h>
void main()
{
int arr1[20],arr2[20],arr3[40];
int i,j,k;
int max1,max2;
clrscr();
printf (\nEnter the number of elements in list1 : );
scanf (%d,&max1);
printf (\nTake the elements in sorted order :\n);
for (i=0;i<max1;i++)
{
printf (\nEnter element %d : ,i+1); scanf (%d,&arr1[i]);
}
printf (\nEnter the number of elements in list2 : );
scanf (%d,&max2);
printf (\nTake the elements in sorted order :\n);
for (i=0;i<max2;i++)
{
printf (\nEnter element %d : ,i+1); scanf (%d,&arr2[i]);
}
/* Merging */
i=0; j=0; k=0;
while( (i < max1) && (j < max2) )
{
if ( arr1[i] < arr2[j] )
arr3[k++]=arr1[i++];
else
arr3[k++]=arr2[j++];
}
while( i < max1 )
arr3[k++]=arr1[i++];
while( j < max2 )
arr3[k++]=arr2[j++];
/*Merging completed*/
printf (\nList 1 : );
for (i=0;i<max1;i++)
printf (%d ,arr1[i]);
printf (\nList 2 : );
for (i=0;i<max2;i++)
printf(%d ,arr2[i]);
printf (\nMerged list : );
for( i=0;i<max1+max2;i++)
printf (%d ,arr3[i]);
getch();
}

//---------------------------------------------------------------------------

G. Radix Sort
Radix Sort atau Bucket Sort adalah metode yang dapat digunakan untuk
mengurutkan daftar nomor dengan pada dasarnya. Jika kita ingin mengurutkan
daftar kata bahasa Inggris, di mana Radix atau dasar adalah 26, maka 26
Bucket digunakan untuk mengurutkan kata-kata.
Untuk mengurutkan array angka desimal, dimana Radix atau dasar adalah 10,
kita perlu 10 Bucket dan dapat dihitung sebagai 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Saat
Jumlah melewati, array diurutkan tergantung pada jumlah digit dalam elemen
terbesar.
Contoh algoritma Radix Sort
radixSort(list; N)
shift=1
for loop = 1 to keySize do
for entry = 1 to N do
bucketN o = (list[entry]:key=shif t) mod 10
append(bucket[bucketN o]; list[entry])
end for
list =combineBuckets()
shif t = shif t 10
end for
Contoh program Radix Sort
//--------------------------------------------------------------------------#include<stdio.h>
#include<conio.h>
#include<malloc.h>
struct node
{
int info;
struct node *link;
}*start=NULL;

//Display the array elements

void display()
{
struct node *p=start;
while( p !=NULL)
{
printf (%d , p->info);
p= p->link;
}
printf (\n);
}
int large_dig(struct node *p)
{
int large = 0,ndig = 0 ;
while (p != NULL)
{
if (p ->info > large)
large = p->info;
p = p->link ;
}
printf (\nLargest Element is %d , ,large);
while (large != 0)
{
ndig++;
large = large/10 ;
}
printf (\nNumber of digits in it are %d\n,ndig);
return(ndig);
}

int digit(int number, int k)

{
int digit, i ;
for (i = 1 ; i <=k ; i++)
{
digit = number % 10 ;
number = number /10 ;
}
return(digit);
}
void radix_sort()
{
int i,k,dig,maxdig,mindig,least_sig,most_sig;
struct node *p, *rear[10], *front[10];
least_sig=1;
most_sig=large_dig(start);
for (k = least_sig; k <= most_sig ; k++)
{
printf (\nPASS %d : Examining %dth digit from right ,k,k);
for(i = 0 ; i <= 9 ; i++)
{
rear[i] = NULL;
front[i] = NULL ;
}
maxdig=0;
mindig=9;
p = start ;
while( p != NULL)
{
dig = digit(p->info, k);
if (dig>maxdig)
maxdig=dig;
if (dig<mindig)
mindig=dig;
if (front[dig] == NULL)
front[dig] = p ;
else
rear[dig]->link = p ;
rear[dig] = p ;
p=p->link;
}
printf (\nmindig=%d maxdig=%d\n,mindig,maxdig);
start=front[mindig];
for i=mindig;i<maxdig;i++)
{
if (rear[i+1]!=NULL)
rear[i]->link=front[i+1];
else
rear[i+1]=rear[i];
}
rear[maxdig]->link=NULL;

printf (\nNew list : );

display();
}
}
void main()
{
struct node *tmp,*q;
int i,n,item;
clrscr();
printf (\nEnter the number of elements in the list : );
scanf (%d, &n);
for (i=0;i<n;i++)
{
printf (\nEnter element %d : ,i+1); scanf (%d,&item);
tmp=(struct node*)malloc(sizeof(struct node));
tmp->info=item;
tmp->link=NULL;
if (start==NULL)
start=tmp;
else
{
q=start;
while(q->link!=NULL)
q=q->link;
q->link=tmp;
}
}
printf (\nUnsorted list is :\n);
display();
radix_sort();
printf (\nSorted list is :\n);
display ();
getch();
}
//---------------------------------------------------------------------------

Referensi :
1. Analysis of Algorithms" by Jerey McConnell, Jones and Bartlett
Publishers, Sudbury, USA, 2007.
2. Data Structures and Algorithm Analysis", by Mark Allen Weiss, Pearson,
2012.
3. Introduction to algorithms", Thomas Cormen, Charles Leiserson, Ronald
Rivest and Cliord Stein, MIT Press, 2009.
4. Principles of Data Structure using C and C++, Vinu V Das M.E.S
College of Engineering Kuttipuram, Kerala, India, Published by New Age
International (P) Ltd., Publishers, 2006
5. Konsep Dan Aplikasi Pemrograman Menggunakan Borland C++ Builder

6, M. Fachurrozi.