program mengurutkan bilangan bahasa c

#include <stdlib.h>
#include <stdio.h>
#include "list.h"

/* Prototype */
/* =========== Test List Kosong ================ */

boolean ListEmpty(List L)
/* mengirim true jika list kosong */
{
    return ((First(L)) == Nil);
}

/* =========== Pembuatan List Kosong =========== */
void CreateList(List *L)
/* I.S. : sembarang */
/* F.S. : terbentuk list kosong */
{ First(*L) = Nil; }

/* =========== Manajemen Memori ================= */
Address Alokasi(InfoType X)
/* mengirimkan address hasil alokasi sebuah elemen */
/* jika alokasi berhasil, maka address tidak nil, dan misalnya
*/
/* menghasilkan P, maka Info(P)=X, Next(P)=Nil */
/* jika alokasi gagal, mengirimkan Nil */
{
 Address P;
 P = (Address) malloc(sizeof(ElmtList));
 if (P == Nil) {
  return Nil;
 } else {  /* P!=Nil*/
  Info(P) = X;
  Next(P) = Nil;
  return P;  }
}

void DeAlokasi(Address P)
/* I.S. : P terdefinisi */
/* F.S. : P dikembalikan ke sistem */
/* melakukan dealokasi / pengembalian Address P */
{ free(P); }

/* ====== Penambahan Elemen ================== */

void InsVFirst(List *L, InfoType X)
/* I.S. : L mungkin kosong */
/* F.S. : melakukan alokasi sebuah elemen dan menambahkan elemen
pertama */
/*        dengan nilai X jika alokasi berhasil */
{
 Address P;

 P = Alokasi(X);

 if (P != Nil) {
  Next(P) = First(*L);
  First(*L) = P;
 }
}

void InsVLast(List *L, InfoType X)
/* I.S. : mungkin kosong */
/* F.S. : melakukan alokasi sebuah elemen dan menambahkan elemen
list di akhir : */
/*        elemen terakhir yang baru bernilai X jika alokasi
berhasil. */
/*        jika alokasi gagal : I.S. = F.S. */
{
 Address P;
 Address Last;

 P = Alokasi(X);
 
 if (P != Nil) {
  if(ListEmpty(*L)){
   First(*L)=P;
  } else { /* P==Nil */
     Last = First(*L);
  
   while ((Next(Last)) != Nil) {
    Last = Next(Last);
   } /* Next(Last)==Nil, last adalah elemen terakhir
list */
   Next(Last) = P;
 }
 Next(P) = Nil;
 }
}


/* ==================== Penghapusan Elemen ================== */
void DelVFirst(List *L, InfoType *X)
/* I.S. : list tidak kosong */
/* F.S. : elemen pertama list dihapus : nilai Info disimpan pada
X */
/*        dan alamat elemen pertama di-dealokasi */
{
 Address P;
 P = First(*L);

 (*X) = Info(P);
 First(*L)= Next(First(*L));
 Next(P) = Nil;
 DeAlokasi(P);
}

/* ============= Penambahan Elemen Berdasarkan Alamat =========
*/

void InsertFirst(List *L, Address P)
/* I.S. : sembarang, P sudah dialokasi */
/* F.S. : menambahkan elemen ber-address P sebagai elemen
pertama */
{
 Next(P) = First(*L);
 First(*L) = P;
}
 


void DelFirst(List * L, Address * P)
/* I.S. : List tidak kosong */
/* F.S. : P adalah alamat elemen pertama list sebelum
penghapusan */ /*        Elemen list berkurang satu (mungkin menjadi kosong) */
/*    First elemen yang baru adalah suksesor elemen pertama
yang lama */
{
 (*P) = First(*L);
 First(*L) = Next(First(*L));
}

boolean CekElmntMembesar (List L)
{
    Address P;
    boolean membesar;
   
    P = First (L);
    membesar = true;
    while (membesar == true && Next (P) != Nil)
    {
        if (Info (P) > Info (Next(P)))
        {
            membesar = false;
        }
        else
        {
            P = Next (P);
        }
    }
    return membesar;
}

/* ========= Proses Semua Elemen List ================= */
void PrintInfo(List L)

/* I.S : List mungkin kosong */
/* F.S : jika list tidak kosong, semua info yang disimpan pada
elemen list */
/*   diprint, jika list kosong, hanya menuliskan "list
kosong"*/
{
 Address P;
 P = First(L);
 if (P == Nil) {
  printf("List kosong \n");
 } else { /* P!=Nil */
  while (P != Nil) {
   printf("%d ", Info(P));
   P = Next(P);
  } /* P==Nil */
 }
 printf("\n");
}

int main()
{
    List L;
   
    int A,i,J;
   
    boolean X;
  
        
    printf("Masukan banyak data = "); scanf("%d",&A);
    CreateList(&L);
    for(i=1;i<=A;i++)
    {
      printf("data ke-%d = ",i); scanf("%d",&J);
      if(ListEmpty(L)){ InsVFirst(&L,J); } 
      else{ InsVLast(&L,J); }
    }
   
    printf("\n");
   
    X = CekElmntMembesar (L);
   
    if (X == true)
    {
        printf("Terurut Membesar");
    }
    else
    {
        printf("Tidak Terurut Membesar");
    }
}

Tweet