Friday, December 23, 2016

Bab 11. Pemrograman C Belajar Dari Contoh



Bab. 11 Struktur Data Terapan

11.1 Menjumlahkan Elemen-Elemen Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/* Penjumlahan elemen-elemen array */
#include<stdio.h>
#include<conio.h>
void main()
{
   void baca(int *,int);
   void dis(int *,int);
   int a[5],i,jum=0;

   printf("Masukkan elemen-elemen ke dalam daftar \n");
   baca(a,5);       /*baca the list*/
   printf("Elemen-elemen di dalam daftar adalah \n");
   dis(a,5);
   for(i=0;i<5;i++) {
      jum+=a[i];
   }
   printf("Jumlah elemen-elemen di dalam daftar adalah %d\n",jum);
   getch();
}

void baca(int c[],int i)
{
   int j;
   for(j=0;j<i;j++)
     scanf("%d",&c[j]);
   fflush(stdin);
}

void dis(int d[],int i)
{
   int j;
   for(j=0;j<i;j++)
     printf("%d ",d[j]);
   printf("\n");
}


Masukkan elemen-elemen ke dalam daftar
34
54
76
78
65
Elemen-elemen di dalam daftar adalah
34 54 76 78 65
Jumlah elemen-elemen di dalam daftar adalah 307



11.2 Menjumlahkan Dua Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/* Penjumlahan dua array */
#include<stdio.h>
#include<conio.h>
void main()
{
   void baca(int *,int);
   void dis(int *,int);
   void tambah(int *,int *,int * ,int);
   int a[5],b[5],c[5],i;

   printf("Masukkan elemen-elemen ke daftar pertama \n");
   baca(a,5);       /*membaca daftar pertama*/
   printf("Elemen-elemen array pertama adalah \n");
   dis(a,5);  /*Menampilkan array pertama*/
   printf("Masukkan elemen-elemen ke daftar kedua \n");
   baca(b,5);      /*membaca array kedua*/
   printf("Elemen-elemen array kedua adalah \n");
   dis(b,5);  /*Menampilkan array kedua*/
   tambah(a,b,c,i);
   printf("Array hasil perjumlahan adalah \n");
   dis(c,5);
   getch();
 }

void tambah(int a[],int b[],int c[],int i)
{
  for(i=0;i<5;i++){
       c[i]=a[i]+b[i];
  }
}

void baca(int c[],int i)
{
  int j;
  for(j=0;j<i;j++)
    scanf("%d",&c[j]);
  fflush(stdin);
}

void dis(int d[],int i)
{
  int j;
  for(j=0;j<i;j++)
    printf("%d ",d[j]);
  printf("\n");
}


Masukkan elemen-elemen ke daftar pertama
32
34
45
65
54
Elemen-elemen array pertama adalah
32 34 45 65 54
Masukkan elemen-elemen ke daftar kedua
65
43
66
76
87
Elemen-elemen array kedua adalah
65 43 66 76 87

Array hasil perjumlahan adalah
97 77 111 141 141



11.3 Membalikkan Isi Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/* Membalikkan isi array */
#include<stdio.h>
#include<conio.h>
void main()
{
   void baca(int *,int);
   void dis(int *,int);
   void balik(int *,int *,int);
   int a[5],b[5];
   baca(a,5);
   dis(a,5);
   balik(a,b,5);
   dis(b,5);
   getch();
}

void baca(int c[],int i)
{
   int j;
   printf("Masukkan array \n");
   for(j=0;j<i;j++)
      scanf("%d",&c[j]);
   fflush(stdin);
}
void dis(int d[],int i)
{
   int j;
   printf("Array adalah \n");
   for(j=0;j<i;j++)
      printf("%d ",d[j]);
   printf("\n");
}
void balik(int a[],int balik_b[],int j)
{
   int i,k;
   k=j-1;
   for(i=0;i<j;i++){
      balik_b[i]=a[k];
      k--;
   }
}


Masukkan array
23
32
33
45
45
Array adalah
23 32 33 45 45

Array adalah
45 45 33 32 23



11.4 Mengurutkan dan Menggabungkan Dua Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/* Menggabungkan dan mengurutkan dua array */
#include<stdio.h>
#include<conio.h>
void main()
{
   void baca(int *,int);
   void dis(int *,int);
   void urut(int *,int);
   void gabung(int *,int *,int *,int);
   int a[5],b[5],c[10];
   printf("Masukkan array pertama \n");
   baca(a,5);      /*membaca array*/
   printf("Elemen-elemen array pertama adalah \n");
   dis(a,5);  /*menampilkan array pertama*/
   printf("Masukkan array kedua \n");
   baca(b,5);   /*read the list*/
   printf("Elemen-elemen array kedua adalah \n");
   dis(b,5);  /*menampilkan array kedua*/
   urut(a,5);
   printf("array a terurut adalah:\n");
   dis(a,5);
   urut(b,5);
   printf("array b terurut adalah:\n");
   dis(b,5);

   gabung(a,b,c,5);
   printf("Elemen-elemen dari array yang digabung adalah \n");
   dis(c,10);  /*menampilkan array yang sudah digabung*/
   getch();
}
void baca(int c[],int i)
{
   int j;
   for(j=0;j<i;j++)
      scanf("%d",&c[j]);
   fflush(stdin);
}

void dis(int d[],int i)
{
   int j;
   for(j=0;j<i;j++)
      printf("%d ",d[j]);
   printf("\n");
}

void urut(int arr[] ,int k)
{
   int temp;
   int i,j;
   for(i=0;i<k;i++){
      for(j=0;j<k-i-1;j++){
         if(arr[j]<arr[j+1])
         {
            temp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
         }
      }
   }
}

void gabung(int a[],int b[],int c[],int k)
{
   int ptra=0,ptrb=0,ptrc=0;
   while(ptra<k && ptrb<k)
   {
      if(a[ptra] < b[ptrb])
      {
            c[ptrc]=a[ptra];
         ptra++;
      }
      else
      {
            c[ptrc]=b[ptrb];
         ptrb++;
      }
      ptrc++;
   }
   while(ptra<k)
   {
      c[ptrc]=a[ptra];
      ptra++;ptrc++;
   }
   while(ptrb<k)
   {
      c[ptrc]=b[ptrb];
      ptrb++;  ptrc++;
   }
}


Masukkan array pertama
23
43
32
22
43
Elemen-elemen array pertama adalah
23 43 32 22 43
Masukkan array kedua
45
65
54
75
76
Elemen-elemen array kedua adalah
45 65 54 75 76
array a terurut adalah:
43 43 32 23 22
array b terurut adalah:
76 75 65 54 45
ELemen-elemen dari array yang digabung adalah
43 43 32 23 22 76 75 65 54 45



11.5 Transposisi Matriks

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/* Transposisi Matriks */
#include<stdio.h>
#include<conio.h>
#define BARIS 3
#define KOLOM 3

void main()
{
   void baca(int a[][KOLOM],int,int);
   void dis(int a[][KOLOM],int,int);
   void trans(int a[][KOLOM],int,int);
   int a[3][3];
  
   baca(a,BARIS,KOLOM);
   printf("\nMatriks adalah \n");
   dis(a,BARIS,KOLOM);
   trans(a,BARIS,KOLOM);
   printf("Transposisi atas matriks adalah\n");
   dis(a,BARIS,KOLOM);
   getch();
}

void baca(int c[3][3] ,int i ,int k)
{
   int j,l;
   printf("Masukkan array \n");
   for(j=0;j<i;j++)
      for(l=0;l<k;l++)
         scanf("%d",&c[j][l]);
   fflush(stdin);
}

void dis(int d[3][3 ],int i,int k)
{
   int j,l;
   for(j=0;j<i;j++)
   {
      for(l=0;l<k;l++)
        printf("%d ",d[j][l]);
      printf("\n");
   }
}

void trans(int mat[][3],int k ,int l)
{
   int i,j,temp;
   for(i=0;i<k;i++)
   {
       for(j=i+1;j<l;j++)
      {
         temp=mat[i][j];
         mat[i][j]=mat[j][i];
         mat[j][i]=temp;
      }
   }
}


Masukkan array
32
44
54
54
65
75
76
78
76

Matriks adalah
32 44 54
54 65 75
76 78 76
Transposisi atas matriks adalah
32 54 76
44 65 78
54 75 76



11.6 Pengurutan Quick

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/* Pengurutan Quick */
#include <stdio.h>
#define MAKS 10

void tukar(int *x,int *y)
{
   int temp;
   temp = *x;
   *x = *y;
   *y = temp;
}

int posisiKunci(int i,int j )
{
   return((i+j) /2);
}

void pengurutanQuick(int daftar[],int m,int n)
{
   int kunci,i,j,k;
   if( m < n)
   {
      k = posisiKunci(m,n);
      tukar(&daftar[m],&daftar[k]);
      kunci = daftar[m];
      i = m+1;
      j = n;
      while(i <= j)
      {
         while((i <= n) && (daftar[i] <= kunci))
                i++;
         while((j >= m) && (daftar[j] > kunci))
                j--;
         if( i < j)
                tukar(&daftar[i],&daftar[j]);
      }
      tukar(&daftar[m],&daftar[j]);
      pengurutanQuick(daftar,m,j-1);
      pengurutanQuick(daftar,j+1,n);
   }
}

void bacadaftar(int daftar[],int n)
{
   int i;
   printf("Masukkan elemen-elemen\n");
   for(i=0;i<n;i++)
       scanf("%d",&daftar[i]);
}

void tampilDaftar(int daftar[],int n)
{
   int i;
   printf("Elemen-elemen di dalam daftar adalah: \n");
   for(i=0;i<n;i++)
       printf("%d\t",daftar[i]);
}

void main()
{
   int daftar[MAKS], n;
   printf("Masukkan jumlah elemen di dalam daftar maks = 10\n");
   scanf("%d",&n);
   bacadaftar(daftar,n);
   printf("Daftar sebelum pengurutan adalah:\n");
   tampilDaftar(daftar,n);
   pengurutanQuick(daftar,0,n-1);
   printf("\nDaftar setelah pengurutan adalah:\n");
   tampilDaftar(daftar,n);
}


Masukkan jumlah elemen di dalam daftar maks = 10
6
Masukkan elemen-elemen
32
34
45
65
55
77
Daftar sebelum pengurutan adalah:
Elemen-elemen di dalam daftar adalah:
32      34      45      65      55      77

Daftar setelah pengurutan adalah:
Elemen-elemen di dalam daftar adalah:
32      34      45      55      65      77     



11.7 Pengurutan Heap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/* Pengurutan Heap */
#include <stdio.h>
#define MAKS 10

void tukar(int *x,int *y)
{
   int temp;
   temp = *x;
   *x = *y;
   *y = temp;
}

void ubah( int list[],int i, int n)
{
   int j,k,flag;
   k = list[i];
   flag = 1;
   j = 2 * i;
   while(j <= n && flag)
   {
      if(j < n && list[j] < list[j+1])
         j++;
      if( k >= list[j])
         flag =0;
      else
      {
         list[j/2] = list[j];
         j = j *2;
      }
   }
   list [j/2] = k;
}

void bangun_heap_awal( int list[], int n)
{
   int i;
   for(i=(n/2);i>=0;i--)
       ubah(list,i,n-1);
}

void pengurutanHeap(int list[],int n)
{
   int i;
   bangun_heap_awal(list,n);
   for(i=(n-2); i>=0;i--)
   {
      tukar(&list[0],&list[i+1]);
      ubah(list,0,i);
   }
}

void bacaList(int list[],int n)
{
   int i;
   printf("Masukkan elemen-elemen:\n");
   for(i=0;i<n;i++)
       scanf("%d",&list[i]);
}

void tampilList(int list[],int n)
{
   int i;
   printf("Elemen-elemen adalah: \n");
   for(i=0;i<n;i++)
       printf("%d\t",list[i]);
}

void main()
{
   int list[MAKS], n;
   printf("Masukkan jumlah elemen di dalam list, maks = 10\n");
   scanf("%d",&n);
   bacaList(list,n);
   printf("List sebelum pengurutan adalah:\n");
   tampilList(list,n);
   pengurutanHeap(list,n);
   printf("List setelah pengurutan adalah:\n");
   tampilList(list,n);
}


Masukkan jumlah elemen di dalam list, maks = 10
6
Masukkan elemen-elemen:
43
33
55
66
77
88
List sebelum pengurutan adalah:
Elemen-elemen adalah:
43      33      55      66      77      88     

List setelah pengurutan adalah:
Elemen-elemen adalah:
33      43      55      66      77      88            


11.8 Pencarian Biner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/* Pencarian Biner */
#include <stdio.h>
#define MAKS 10

void pencarianBiner(int list[],int n,int elemen)
{
   int l,u,m, flag = 0;
   l = 0;
   u = n-1;
   while(l <= u)
   {
      m = (l+u)/2;
      if( list[m] == elemen)
      {
         printf(" Elemen dengan nilai %d ada pada posisi %d \n", elemen,m);
         flag =1;
         break;
      }
      else
            if(list[m] < elemen)
                   l = m+1;
            else
                   u = m-1;
   }
   if( flag == 0)
      printf("Elemen dengan nilai %d tidak ada\n", elemen);
}

void bacaList(int list[],int n)
{
   int i;
   printf("Masukkan elemen-elemen\n");
   for(i=0;i<n;i++)
       scanf("%d",&list[i]);
}

void tampilList(int list[],int n)
{
    int i;
   printf("Elemen-elemen di dalam list adalah: \n");
   for(i=0;i<n;i++)
       printf("%d\t",list[i]);
}

void main()
{
   int list[MAKS], n, elemen;
   printf("Jumlah elemen di dalam list, maks = 10\n");
   scanf("%d",&n);
   bacaList(list,n);
   printf("\nList sebelum pengurutan adalah:\n");
   tampilList(list,n);
   printf("\nMasukkan elemen yang akan dicari\n");
   scanf("%d",&elemen);
   pencarianBiner(list,n,elemen);
}


Jumlah elemen di dalam list, maks = 10
8
Masukkan elemen-elemen
45
44
7
87
76
98
90
43

List sebelum pengurutan adalah:
Elemen-elemen di dalam list adalah:
45      44      7       87      76      98      90      43
Masukkan elemen yang akan dicari
98
Elemen dengan nilai 98 ada pada posisi 5            



11.9 Tumpukan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/* Program untuk tumpukan */
#include <stdio.h>
#define MAKS 10 /* The maximum size of the tumpukan */
#include <stdlib.h>

void tempatkanpadaTumpukan(int tumpukan[], int *atas, int nilai)
{
   if(*atas < MAKS ) {
      *atas = *atas + 1;
      tumpukan[*atas] = nilai;
   }
  else {
      printf("Tumpukan penuh, tidak bisa menempatkan nilai pada tumpukan\n");
      exit(0);
  }
}
void ambilDariTumpukan(int tumpukan[], int *atas, int * nilai)
{
   if(*atas >= 0 ) {
      *nilai = tumpukan[*atas];
      *atas = *atas - 1;
   }
   else {
      printf("Tumpukan kosong, tidak bisa mengambil nilai dari tumpukan\n");
      exit(0);
   }
}

void main()
{
   int tumpukan[MAKS];
   int atas = -1;
   int n,nilai;
   do
   {
      do
      {
         printf("Masukkan elemen pada tumpukan:\n");
         scanf("%d",&nilai);
         tempatkanpadaTumpukan(tumpukan,&atas,nilai);
         printf("Masukkan 1 untuk lanjut\n");
         scanf("%d",&n);
      } while(n == 1);

      printf("Masukkan 1 untuk mengambil elemen dari tumpukan\n");
      scanf("%d",&n);
      while( n == 1)
      {
            ambilDariTumpukan(tumpukan,&atas,&nilai);
            printf("Nilai yang diambil dari tumpukan adalah %d\n",nilai);
            printf("Masukkan 1 untuk mengambil elemen dari tumpukan\n");
            scanf("%d",&n);
      }
      printf("Masukkan 1 untuk lanjut\n");
      scanf("%d",&n);
   } while(n == 1);
}


Masukkan elemen pada tumpukan:
10
Masukkan 1 untuk lanjut
1
Masukkan elemen pada tumpukan:
20
Masukkan 1 untuk lanjut
1
Masukkan elemen pada tumpukan:
30
Masukkan 1 untuk lanjut
0
Masukkan 1 untuk mengambil elemen dari tumpukan
1
Nilai yang diambil dari tumpukan adalah 30
Masukkan 1 untuk mengambil elemen dari tumpukan
1
Nilai yang diambil dari tumpukan adalah 20
Masukkan 1 untuk mengambil elemen dari tumpukan
1
Nilai yang diambil dari tumpukan adalah 10
Masukkan 1 untuk mengambil elemen dari tumpukan            


11.10 Tumpukan Dengan Senarai Berantai

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/* Tumpukan dengan senarai berantai */
#include <stdio.h>
#include <stdlib.h>

struct simpul
{
   int data;
   struct simpul *link;
};

struct simpul *tempatkanPadaTumpukan(struct simpul *p, int nilai)
{
   struct simpul *temp;
   temp=(struct simpul *)malloc(sizeof(struct simpul));
       /* menciptakan simpul baru menggunakan
          nilai yang dilewatkan sebagai parameter */
   if(temp==NULL) {
      printf("Memori tidak tersedia\n");
      exit(0);
   }
   temp->data = nilai;
   temp->link = p;
   p = temp;
   return(p);
}

struct simpul *ambilDariTumpukan(struct simpul *p, int *nilai)
{
   struct simpul *temp;
   if(p==NULL) {
      printf(" Tumpukan kosong, tidak bisa diambil\n");
      exit(0);
   }
   *nilai = p->data;
   temp = p;
   p = p->link;
   free(temp);
   return(p);
}

void main()
{
   struct simpul *top = NULL;
   int n,nilai;
   do
   {
      do
      {
         printf("Masukkan elemen yang akan ditempatkan pada tumpukan:\n");
         scanf("%d",&nilai);
         top = tempatkanPadaTumpukan(top,nilai);
         printf("Masukkan 1 untuk lanjut\n");
         scanf("%d",&n);
      } while(n == 1);

      printf("Masukkan 1 untuk mengambil elemen dari tumpukan\n");
      scanf("%d",&n);
      while( n == 1)
      {
         top = ambilDariTumpukan(top,&nilai);
         printf("Nilai yang diambil dari tumpukan adalah %d\n",nilai);
         printf("Masukkan 1 untuk mengambil elemen dari tumpukan\n");
         scanf("%d",&n);
      }
      printf("Masukkan 1 untuk lanjut\n");
      scanf("%d",&n);
   } while(n == 1);
}


Masukkan elemen yang akan ditempatkan pada tumpukan:
10
Masukkan 1 untuk lanjut
1
Masukkan elemen yang akan ditempatkan pada tumpukan:
20
Masukkan 1 untuk lanjut
1
Masukkan elemen yang akan ditempatkan pada tumpukan:
30
Masukkan 1 untuk lanjut
0
Masukkan 1 untuk mengambil elemen dari tumpukan
1
Nilai yang diambil dari tumpukan adalah 30
Masukkan 1 untuk mengambil elemen dari tumpukan
1
Nilai yang diambil dari tumpukan adalah 20
Masukkan 1 untuk mengambil elemen dari tumpukan
1
Nilai yang diambil dari tumpukan adalah 10
Masukkan 1 untuk mengambil elemen dari tumpukan            





11.11 Antrian

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/* Program untuk mensimulasikan antrian */
#include <stdio.h>
#define MAKS 10 /* Ukuran maksimum antrian */
#include <stdlib.h>

void sisip(int antrian[], int *belakang, int nilai)
{
   if(*belakang < MAKS-1)
   {
      *belakang= *belakang +1;
      antrian[*belakang] = nilai;
   }
   else
   {
      printf("Antrian penuh, tidak bisa menyisipkan suatu nilai\n");
      exit(0);
   }
}

void hapus(int antrian[], int *depan, int belakang, int * nilai)
{
   if(*depan == belakang)
   {
      printf("Antrian kosong, tidak bisa menghapus suatu nilai\n");
      exit(0);
   }
   *depan = *depan + 1;
   *nilai = antrian[*depan];
}

void main()
{
   int antrian[MAKS];
   int depan,belakang;
   int n,nilai;
   depan=belakang=(-1);
   do
   {
      do
      {
         printf("Masukkan elemen yang akan disisipkan\n");
         scanf("%d",&nilai);
         sisip(antrian,&belakang,nilai);
         printf("Masukkan 1 untuk lanjut\n");
         scanf("%d",&n);
      } while(n == 1);

      printf("Masukkan 1 untuk menghapus suatu elemen\n");
      scanf("%d",&n);
      while( n == 1)
      {
         hapus(antrian,&depan,belakang,&nilai);
         printf("Nilai yang dihapus adalah %d\n",nilai);
         printf("Masukkan 1 untuk menghapus suatu elemen\n");
         scanf("%d",&n);
      }
      printf("Masukkan 1 untuk lanjut\n");
      scanf("%d",&n);
   } while(n == 1);
}


Masukkan elemen yang akan disisipkan
10
Masukkan 1 untuk lanjut
1
Masukkan elemen yang akan disisipkan
20
Masukkan 1 untuk lanjut
1
Masukkan elemen yang akan disisipkan
30
Masukkan 1 untuk lanjut
0
Masukkan 1 untuk menghapus suatu elemen
20
Masukkan 1 untuk lanjut
0            


14.12 Antrian Sirkular

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/* Program untuk mensimulasikan antrian sirkular */
#include <stdio.h>
#define MAKS 10 /* Ukuran maksimum dari antrian */
#include <stdlib.h>

void sisip(int antrian[], int *belakang, int depan, int nilai)
{
   *belakang= (*belakang +1) % MAKS;
   if(*belakang == depan)
   {
      printf("Antrian penuh, nilai tidak bisa disisipkan\n");
      exit(0);
   }
   antrian[*belakang] = nilai;
}

void hapus(int antrian[], int *depan, int belakang, int * nilai)
{
   if(*depan == belakang)
   {
      printf("Antrian kosong, nilai tidak bisa dihapus\n");
      exit(0);
   }
   *depan = (*depan + 1) % MAKS;
   *nilai = antrian[*depan];
}

void main()
{
   int antrian[MAKS];
   int depan,belakang;
   int n,nilai;
   depan=0; belakang=0;
   do
   {
      do
      {
         printf("Masukkan elemen yang akan disisipkan\n");
         scanf("%d",&nilai);
         sisip(antrian,&belakang,depan,nilai);
         printf("Masukkan 1 untuk lanjut\n");
         scanf("%d",&n);
      } while(n == 1);

   printf("Masukkan 1 untuk menghapus suatu elemen\n");
   scanf("%d",&n);
   while( n == 1)
   {
      hapus(antrian,&depan,belakang,&nilai);
      printf("Nilai yang dihapus adalah %d\n",nilai);
      printf("Masukkan 1 untuk menghapus suatu elemen\n");
      scanf("%d",&n);
   }
   printf("Masukkan 1 untuk lanjut\n");
   scanf("%d",&n);
   } while(n == 1);
}


Masukkan elemen yang akan disisipkan
10
Masukkan 1 untuk lanjut
1
Masukkan elemen yang akan disisipkan
20
Masukkan 1 untuk lanjut
1
Masukkan elemen yang akan disisipkan
30
Masukkan 1 untuk lanjut
0
Masukkan 1 untuk menghapus suatu elemen
1
Nilai yang dihapus adalah 10
Masukkan 1 untuk menghapus suatu elemen
1
Nilai yang dihapus adalah 20
Masukkan 1 untuk menghapus suatu elemen
1
Nilai yang dihapus adalah 30
Masukkan 1 untuk menghapus suatu elemen
1
Antrian kosong, nilai tidak bisa dihapus            



11.13 Antrian Dengan Senarai Berantai

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/* Program untuk mensimulasikan antrian menggunakan senarai berantai */
#include <stdio.h>
#include <stdlib.h>
struct simpul
{
   int data;
   struct simpul *link;
};

void sisip(struct simpul **depan, struct simpul **belakang, int nilai)
{
   struct simpul *temp;
   temp=(struct simpul *) malloc(sizeof(struct simpul));
   /* menciptakan simpul baru
      menggunakan nilai
      yang dilewatkan sebagai parameter */
   if(temp==NULL)
   {
      printf("Memori tidak tersedia\n");
      exit(0);
   }
   temp->data = nilai;
   temp->link=NULL;
   if(*belakang == NULL)
   {
      *belakang = temp;
      *depan = *belakang;
   }
   else
   {
      (*belakang)->link = temp;
      *belakang = temp;
   }
}

void hapus(struct simpul **depan, struct simpul **belakang, int *nilai)
{
   struct simpul *temp;
   if((*depan == *belakang) && (*belakang == NULL))
   {
      printf("Antrian kosong, tidak bisa menghapus nilai\n");
      exit(0);
   }
   *nilai = (*depan)->data;
   temp = *depan;
   *depan = (*depan)->link;
   if(*belakang == temp)
   *belakang = (*belakang)->link;
   free(temp);
}

void main()
{
   struct simpul *depan=NULL,*belakang = NULL;
   int n,nilai;
   do
   {
      do
      {
         printf("Masukkan elemen yang akan disisipkan\n");
         scanf("%d",&nilai);
         sisip(&depan,&belakang,nilai);
         printf("Masukkan 1 untuk lanjut\n");
         scanf("%d",&n);
      } while(n == 1);

      printf("Masukkan 1 untuk menghapus suatu elemen\n");
      scanf("%d",&n);
      while( n == 1)
      {
            hapus(&depan,&belakang,&nilai);
            printf("Nilai yang dihapus adalah %d\n",nilai);
            printf("Masukkan 1 untuk menghapus sebuah elemen\n");
            scanf("%d",&n);
      }
      printf("Masukkan 1 untuk lanjut\n");
      scanf("%d",&n);
   } while(n == 1);
}


Masukkan elemen yang akan disisipkan
10
Masukkan 1 untuk lanjut
1
Masukkan elemen yang akan disisipkan
20
Masukkan 1 untuk lanjut
1
Masukkan elemen yang akan disisipkan
30
Masukkan 1 untuk lanjut
0
Masukkan 1 untuk menghapus suatu elemen
1
Nilai yang dihapus adalah 10
Masukkan 1 untuk menghapus sebuah elemen
1
Nilai yang dihapus adalah 20
Masukkan 1 untuk menghapus sebuah elemen
1
Nilai yang dihapus adalah 30
Masukkan 1 untuk menghapus sebuah elemen
1
Antrian kosong, tidak bisa menghapus nilai            



11.14 Menyisipkan Simpul Dengan Program Rekursif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/* Menyisipkan simpul dengan program rekursif*/
#include <stdio.h>
#include <stdlib.h>
struct simpul
{
  int data;
  struct simpul *link;
};

struct simpul *sisip(struct simpul *p, int n)
{
   struct simpul *temp;
   if(p==NULL)
   {
      p=(struct simpul *)malloc(sizeof(struct simpul));
      if(p==NULL)
      {
          printf("Error\n");
          exit(0);
      }
      p-> data = n;
      p-> link = NULL;
   }
   else
      p->link = sisip(p->link,n); /* loop while digantikan pemanggilan rekursif */
      return (p);
   }
  
void tampilList ( struct simpul *p )
{
      printf("Data di dalam list adalah\n");
      while (p!= NULL)
      {
         printf("%d\t",p-> data);
         p = p-> link;
      }
}
  
void main()
{
      int n;
      int x;
      struct simpul *awal = NULL ;
      printf("Masukkan simpula yang akan diciptakan \n");
      scanf("%d",&n);
      while ( n-- > 0 )
      {
         printf( "Masukkan nilai-nilai yang akan ditempatkan ke dalam suatu simpul\n");
            scanf("%d",&x);
            awal = sisip ( awal, x );
         }
         printf("List yang diciptakan adalah\n");
         tampilList ( awal );
}


Masukkan simpula yang akan diciptakan
5
Masukkan nilai-nilai yang akan ditempatkan ke dalam suatu simpul
34
Masukkan nilai-nilai yang akan ditempatkan ke dalam suatu simpul
54
Masukkan nilai-nilai yang akan ditempatkan ke dalam suatu simpul
56
Masukkan nilai-nilai yang akan ditempatkan ke dalam suatu simpul
76
Masukkan nilai-nilai yang akan ditempatkan ke dalam suatu simpul
78

List yang diciptakan adalah
Data di dalam list adalah
34      54      56      76      78    



11.15 Program Mengurutkan Dengan Senarai Berantai

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
/* Program mengurutkan list */
#include <stdio.h>
#include <stdlib.h>
struct simpul
{
   int data;
   struct simpul *link;
};
struct simpul *sisip(struct simpul *p, int n)
{
   struct simpul *temp;
   if(p==NULL)
   {
      p=(struct simpul *)malloc(sizeof(struct simpul));
      if(p==NULL)
      {
            printf("Error\n");
         exit(0);
      }
      p-> data = n;
      p-> link = NULL;
   }
   else
   {
      temp = p;
      while (temp-> link!= NULL)
      temp = temp-> link;
      temp-> link = (struct simpul *)malloc(sizeof(struct simpul));
      if(temp -> link == NULL)
      {
         printf("Error\n");
         exit(0);
      }
       temp = temp-> link;
       temp-> data = n;
       temp-> link = NULL;
   }
   return(p);
}

void tampilList ( struct simpul *p )
{
   printf("Nilai-nilai data di dalam list adalah\n");
   while (p!= NULL)
   {
      printf("%d\t",p-> data);
      p = p-> link;
   }
}

/* fungsi untuk membalikkan */
struct simpul *terbalik(struct simpul *p)
{
   struct simpul *prev, *curr;
   prev = NULL;
   curr = p;
   while (curr != NULL)
   {
      p = p-> link;
      curr-> link = prev;
      prev = curr;
      curr = p;
   }
   return(prev);
}
/* fungsi untuk mengurutkan list */
struct simpul *urutList(struct simpul *p)
{
   struct simpul *temp1,*temp2,*min,*prev,*q;
   q = NULL;
   while(p != NULL)
   {
      prev = NULL;
      min = temp1 = p;
      temp2 = p -> link;
      while ( temp2 != NULL )
      {
         if (min -> data > temp2 -> data)
         {
            min = temp2;
            prev = temp1;
         }
         temp1 = temp2;
         temp2 = temp2-> link;
      }
      if(prev == NULL)
         p = min -> link;
      else
         prev -> link = min -> link;
      min -> link = NULL;
      if( q == NULL)
         q = min; /* memindahkan simpul dengan nilai data terendah di
                     dalam list yang ditunjuk oleh p ke list
                     yang ditunjuk oleh q sebagai simpul pertama */
      else
      {
         temp1 = q;
         /* menjelajah list yang ditunjuk oleh q untuk
            mendapatkan pointer ke simpul terakhir */
         while( temp1 -> link != NULL)
            temp1 = temp1 -> link;
         /* memindahkan simpul dengan nilai data terendah
            di dalam list yang ditunjuk oleh p ke list yang
            ditunjuk oleh q di akhir list yang ditunjuk q */
         temp1 -> link = min;
      }
   }
   return (q);
}

void main()
{
   int n;
   int x;
   struct simpul *awal = NULL ;
   printf("Masukkan simpul yang akan diciptakan \n");
   scanf("%d",&n);
   while ( n-- > 0 )
   {
      printf( "Masukkan nilai data yang akan ditempatkan ke suatu simpul\n");
      scanf("%d",&x);
      awal = sisip ( awal,x);
   }
   printf("List yang diciptakan adalah\n");
   tampilList ( awal );
   awal = urutList(awal);
   printf("List yang terurut adalah\n");
   tampilList ( awal );
   awal = terbalik(awal);
   printf("List yang terbalik adalah\n");
   tampilList ( awal );
}


Masukkan simpul yang akan diciptakan
5
Masukkan nilai-nilai data yang akan ditempatkan ke suatu simpul
23
Masukkan nilai-nilai data yang akan ditempatkan ke suatu simpul
32
Masukkan nilai-nilai data yang akan ditempatkan ke suatu simpul
54
Masukkan nilai-nilai data yang akan ditempatkan ke suatu simpul
56
Masukkan nilai-nilai data yang akan ditempatkan ke suatu simpul
67
List yang diciptakan adalah
Nilai-nilai data di dalam list adalah
23      32      54      56      67      
List yang terurut adalah
Nilai-nilai data di dalam list adalah
23      32      54      56      67     
List yang terbalik adalah
Nilai-nilai data di dalam list adalah
67      56      54      32      23     



11.16 Program Menghapus Simpul Senarai Berantai

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/* Program menghapus simpul senarai berantai */
#include <stdio.h>
#include <stdlib.h>
struct simpul *hapus ( struct simpul *, int );
int panjang ( struct simpul * );

struct simpul
{
   int data;
   struct simpul *link;
};

struct simpul *sisip(struct simpul *p, int n)
{
   struct simpul *temp;
   if(p==NULL)
   {
      p=(struct simpul *)malloc(sizeof(struct simpul));
      if(p==NULL)
      {
            printf("Error\n");
         exit(0);
      }
      p-> data = n;
      p-> link = NULL;
   }
   else
   {
      temp = p;
      while (temp-> link != NULL)
      temp = temp-> link;
      temp-> link = (struct simpul *)malloc(sizeof(struct simpul));
      if(temp -> link == NULL)
      {
         printf("Error\n");
         exit(0);
      }
      temp = temp-> link;
      temp-> data = n;
      temp-> link = NULL;
      }
      return (p);
}

void tampilList ( struct simpul *p )
{
   printf("Nilai-nilai data di dalam list adalah\n");
   while (p!= NULL)
   {
      printf("%d\t",p-> data);
      p = p-> link;
   }
}

void main()
{
   int n;
   int x;
   struct simpul *awal = NULL;
   printf("Masukkan jumlah simpul yang akan diciptakan \n");
   scanf("%d",&n);
   while ( n-- > 0 )
   {
      printf( "Masukkan nilai-nilai data yang akan ditempatkan pada simpul\n");
      scanf("%d",&x);
      awal = sisip ( awal, x );
   }
   printf("List sebelum penghapusan adalah\n");
   tampilList ( awal );
   printf("% \n Masukkan nomor simpul\n");
   scanf ( " %d",&n);
   awal = hapus (awal , n );
   printf("List setelah penghapusan adalah\n");
   tampilList ( awal );
}

/* fungsi untuk menghapus simpul tertentu*/
struct simpul *hapus ( struct simpul *p, int simpul_no )
{
   struct simpul *prev, *curr ;
   int i;

   if (p == NULL )
   {
      printf("Tidak ada simpul yang akan dihapus \n");
   }
   else
   {
      if ( simpul_no > panjang (p))
      {
            printf("Error\n");
      }
      else
      {
         prev = NULL;
         curr = p;
         i = 1 ;
         while ( i < simpul_no )
         {
            prev = curr;
            curr = curr-> link;
            i = i+1;
         }
         if ( prev == NULL )
         {
            p = curr -> link;
            free ( curr );
         }
         else
         {
            prev -> link = curr -> link ;
            free ( curr );
         }
      }
   }
   return(p);
}

/* fungsi untuk menghitung panjang senarai berantai */
int panjang ( struct simpul *p )
{
   int count = 0 ;
   while ( p != NULL )
   {
      count++;
      p = p->link;
   }
   return ( count ) ;
}


Masukkan jumlah simpul yang akan diciptakan
5
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
23
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
34
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
45
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
56
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
67
List sebelum penghapusan adalah
Nilai-nilai data di dalam list adalah
23      34      45      56      67
Masukkan nomor simpul
4
List setelah penghapusan adalah
Nilai-nilai data di dalam list adalah
23      34      45      67        




11.17 Program Menyisipkan Simpul Setelah Simpul Tertentu

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/* Program untuk menyisipkan simpul setelah simpul tertentu */
#include <stdio.h>
#include <stdlib.h>
int panjang ( struct simpul * );

struct simpul
{
   int data;
   struct simpul *link;
};

/* fungsi untuk menyambung simpul baru ke senarai yang sudan ada */
struct simpul *sisip(struct simpul *p, int n)
{
   struct simpul *temp;
   if(p==NULL)
   {
      p=(struct simpul *)malloc(sizeof(struct simpul));
      if(p==NULL)
      {
         printf("Error\n");
         exit(0);
      }
      p-> data = n;
      p-> link = NULL;
   }
   else
   {
      temp = p;
      while (temp-> link != NULL)
         temp = temp-> link;
      temp-> link = (struct simpul *)malloc(sizeof(struct simpul));
      if(temp -> link == NULL)
         {
        printf("Error\n");
        exit(0);
      }
      temp = temp-> link;
      temp-> data = n;
      temp-> link= NULL;
    }
    return (p);
 }

/* fungsi yang menyisipkan simpul yang baru diciptakan setelah simpul baru */
struct simpul * sisipBaru ( struct simpul *p, int simpul_no, int nilai )
{
   struct simpul *temp, * temp1;
   int i;
   if ( simpul_no <= 0 || simpul_no > panjang (p))
   {
      printf("Error! simpul yang dimaksud tidak ada\n");
      exit(0);
   }
   if ( simpul_no == 0)
   {
      temp = ( struct simpul * )malloc ( sizeof ( struct simpul ));
      if ( temp == NULL )
      {
         printf( "Tidak bisa dialokasi \n");
         exit (0);
      }
      temp -> data = nilai;
      temp -> link = p;
      p = temp ;
   }
   else
   {
      temp = p ;
      i = 1;
      while ( i < simpul_no )
      {
         i = i+1;
         temp = temp-> link ;
      }
      temp1 = ( struct simpul * )malloc ( sizeof(struct simpul));
      if ( temp == NULL )
      {
         printf ("Tidak bisa dialokasi \n");
         exit(0);
      }
      temp1 -> data = nilai ;
      temp1 -> link = temp -> link;
      temp -> link = temp1;
   }
   return (p);
}

void tampilList ( struct simpul *p )
{
   printf("Nilai-nilai data di dalam list adalah\n");
   while (p!= NULL)
   {
      printf("%d\t",p-> data);
      p = p-> link;
   }
}

/* fungsi untuk menghitung panjang senarai berantai */
int panjang ( struct simpul *p )
{
   int hitung = 0 ;
   while ( p != NULL )
   {
      hitung++;
      p = p->link;
   }
   return ( hitung ) ;
}

void main ()
{
   int n;
   int x;
   struct simpul *awal = NULL;
   printf("Masukkan jumlah simpul yang akan diciptakan \n");
   scanf("%d",&n);
   while ( n-- > 0 )
   {
      printf( "Masukkan nilai-nilai data yang akan ditempatkan pada simpul\n");
      scanf("%d",&x);
      awal = sisip ( awal, x );
   }
   printf("List sebelum penghapusan adalah\n");
   tampilList ( awal );
   printf(" \n Masukkan nomor simpul untuk disisipkan\n");
   scanf ( " %d",&n);
   printf("Masukkan nilai simpul\n");
   scanf("%d",&x);
   awal = sisipBaru(awal,n,x);
   printf("Simpul setelah penyisipan adalah \n");
   tampilList(awal);
}


Masukkan jumlah simpul yang akan diciptakan
5
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
12
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
32
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
34
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
45
Masukkan nilai-nilai data yang akan ditempatkan pada simpul
56
List sebelum penghapusan adalah
Nilai-nilai data di dalam list adalah
12      32      34      45      56
Masukkan nomor simpul untuk disisipkan
4
Masukkan nilai simpul
50000
Simpul setelah penyisipan adalah
Nilai-nilai data di dalam list adalah
12      32      34      45      50000   56     


11.18 Program untuk Pohon Pencarian Biner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/* Pohon pencarian biner */
#include <stdio.h>
#include <stdlib.h>

struct tsimpul
{
   int data;
   struct tsimpul *L_anak, *R_anak;
};

struct tsimpul *sisip(struct tsimpul *p,int nilai)
{
   struct tsimpul *temp1,*temp2;
   if(p == NULL)
   {
      /* sisip simpul baru sebagai akar */     
      p = (struct tsimpul *) malloc(sizeof(struct tsimpul));
      if(p == NULL)
      {
         printf("Tidak bisa dialokasi\n");
         exit(0);
      }
      p->data = nilai;
      p->L_anak=p->R_anak=NULL;
   }
   else
   {
      temp1 = p;
      /* menjelajah pohon untuk mendapatkan pointer ke simpul
         yang memiliki anak yang simpulnya baru dibuat*/
      while(temp1 != NULL)
         {
            temp2 = temp1;
            if( temp1 ->data > nilai)
                temp1 = temp1->L_anak;
            else
                temp1 = temp1->R_anak;
         }
      if( temp2->data > nilai)
         {
          /*sisip simpul yang baru dibuat menjadi anak kiri*/
          temp2->L_anak = (struct tsimpul*)malloc(sizeof(struct tsimpul));
          temp2 = temp2->L_anak;
          if(temp2 == NULL)
          {
             printf("Tidak dapat dialokasi\n");
             exit(0);
          }
          temp2->data = nilai;
          temp2->L_anak=temp2->R_anak = NULL;
      }
      else
         {
            /*sisip simpul yang baru dibuat menjadi anak kiri*/   
         temp2->R_anak = (struct tsimpul*)malloc(sizeof(struct tsimpul));
         temp2 = temp2->R_anak;
         if(temp2 == NULL)
         {
            printf("Tidak dapat dialokasi\n");
            exit(0);
          }
          temp2->data = nilai;
          temp2->L_anak=temp2->R_anak = NULL;
         }
   }
   return(p);
}

/* fungsi yang menciptakan pohon biner */
void inorder(struct tsimpul *p)
{
   if(p != NULL)
   {
      inorder(p->L_anak);
      printf("%d\t",p->data);
      inorder(p->R_anak);
    }
}

void main()
{
   struct tsimpul *akar = NULL;
   int n,x;
   printf("Masukkan jumlah simpul\n");
   scanf("%d",&n);
   while( n-- > 0)
     {
         printf("Masukkan nilai data\n");
         scanf("%d",&x);
         akar = sisip(akar,x);
    }
     inorder(akar);
 }


Masukkan jumlah simpul
6
Masukkan nilai data
23
Masukkan nilai data
32
Masukkan nilai data
33
Masukkan nilai data
34
Masukkan nilai data
54
Masukkan nilai data
45
23      32      33      34      45      54     


11.19 Program untuk Mencari Kunci Di Pohon Pencarian Biner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
/* Program untuk mencari kunci pada pohon pencarian biner */
#include <stdio.h>
#include <stdlib.h>
struct tsimpul
{
  int data;
  struct tsimpul *L_anak, *R_anak;
};

/* Fungsi untuk mencari kunci di dalam pohon biner */
struct tsimpul *cari( struct tsimpul *p,int kunci)
{
   struct tsimpul *temp;
   temp = p;
   while( temp != NULL)
   {
      if(temp->data == kunci)
         return(temp);
      else
      if(temp->data > kunci)
         temp = temp->L_anak;
      else
         temp = temp->R_anak;
   }

   return(NULL);
}

/*fungsi iteratif untuk menata pohon biner*/
void inorder1(struct tsimpul *p)
{
   struct tsimpul *tumpukan[100];
   int atas;
   atas = -1;
   if(p != NULL)
   {
      atas++;
      tumpukan[atas] = p;
      p = p->L_anak;
      while(atas >= 0)
      {
         while ( p!= NULL)/* menempatkann anak kiri pada tumpukan */
         {
            atas++;
            tumpukan[atas] =p;
            p = p->L_anak;
         }
         p = tumpukan[atas];
         atas--;
         printf("%d\t",p->data);
         p = p->R_anak;

         if ( p != NULL) /* menempatkan anak kanan pada tumpukan */
         {
            atas++;
            tumpukan[atas] = p;
            p = p->L_anak;
         }
      }
   }
}

/* Fungsi untuk menyisipkan simpul baru di dalam pohon biner
   untuk menghasilkan pohon biner */
struct tsimpul *sisip(struct tsimpul *p,int nilai)
{
   struct tsimpul *temp1,*temp2;
   if(p == NULL)
   {
      /* menyisipkan simpul baru sebagai simpul akar */
      p = (struct tsimpul *) malloc(sizeof(struct tsimpul));
      if(p == NULL)
      {
         printf("Tidak bisa dialokasikan\n");
         exit(0);
      }
      p->data = nilai;
      p->L_anak=p->R_anak=NULL;
   }
   else
   {
      temp1 = p;
      /* menjelajah pohon untuk menghasilkan pointer ke simpul
         dengan anak yang baru diciptakan */
      while(temp1 != NULL)
      {
         temp2 = temp1;
         if( temp1 ->data > nilai)
            temp1 = temp1->L_anak;
         else
            temp1 = temp1->R_anak;
         }
      if( temp2->data > nilai)
      {
         /*menyisipkan simpul yang baru tercipta sebagai anak kiri */
         temp2->L_anak = (struct tsimpul*)malloc(sizeof(struct tsimpul));
         temp2 = temp2->L_anak;
         if(temp2 == NULL)
         {
            printf("Tidak bisa dialokasikan\n");
            exit(0);
         }
         temp2->data = nilai;
         temp2->L_anak=temp2->R_anak = NULL;
         }
      else
         {
         /*menyisipkan simpul yang baru tercipta sebagai anak kiri*/
         temp2->R_anak = (struct tsimpul*)malloc(sizeof(struct tsimpul));
         temp2 = temp2->R_anak;
         if(temp2 == NULL)
         {
            printf("Tidak bisa dialokasikan\n");
            exit(0);
         }
         temp2->data = nilai;
         temp2->L_anak=temp2->R_anak = NULL;
         }
   }
   return(p);
}

void main()
{
   struct tsimpul *akar = NULL, *temp = NULL;
   int n,x;
   printf("Jumlah simpul di dalam pohon\n");
   scanf("%d",&n);
   while( n-- > 0)
   {
      printf("Masukkan nilai data\n");
      scanf("%d",&x);
      akar = sisip(akar,x);
   }
   printf("Pohon yang tercipta adalah :\n");
   inorder1(akar);
   printf("\n Masukkan kunci simpul yang dicari\n");
   scanf("%d",&n);
   temp=cari(akar,n);
   if(temp != NULL)
      printf("Nilai data ada di dalam pohon \n");
   else
      printf("Nilai data tidak ada di dalam pohon \n");
}


Jumlah simpul di dalam pohon
7
Masukkan nilai data
34
Masukkan nilai data
43
Masukkan nilai data
45
Masukkan nilai data
56
Masukkan nilai data
54
Masukkan nilai data
65
Masukkan nilai data
66
Pohon yang tercipta adalah :
34      43      45      54      56      65      66
Masukkan kunci simpul yang dicari
65
Nilai data ada di dalam pohon     















Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)