Contoh Program Pohon

 Silahkan dicoba

#include <iostream>
#include <deque>
#include <climits>
using namespace std;

struct Tree
{
 char data;
 Tree *left;
 Tree *right;  
 Tree *parent;  
};

Tree* lookUp(struct Tree *node, char key)
{
 if(node == NULL) return node;

 if(node->data == key) return node;
 else {
  if(node->data < key)
   return lookUp(node->right, key) ;
  else
   return lookUp(node->left, key);
 }
}

Tree* leftMost(struct Tree *node)
{
 if(node == NULL) return NULL;
 while(node->left != NULL)
  node = node->left;
 return node;
}

struct Tree *newTreeNode(int data) 
{
 Tree *node = new Tree;
 node->data = data;
 node->left = NULL;
 node->right = NULL;
 node->parent = NULL;

 return node;
}

struct Tree* insertTreeNode(struct Tree *node, int data)
{
 static Tree *p;
 Tree *retNode;

 if(node != NULL) p = node;

 if(node == NULL)  {
  retNode = newTreeNode(data);
      retNode->parent = p;
  return retNode;
 }
 if(data <= node->data ) { 
  p = node;
  node->left = insertTreeNode(node->left,data);
 } 
 else {
  p = node;
  node->right = insertTreeNode(node->right,data);
 } 
 return node;
}

void isBST(struct Tree *node)
{
 static int lastData = INT_MIN;
 if(node == NULL) return;

 isBST(node->left);

 /* check if the given tree is BST */
 if(lastData < node->data) 
  lastData = node->data;
 else {
  cout << "Not a BST" << endl;
  return;
 }

 isBST(node->right);
 return;
}

int treeSize(struct Tree *node)
{
 if(node == NULL) return 0;
 else
  return treeSize(node->left) + 1 + treeSize(node->right);
}

int maxDepth(struct Tree *node)
{
 if(node == NULL) return 0;

 int leftDepth = maxDepth(node->left);
 int rightDepth = maxDepth(node->right);

 return leftDepth > rightDepth ? 
    leftDepth + 1 : rightDepth + 1;
}

int minDepth(struct Tree *node)
{
 if(node == NULL) return 0;

 int leftDepth = minDepth(node->left);
 int rightDepth = minDepth(node->right);

 return leftDepth < rightDepth ? 
    leftDepth + 1 : rightDepth + 1;
}

bool isBalanced(struct Tree *node)
{
 if(maxDepth(node)-minDepth(node) <= 1) 
  return true;
 else
  return false;
}

/* Tree Minimum */
Tree* minTree(struct Tree *node)
{
 if(node == NULL) return NULL;
 while(node->left) 
  node = node -> left;
 return node;
}

/* Tree Maximum */
Tree* maxTree(struct Tree *node)
{
 while(node->right) 
  node = node -> right;
 return node;
}

/* In Order Successor - a node which has the next higher key */ 
Tree *succesorInOrder(struct Tree *node)
{
 /* if the node has right child, seccessor is Tree-Minimum */
 if(node->right != NULL) return minTree(node->right);

 Tree *y = node->parent;
 while(y != NULL && node == y->right) {
  node = y;
  y = y->parent;
 }
 return y;
}

/* In Order Predecessor - a node which has the next lower key */
Tree *predecessorInOrder(struct Tree *node)
{
 /* if the node has left child, predecessor is Tree-Maximum */
 if(node->left != NULL) return maxTree(node->left);

 Tree *y = node->parent;
 /* if it does not have a left child, 
 predecessor is its first left ancestor */
 while(y != NULL && node == y->left) {
  node = y;
  y = y->parent;
 }
 return y;
}
 
Tree *lowestCommonAncestor(Tree *root, Tree *p, Tree *q) 
{
 Tree *left, *right;
 if(root == NULL) return NULL;
 if(root->left == p || root->left == q
  || root->right == p || root->right == q) return root;
 else {
  left = lowestCommonAncestor(root->left,p,q);
  right = lowestCommonAncestor(root->right, p,q);
  if(left && right) 
   return root;
  else 
   return (left) ? left : right;
 } 
}

void clear(struct Tree *node)
{
 if(node != NULL) {
  clear(node->left);
  clear(node->right);
  delete node;
 }
}
/* print tree in order */
/* 1. Traverse the left subtree. 
   2. Visit the root. 
   3. Traverse the right subtree. 
*/

void printTreeInOrder(struct Tree *node)
{
 static int lastData = INT_MIN;
 if(node == NULL) return;

 printTreeInOrder(node->left);
 cout << node->data << " ";
 printTreeInOrder(node->right);
}

/* print tree in postorder*/
/* 1. Traverse the left subtree. 
   2. Traverse the right subtree. 
   3. Visit the root. 
*/
void printTreePostOrder(struct Tree *node)
{
 if(node == NULL) return;

 printTreePostOrder(node->left);
 printTreePostOrder(node->right);
 cout << node->data << " ";
}

/* print in preorder */
/* 1. Visit the root. 
   2. Traverse the left subtree. 
   3. Traverse the right subtree. 
*/
void printTreePreOrder(struct Tree *node)
{
 if(node == NULL) return;

 cout << node->data << " ";
 printTreePreOrder(node->left);
 printTreePreOrder(node->right);
}

/* printing array */
void printThisPath(int path[], int n)
{
 for(int i = 0; i < n; i++)
  cout << (char)path[i] << " ";
 cout << endl;
}

/* recursion routine to find path */
void pathFinder(struct Tree *node, int path[], int pathLength)
{
 if(node == NULL) return;
 path[pathLength++] = node->data;

 /* Leaf node is the end of a path. 
    So, let's print the path */
 if(node->left == NULL && node->right == NULL)
  printThisPath(path, pathLength);
 else {
  pathFinder(node->left, path, pathLength);
  pathFinder(node->right, path, pathLength);
 }
}

/*printing all paths :
Given a binary tree, print out all of its root-to-leaf 
paths, one per line. Uses a recursive helper to do the work. */

void printAllPaths(struct Tree *root)
{
 int path[100];
 pathFinder(root,path,0);
}

bool matchTree(Tree *r1, Tree *r2)
{
 /* Nothing left in the subtree */
 if(r1 == NULL && r2 == NULL)
  return true;
 /* Big tree empty and subtree not found */
 if(r1 == NULL || r2 == NULL)
  return false;
 /* Not matching */
 if(r1->data != r2->data)
  return false;
 return (matchTree(r1->left, r2->left) && 
   matchTree(r1->right, r2->right));
}

bool subTree(Tree *r1, Tree *r2)
{
 /*Big tree empty and subtree not found */
 if(r1 == NULL)
  return false;
 if(r1->data == r2->data)
  if(matchTree(r1, r2)) return true;
 return (subTree(r1->left, r2) || subTree(r1->right, r2));
}

bool isSubTree(Tree *r1, Tree *r2)
{
 /* Empty tree is subtree */
 if(r2 == NULL) 
  return true;
 else
  return subTree(r1, r2);
}

/* change a tree so that the roles of the left 
and right hand pointers are swapped at every node */
void mirror(Tree *r)
{
 if(r == NULL) return;
 
 Tree *tmp;
 mirror(r->left);
 mirror(r->right);

 /* swap pointers */
 tmp = r->right;
 r->right = r->left;
 r->left = tmp;
}

/* create a new tree from a sorted array */
Tree *addToBST(char arr[], int start, int end)
{
 if(end < start) return NULL;
 int mid = (start + end)/2;

 Tree *r = new Tree;
 r->data = arr[mid];
 r->left = addToBST(arr, start, mid-1);
 r->right = addToBST(arr, mid+1, end);
 return r;
}

Tree *createMinimalBST(char arr[], int size)
{
 return addToBST(arr,0,size-1);
}

/* Breadth first traversal using queue */
void BreadthFirstTraversal(Tree *root)
{
 if (root == NULL) return;
 deque <Tree *> queue;
 queue.push_back(root);

 while (!queue.empty()) {
  Tree *p = queue.front();
  cout << p->data << " ";
  queue.pop_front();

  if (p->left != NULL)
   queue.push_back(p->left);
  if (p->right != NULL)
   queue.push_back(p->right);
 }
 cout << endl;
} 

/* find n-th max node from a tree */
void NthMax(struct Tree* t)
{        
 static int n_th_max = 5;
 static int num = 0;
 if(t == NULL) return;        
 NthMax(t->right);        
 num++;        
 if(num == n_th_max)                
  cout << n_th_max << "-th maximum data is " << t->data << endl;        
 NthMax(t->left);
}

/* Converting a BST into an Array */ 
void TreeToArray(struct Tree *node, int a[]){ 
 static int pos = 0; 
  
 if(node){ 
  TreeToArray(node->left,a); 
  a[pos++] = node->data; 
  TreeToArray(node->right,a); 
      } 
} 

int main(int argc, char **argv)
{
 char ch, ch1, ch2;
 Tree *found;
 Tree *succ;
 Tree *pred;
 Tree *ancestor;
 char charArr[9] 
  = {'A','B','C','D','E','F','G','H','I'};

 Tree *root = newTreeNode('F');
 insertTreeNode(root,'B');
 insertTreeNode(root,'A');
 insertTreeNode(root,'D');
 insertTreeNode(root,'C');  
 insertTreeNode(root,'E');
 insertTreeNode(root,'G');
 insertTreeNode(root,'I');
 insertTreeNode(root,'H');

 /* is the tree BST? */
 isBST(root);

 /* size of tree */
 cout << "size = " << treeSize(root) << endl;

 /* max depth */
 cout << "max depth = " << maxDepth(root) << endl;

 /* min depth */
 cout << "min depth = " << minDepth(root) << endl;

 /* balanced tree? */
 if(isBalanced(root))
  cout << "This tree is balanced!\n";
 else
  cout << "This tree is not balanced!\n";

 /* min value of the tree*/
 if(root) 
  cout << "Min value = " << minTree(root)->data << endl;

 /* max value of the tree*/
 if(root) 
  cout << "Max value = " << maxTree(root)->data << endl;

 ch = 'B';
 found = lookUp(root,ch);
 if(found) {
  cout << "Min value of subtree " << ch << " as a root is "
    << minTree(found)->data << endl;
  cout << "Max value of subtree " << ch << " as a root is "
    << maxTree(found)->data << endl;
 }

 ch = 'B';
 found = lookUp(root,ch);
 if(found) {
  succ = succesorInOrder(found);
  if(succ)
   cout << "In Order Successor of " << ch << " is "
    << succesorInOrder(found)->data << endl;
  else 
   cout << "In Order Successor of " << ch << " is None\n";
 }

 ch = 'E';
 found = lookUp(root,ch);
 if(found) {
  succ = succesorInOrder(found);
  if(succ)
   cout << "In Order Successor of " << ch << " is "
    << succesorInOrder(found)->data << endl;
  else 
   cout << "In Order Successor of " << ch << " is None\n";
 }

 ch = 'I';
 found = lookUp(root,ch);
 if(found) {
  succ = succesorInOrder(found);
  if(succ)
   cout << "In Order Successor of " << ch << " is "
    << succesorInOrder(found)->data << endl;
  else 
   cout << "In Order Successor of " << ch << " is None\n";
 }

 ch = 'B';
 found = lookUp(root,ch);
 if(found) {
  pred = predecessorInOrder(found);
  if(pred)
   cout << "In Order Predecessor of " << ch << " is "
    << predecessorInOrder(found)->data << endl;
  else 
   cout << "In Order Predecessor of " << ch << " is None\n";
 }

 ch = 'E';
 found = lookUp(root,ch);
 if(found) {
  pred = predecessorInOrder(found);
  if(pred)
   cout << "In Order Predecessor of " << ch << " is "
    << predecessorInOrder(found)->data << endl;
  else 
   cout << "In Order Predecessor of " << ch << " is None\n";
 }

 ch = 'I';
 found = lookUp(root,ch);
 if(found) {
  pred = predecessorInOrder(found);
  if(pred)
   cout << "In Order Predecessor of " << ch << " is "
    << predecessorInOrder(found)->data << endl;
  else 
   cout << "In Order Predecessor of " << ch << " is None\n";
 }

 /* Lowest Common Ancestor */
 ch1 = 'A';
 ch2 = 'C';
 ancestor = 
  lowestCommonAncestor(root, 
   lookUp(root,ch1), lookUp(root,ch2));
 if(ancestor) 
  cout << "The lowest common ancestor of " << ch1 << " and "
  << ch2 << " is " << ancestor->data << endl;

 ch1 = 'E';
 ch2 = 'H';
 ancestor = 
  lowestCommonAncestor(root, 
   lookUp(root,ch1), lookUp(root,ch2));
 if(ancestor) 
  cout << "The lowest common ancestor of " << ch1 << " and "
  << ch2 << " is " << ancestor->data << endl;

 /* print tree in order */
 cout << "increasing sort order\n";
 printTreeInOrder(root);
 cout << endl;

 /* print tree in postorder*/
 cout << "post order \n";
 printTreePostOrder(root);
 cout << endl;

 /* print tree in preorder*/
 cout << "pre order \n";
 printTreePreOrder(root);
 cout << endl;

 /* lookUp */
 ch = 'D';
 found = lookUp(root,ch);
 if(found) 
  cout << found->data << " is in the tree\n";
 else
  cout << ch << " is not in the tree\n";

 /* lookUp */
 ch = 'M';
 found = lookUp(root,ch);
 if(found) 
  cout << found->data << " is in the tree\n";
 else
  cout << ch << " is not in the tree\n";

 /* printing all paths :
 Given a binary tree, print out all of its root-to-leaf 
 paths, one per line. Uses a recursive helper to do the work. */
 cout << "printing paths ..." << endl;
 printAllPaths(root); 

 /* find n-th maximum node */
 NthMax(root);


 /* convert the tree into an array */
 int treeSz = treeSize(root);
 int *array = new int[treeSz];
 TreeToArray(root,array);
 cout << "New array: ";
 for (int i = 0; i < treeSz; i++)
  cout << (char)array[i] << ' ';
 cout << endl;
 delete [] array;

 /* subtree */
 Tree *root2 = newTreeNode('D');
 insertTreeNode(root2,'C');  
 insertTreeNode(root2,'E');
 cout << "1-2 subtree: " << isSubTree(root, root2) << endl;

 Tree *root3 = newTreeNode('B');
 insertTreeNode(root3,'A');  
 insertTreeNode(root3,'D');
 insertTreeNode(root3,'C');  
 insertTreeNode(root3,'E');
 cout << "1-3 subtree: " << isSubTree(root, root3) << endl;

 Tree *root4 = newTreeNode('B'); 
 insertTreeNode(root4,'D');
 insertTreeNode(root4,'C');  
 insertTreeNode(root4,'E');
 cout << "1-4 subtree: " << isSubTree(root, root4) << endl;

 cout << "2-3 subtree: " << isSubTree(root2, root3) << endl;
 cout << "3-2 subtree: " << isSubTree(root3, root2) << endl;

 /* swap left and right */
 mirror(root);

 /* deleting a tree */
 clear(root);

 /* make a new tree with minimal depth */
 Tree *newRoot = createMinimalBST(charArr,9);

 /* Traversing level-order. 
 We visit every node on a level before going to a lower level. 
 This is also called Breadth-first traversal.*/
 cout << "printing with Breadth-first traversal" << endl;
 BreadthFirstTraversal(newRoot);

 return 0;
}

Antrian dengan linklist

Contoh antrian dengan linklist

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

struct node
{
 int data;
 node *next;
};
typedef struct node node_t;

node_t *head = NULL;

void push(int n)
{
 node_t *newNode = (node_t *)malloc(sizeof(node_t));
 newNode->data = n;
 newNode->next = NULL;

 if(head == NULL) {
  head = newNode;
  return;
 }

 node_t *cur = head;
 while(cur) {
  if(cur->next==NULL) {
   cur->next = newNode;
   return;
  }
  cur = cur->next;
 }
}

void pop()
{
 if(head==NULL) return;
 node_t *tmp = head;
 head = head->next;
 free(tmp);
}

void display()
{
 node_t *cur = head;
 while(cur) {
  printf("%3d",cur->data);
  cur = cur->next;
 }
 printf("\n");
}

int main()
{
 push(1);push(2);push(3);push(4);push(5);display();
 pop();display();
 pop();display();
 pop();display();
 pop();display();
 pop();display();
 return 0;
}

Link list menggunakan class

#include <iostream>
#include <string>
using namespace std;

class list
{
public:
 struct node {
  int id;
  string name;
  struct node *next;
 } *head, *tail, *ptr; 

 list():head(NULL),tail(NULL){} // constructor 
 ~list();   // destructor

 struct list::node* searchName(struct list::node*, string); 
 struct list::node* searchId(struct list::node*, int);
 struct list::node* initNode(string, int);

 void reverse();
 void addNode( struct list::node*);
 void insertNode( struct list::node*);
 void deleteNode( struct list::node*);
 void deleteList( struct list::node*);
 void displayList( struct list::node*)const ;
  void displayNode( struct list::node*) const; 
};

list::~list() {
 node *current,*temp;
 current = head;
 temp = head;
 while(current != NULL) {
  current = current->next;
  delete temp;
  temp = current;
 }
}

struct list::node* list::initNode(string s, int i) {
 struct node *ptr = new node;
 
 // error? then just return
 if( ptr == NULL )                         
  return static_cast<struct node *>(NULL);  
 // assign it 
 // then return pointer to ne node
 else {  
  ptr->name = s ;  
  ptr->id = i;                        
  return ptr;                         
 }
}

// adding to the end of list  
void list::addNode( struct node *newNode )  {
 // if there is no node, put it to head
 if( head == NULL ) {
  head = newNode;  
  tail = newNode;
 }
   
 // link in the new_node to the tail of the list
 // then mark the next field as the end of the list
 // adjust tail to point to the last node

 tail->next = newNode;       
 newNode->next = NULL;       
 tail = newNode;               
}

void list::insertNode( struct node *newnode ) {
   struct node *temp, *prev;                

   if( head == NULL ) {                     // if an empty list,         
       head = newnode;                      // set 'head' to it         
       tail = newnode;
       head->next = NULL;                   // set end of list to NULL     
       return;                                             
   }

   temp = head;                             // start at beginning of list 
         // while currentname < newname 
   while( temp->name < newnode->name) {     // to be inserted then 
          temp = temp->next;                // goto the next node in list  
          if( temp == NULL )                // don't go past end of list    
              break;
   }        
         // set previous node before we insert  
         // first check to see if it's inserting         
   if( temp == head ) {           // before the first node 
      newnode->next = head;                 // link next field to original list    
      head = newnode;                       // head adjusted to new node          
   }
   else {        // it's not the first node
      prev = head;           // start of the list, 
      while( prev->next != temp ) { 
          prev = prev->next;          // will cycle to node before temp 
      }
      prev->next = newnode;                 // insert node between prev and next   
      newnode->next = temp;
      if( tail == prev )      // if the new node is inserted at the  
         tail = newnode;      // end of the list the adjust 'end'    
   }
}

struct list::node* list::searchName(struct node* ptr, string name) {
    while( name != ptr->name ) {    
       ptr = ptr->next;                          
       if( ptr == NULL )                          
          break;                                  
    }
    return ptr;  
}

struct list::node* list::searchId(struct node* ptr, int id) {
    while( id != ptr->id ) {    
       ptr = ptr->next;                          
       if( ptr == NULL )                          
          break;                                  
    }
    return ptr;  
}

void list::reverse() {
 // we need at least two nodes for the reverse to have any effect
 if(head == NULL || head->next == NULL) return;

 // Starting 2nd list as 'me' and 'head' is now 'me->next'
 // and 'head->next' is pointing to NULL
 // So, the 3rd list is now 'child' of 'me'
 node *parent = head;
 node *me = head->next;
 node *child = me->next;

 // convert head to tail
 head->next = NULL;

 // reverse pointer direction
 me->next = head;
 
 while(child != NULL){
  me->next = parent;
  parent = me;
  me = child;
  child = child->next;
 }
 // when me reached the tail
 // me becomes head
 head = me;
 // the head is now pointing to the 2nd last node
 head->next = parent;
}
 

void list::deleteNode( struct list::node *ptr )
{
  struct node *temp, *prev;
   temp = ptr;    // node to be deleted 
   prev = head;   // start of the list, will cycle to node before temp    

   if( temp == prev ) {                    // deleting first node?  
       head = head->next;                  // moves head to next node     
       if( tail == temp )                  // is it end, only one node?   
          tail = tail->next;               // adjust end as well          
       delete temp ;                       // free up space 
   }
   else {                                  // if not the first node, then 
       while( prev->next != temp ) {       // move prev to the node before
           prev = prev->next;              // the one to be deleted       
       }
       prev->next = temp->next;            // link previous node to next  
       if( tail == temp )                  // if this was the end node,   
           tail = prev;                    // then reset the end pointer  
      delete temp;                         // free up space
   }
}

void list::deleteList( struct node *ptr )
{
   struct node *temp;

   if( head == NULL ) return;    // don't try to delete an empty list      

   if( ptr == head ) {   // if we are deleting the entire list    
       head = NULL;   // then reset head and    
       tail = NULL;   // end to empty                                     
   }
   else {
       temp = head;   // if it's not the entire list, readjust end   
       while( temp->next != ptr )       // locate previous node to ptr   
           temp = temp->next;
       tail = temp;                     // set end to node before ptr   
   }

   while( ptr != NULL ) {  // whilst there are still nodes to delete      
      temp = ptr->next;   // record address of next node                 
      delete ptr;   // free this node                             
      ptr = temp;   // point to next node to be deleted           
   }
}

void list::displayNode( struct list::node *ptr ) const
{
 cout << ptr->id << ": " << ptr->name << endl;
}

void list::displayList( struct list::node *ptr ) const
{
 if(!ptr) cout << "Nothing to display" << endl;
 while(ptr) {
  displayNode(ptr);
  ptr = ptr->next;
 }
}

int main()
{
 int id;
 string name;
  list myList;
 list::node* ptr;

 // add
 ptr = myList.initNode( "s1", 1 );
 myList.addNode(ptr);
 ptr = myList.initNode( "s2", 2 );
 myList.addNode(ptr);
 ptr = myList.initNode( "s3", 3 );
 myList.addNode(ptr);
 ptr = myList.initNode( "s4", 4 );
 myList.addNode(ptr);
 ptr = myList.initNode( "s5", 5 );
 myList.addNode(ptr); 
 myList.displayList(myList.head);

 // delete
 name = "s2";
 ptr = myList.searchName( myList.head, name );
 if( ptr == NULL ) {
  cout << "\nName: " << name << " not found" << endl;
 }
 else {
  cout << "\nDeleting a node ...  ";
     myList.displayNode(ptr);
  myList.deleteNode( ptr );
 }
 myList.displayList(myList.head);

 // insert
 name = "s2";
 id = 2;
 ptr = myList.initNode( name, id );
 myList.insertNode( ptr );
 cout << "\nInserting a node ...  ";
 myList.displayNode(ptr);
 myList.displayList(myList.head);

 // reverse
 cout << "\nReversing the list ...  \n";
 myList.reverse();
 myList.displayList(myList.head);

 // delete
 cout << "\nIn the end, deleting the list ...  \n";
 myList.deleteList(myList.head);
 myList.displayList(myList.head);
 return 0;
}

Link list circular (loop)

Didalam kode ini berisi
 1. menambahkan node
 2. fungsi pengembalian pada list
 3. membuat list circular (loop)
 4. rekursif 

#include <iostream>
using namespace std;

struct Node
{
 int data;
 Node * next;
};

Node *root = 0;

void addNode(int n)
{
 if(root==0) {
  root = new Node;
  root->data = n;
  root->next = 0;
  return;
 }
 Node *cur = root;
 while(cur) {
  if(cur->next == 0) {
   Node *ptr = new Node;
   ptr -> data = n;
   ptr -> next = 0;
   cur -> next = ptr;
   return;
  }
  cur = cur->next;
 }
}

void makeCircular()
{
 if(!root || !root->next) return;
 Node *cur = root;
 while(cur) {
  if(cur->next == 0) {
   cur->next = root;
   return;
  }
  cur = cur->next;
 }
}

int sizeOfList()
{
 Node *cur = root;
 int size = 0;
 while(cur) {
  size++;
  if(cur->next == 0) {
   return size; 
  }
  cur = cur->next; 
 }
 return size;
}

bool detectCircular() 
{
 // Assuming the list may not be circular

 if(!root || !root->next) return false;
 Node *ptr1 = root;
 Node *ptr2 = root;

 while(ptr1 && ptr2) {
  ptr1 = ptr1->next;
  ptr2 = ptr2->next;
  if(ptr2) {
         ptr2 = ptr2->next;
         if(!ptr2) return false;
  }
  else {
   return false;
  }
  cout << ptr1->data << "," << ptr2->data << endl;
  if(ptr1==ptr2) {
   return true;
  }
 }
 return false;
}

void printRecursive(Node *ptr)
{
 if(!ptr) {
  cout << endl;
  return;
 }
 cout << ptr->data << " ";
 printRecursive(ptr->next);
}

int main(int argc, char **argv)
{
 addNode(10);addNode(20);addNode(30);addNode(40);addNode(50);
 addNode(60);addNode(70);addNode(80);addNode(90);addNode(100);
 
 printRecursive(root);

 cout << "size of list = " << sizeOfList() << endl;
  
 makeCircular();

 if(detectCircular()) cout <<"Circular\n";
 else cout << "Normal\n";
  
}

Output from the run:

10 20 30 40 50 60 70 80 90 100
size of list = 10
20,30
30,50
40,70
50,90
60,10
70,30
80,50
90,70
100,90
10,10
Circular

Example 5B - Detecting Circular (Loop) Linked List (Generic Class with Template)

#include <iostream>
#include <string>

using namespace std;

template <class T>
class LinkedList
{
private:
 struct node
 {
  T data;
  node * next;
 } *head;

public:
 LinkedList();
 ~LinkedList();
 void add(T d);
 void remove(T d);
 void clear();
 void makeCircular();
 bool isCircular();
 void display(const char* s);
};

template <class T>
LinkedList<T>::LinkedList()
{
 head = NULL;
} 

template <class T>
LinkedList<T>::~LinkedList()
{
 node *p, *q;
 p = head;
 if(p == NULL) return;
 while(p) {
  q = p->next;
  delete p;
  p = q;
 }
}

template <class T>
void LinkedList<T>::add(T d)
{ 
 node *p, *q;
 if(head == NULL) {
  head = new node;
  head->data = d;
  head->next = NULL;
  return;
 } 
 p = head;
 while(p->next != NULL) 
  p = p->next;
 q = new node;
 q->data = d;
 q->next = NULL;
 p->next = q; 
}

template <class T>
void LinkedList<T>::remove(T d)
{
 node *p, *q;
 if(head == NULL) return;
 p = head;
 while(p) {
  if(p->data == d) {
   q->next = p->next;
   delete p;
   return;
  }
  q = p;
  p = p->next;
 }
}

template <class T>
void LinkedList<T>::clear()
{
 node *p, *q;
 if(head == NULL) return;
 p = head;
 while(p) {
  q = p->next;
  delete p;
  if(q != head)  {
   head = NULL;
   return;
  }
  p = q;
 }
}

template <class T>
void LinkedList<T>::makeCircular()
{
 node *p;
 if(head == NULL || head->next == NULL) return;
 p = head;
 while(p) {
  if(p->next == NULL) {
   p->next = head;
   return;
  }
  p = p->next;
 }
}

template <class T>
bool LinkedList<T>::isCircular()
{
 node *p, *pp;
 if(head == NULL || head->next == NULL) return false;
 p = head;
 pp = head;
 while(pp) {
  p = p->next;
  if(pp->next == NULL) return false;
  pp = (pp->next)->next;
  if(p == pp) return true;
 }
 return false;
}

template <class T>
void LinkedList<T>::display(const char* s)
{
 node *p;
 if(head == NULL) return;
 p = head;
 while(p) {
  if(s == "string") 
   cout << p->data << endl;
  else
   cout << p->data << ' ';
  p = p->next;
  if(p != NULL) {
   if(p == head) return;
  }
 }
 if(s == "integer") cout << endl;
}
 
int main()
{
 LinkedList<string> sList;
 sList.add("Wolfgang Amadeus Mozart");
 sList.add("Franz Peter Schubert");
 sList.add("Pyotr Ilyich Tchaikovsky");
 sList.add("Clude-Achille Debussy");
 sList.add("Camille Saint-Saens");
 sList.display("string");
 sList.clear();

 LinkedList<int> iList;
 iList.add(40);
 iList.add(50);
 iList.add(60);
 iList.add(70);
 iList.add(80);
 iList.add(90);
 iList.add(100);
 iList.add(10);
 iList.add(20);
 iList.add(30);
 iList.display("integer");

 /* link last element to the first */
 iList.makeCircular();

 if(iList.isCircular()) cout <<"This is circular list\n";
 iList.display("integer");

 iList.clear();
 cout << "\ndisplay after clear()\n";
 iList.display("integer");

 return 0;
}

Stack menggunakan linklist

Contoh program stack ini menggunakan linklist dan data terstruktur

#include <iostream<

using namespace std;

typedef struct Element
{
 void *data;
 struct Element *next;
} Element;

bool push(Element **top, void *data)
{
 Element *elem = new Element;
 if(!elem) return false;

 elem->data = data;
 elem->next = *top;
 *top = elem;
 return true;
}

bool createStack(Element **top)
{
 *top = NULL;
 return true;
}

bool pop(Element **top, void **data )
{
 Element *elem;
 if( !(elem = *top) ) return false;

 *data = elem->data;
 *top = elem->next;
 delete elem;
 return true;
}

bool deleteStack(Element **top)
{
 Element *elem;
 while(*top) {
  elem = (*top)->next;
  delete *top;
  *top = elem;
 }
 return true;

}

void printStack(Element *top) 
{
 if(top==NULL) {
  cout << "Empty!" << endl;
 }
 Element *cur = top;
 while(cur) {
  cout << *(static_cast<int *>(cur->data)) << " ";
  cur = cur->next;
 }
 cout << endl << endl;
}

int main()
{
 Element *head;
 createStack(&head);
 int n1 = 10, n2 = 20, n3 = 30, n4 = 40, n5 = 50;
 push(&head, &n1);
 push(&head, &n2);
 push(&head, &n3);
 push(&head, &n4);
 push(&head, &n5);

 printStack(head);

 void * n;
 pop(&head, &n);
 cout << "popped " << *(static_cast<int*>(n)) << endl;
 pop(&head, &n);
 cout << "popped " << *(static_cast<int*>(n)) << endl;
 cout << endl;

 printStack(head);

 cout << "deleting stack..." << endl;
 deleteStack(&head);
 printStack(head);
}

Link list menggunakan template

ini contoh linklist circular menggunakan template

#include <iostream>
#include <string>

using namespace std;

template <class T>
class LinkedList
{
private:
 struct node
 {
  T data;
  node * next;
 } *head;

public:
 LinkedList();
 ~LinkedList();
 void add(T d);
 void remove(T d);
 void clear();
 void makeCircular();
 bool isCircular();
 void display(const char* s);
};

template <class T>
LinkedList<T>::LinkedList()
{
 head = NULL;
} 

template <class T>
LinkedList<T>::~LinkedList()
{
 node *p, *q;
 p = head;
 if(p == NULL) return;
 while(p) {
  q = p->next;
  delete p;
  p = q;
 }
}

template <class T>
void LinkedList<T>::add(T d)
{ 
 node *p, *q;
 if(head == NULL) {
  head = new node;
  head->data = d;
  head->next = NULL;
  return;
 } 
 p = head;
 while(p->next != NULL) 
  p = p->next;
 q = new node;
 q->data = d;
 q->next = NULL;
 p->next = q; 
}

template <class T>
void LinkedList<T>::remove(T d)
{
 node *p, *q;
 if(head == NULL) return;
 p = head;
 while(p) {
  if(p->data == d) {
   q->next = p->next;
   delete p;
   return;
  }
  q = p;
  p = p->next;
 }
}

template <class T>
void LinkedList<T>::clear()
{
 node *p, *q;
 if(head == NULL) return;
 p = head;
 while(p) {
  q = p->next;
  delete p;
  if(q != head)  {
   head = NULL;
   return;
  }
  p = q;
 }
}

template <class T>
void LinkedList<T>::makeCircular()
{
 node *p;
 if(head == NULL || head->next == NULL) return;
 p = head;
 while(p) {
  if(p->next == NULL) {
   p->next = head;
   return;
  }
  p = p->next;
 }
}

template <class T>
bool LinkedList<T>::isCircular()
{
 node *p, *pp;
 if(head == NULL || head->next == NULL) return false;
 p = head;
 pp = head;
 while(pp) {
  p = p->next;
  if(pp->next == NULL) return false;
  pp = (pp->next)->next;
  if(p == pp) return true;
 }
 return false;
}

template <class T>
void LinkedList<T>::display(const char* s)
{
 node *p;
 if(head == NULL) return;
 p = head;
 while(p) {
  if(s == "string") 
   cout << p->data << endl;
  else
   cout << p->data << ' ';
  p = p->next;
  if(p != NULL) {
   if(p == head) return;
  }
 }
 if(s == "integer") cout << endl;
}
 
int main()
{
 LinkedList<string> sList;
 sList.add("Wolfgang Amadeus Mozart");
 sList.add("Franz Peter Schubert");
 sList.add("Pyotr Ilyich Tchaikovsky");
 sList.add("Clude-Achille Debussy");
 sList.add("Camille Saint-Saens");
 sList.display("string");
 sList.clear();

 LinkedList<int> iList;
 iList.add(40);
 iList.add(50);
 iList.add(60);
 iList.add(70);
 iList.add(80);
 iList.add(90);
 iList.add(100);
 iList.add(10);
 iList.add(20);
 iList.add(30);
 iList.display("integer");

 /* link last element to the first */
 iList.makeCircular();

 if(iList.isCircular()) cout <<"This is circular list\n";
 iList.display("integer");

 iList.clear();
 cout << "\ndisplay after clear()\n";
 iList.display("integer");

 return 0;
}

Contoh Link list

Ini adalah contoh linklist

silahkan dicoba

#include <iostream>

using namespace std;

struct Node {
 int data;
 Node* next;
};

// only for the 1st Node
void initNode(struct Node *head,int n){
 head->data = n;
 head->next =NULL;
}

// apending
void addNode(struct Node *head, int n) {
 Node *newNode = new Node;
 newNode->data = n;
 newNode->next = NULL;

 Node *cur = head;
 while(cur) {
  if(cur->next == NULL) {
   cur->next = newNode;
   return;
  }
  cur = cur->next;
 }
}

void insertFront(struct Node **head, int n) {
 Node *newNode = new Node;
 newNode->data = n;
 newNode->next = *head;
 *head = newNode;
}

struct Node *searchNode(struct Node *head, int n) {
 Node *cur = head;
 while(cur) {
  if(cur->data == n) return cur;
  cur = cur->next;
 }
 cout << "No Node " << n << " in list.\n";
}

bool deleteNode(struct Node **head, Node *ptrDel) {
 Node *cur = *head;
 if(ptrDel == *head) {
  *head = cur->next;
  delete ptrDel;
  return true;
 }
 
 while(cur) {
  if(cur->next == ptrDel) {
   cur->next = ptrDel->next;
   delete ptrDel;
   return true;
  }
  cur = cur->next;
 }
 return false;
}

/* reverse the list */
struct Node* reverse(struct Node** List) 
{
 Node *parent = *List;
 Node *me = parent->next;
 Node *child = me->next;

 /* make parent as tail */
 parent->next = NULL;
 while(child) {
  me->next = parent;
  parent = me;
  me = child;
  child = child->next;
 }
 me->next = parent;
 *List = me;
 return *List;
}

/* Creating a copy of a linked list */
void copyLinkedList(struct Node *node, struct Node **pNew)
{
 if(node != NULL) {
  *pNew = new Node;
  (*pNew)->data = node->data;
  (*pNew)->next = NULL;
  copyLinkedList(node->next, &((*pNew)->next));
 }
}

/* Compare two linked list */
/* return value: same(1), different(0) */
int compareLinkedList(struct Node *node1, struct Node *node2)
{
 static int flag;

 /* both lists are NULL */
 if(node1 == NULL && node2 == NULL) {
  flag = 1;
 }
 else {
  if(node1 == NULL || node2 == NULL) 
   flag = 0;
  else if(node1->data != node2->data) 
   flag = 0;
  else
   compareLinkedList(node1->next, node2->next);
 }

 return flag;
}

void deleteLinkedList(struct Node **node)
{
 struct Node *tmpNode;
 while(*node) {
  tmpNode = *node;
  *node = tmpNode->next;
  delete tmpNode;
 }
}

void display(struct Node *head) {
 Node *list = head;
 while(list) {
  cout << list->data << " ";
  list = list->next;
 }
 cout << endl;
 cout << endl;
}

int main() 
{
 struct Node *newHead;
 struct Node *head = new Node;
 
 initNode(head,10);
 display(head);

 addNode(head,20);
 display(head);

 addNode(head,30);
 display(head);

 addNode(head,35);
 display(head);

 addNode(head,40);
 display(head);

 insertFront(&head,5);
 display(head);

 int numDel = 5;
 Node *ptrDelete = searchNode(head,numDel);
 if(deleteNode(&head,ptrDelete)) 
  cout << "Node "<< numDel << " deleted!\n";
 display(head);

 cout << "The list is reversed\n";
 reverse(&head);
 display(head);

 cout << "The list is copied\n";
 copyLinkedList(head,&newHead);
 display(newHead);

 cout << "Comparing the two lists...\n";
 cout << "Are the two lists same?\n";
 if(compareLinkedList(head,newHead)) 
  cout << "Yes, they are same!\n";
 else
  cout << "No, they are different!\n";
 cout << endl;

 numDel = 35;
 ptrDelete = searchNode(newHead,numDel);
 if(deleteNode(&newHead,ptrDelete)) {
  cout << "Node "<< numDel << " deleted!\n";
  cout << "The new list after the delete is\n";
  display(newHead);
 }
 cout << "Comparing the two lists again...\n";
 cout << "Are the two lists same?\n";
 if(compareLinkedList(head,newHead)) 
  cout << "Yes, they are same!\n";
 else
  cout << "No, they are different!\n";
    
 cout << endl;
 cout << "Deleting the copied list\n";
 deleteLinkedList(&newHead);
 display(newHead);
 return 0;
}

Program Pointer

Contoh program pointer

#include <iostream>  
using namespace std;  

enum Type  {  
   INT,  
   FLOAT,  
   STRING,  
 };  

void Display(void *pVoid, Type eType)  {    
   switch (eType)  {  
 case INT:  
   cout << *(int*)pVoid << endl;  
  break;  
 case FLOAT:  
  cout << *(float*)pVoid << endl;  
  break;  
 case STRING:  
  cout << (char*)pVoid << endl;  
  break;  
   }  
}    

int main()  
{  
   int a = 10;  
   float b = 987.654;  
   char *c = 
 "Art is a lie that makes us realize the truth.";  
   Display(&a, INT);  
   Display(&b, FLOAT);  
   Display(c, STRING);  
   return 0;  
} 

Source code program C menghitung nilai kombinasi Dan Permutasi

Source code program C menghitung nilai kombinasi

Berikut ini merupakan source code bahasa C untuk membuat program penghitung nilai dari kombinasi bilangan

# include <stdio.h>
long int faktorial (unsigned int n)
{
if(n==1||n==0)
return 1;
else
return n*faktorial (n-1);
}
int main()
{
int a,b;
long int hasil;
printf("\t Menghitung Rumus Kombinasi\n\n");
printf("Masukkan nilai a = ");

scanf("%d",&a);
printf("Masukkan nilai b = ");
scanf("%d",&b);
hasil = faktorial(a)/faktorial(b)*faktorial(a-b);
printf ("%d!=%d\n",a,faktorial(a));
printf ("%d!=%d\n",b,faktorial(b));
printf ("%d-%d!=%d\n",a,b,faktorial(a-b));
printf("%d C %d = %d\n\n",a,b,hasil);
return 0;
}

Source code program C menghitung nilai Permutasi
Berikut ini merupakan source code bahasa C untuk membuat program penghitung nilai dari permutasi bilangan

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
main()
{
int x,y,m,n,z=0,nilai=1;
system(“color d”);
puts(“\t\t=========================================================”);
puts(“\n\t\t =============== \2\4 PROGRAM PERMUTASI \4\2 ===============”);
puts(“\n\t\t=========================================================”);
printf(“\n\nmasukkan banyak angka yang akan di cari permutasinya : “, x);
scanf(“%d”,&x);
system(“color b”);
puts(“\n===========================”);
printf(“Hasil Permutasinya”);
puts(“\n===========================”);

for(n=0;n<x;n++)
{
n=nilai*x;
nilai=n;
}

int p[x];
for(y=0;y<x;y++)
p[y]=1;
for(y=0;y<nilai;y++)
{
for(m=0;m<x;m++)
printf(“%d  “,p[m]);
p[x-1]++;
printf(“\n”);

for(m=x-1;m>0;m–)
{
if(p[m]>x)
{
p[m]=1;
p[m-1]++;
}
}
}
puts(“\n===========================”);
getch();
}

Contoh Program Antrian

Source Code C++:
#include <iostream.h>
#include <conio.h>

int main()
{
    int cek=0, data[20], x, hapus;
    char pil;
    do {
           
           cout<<"1. Tambah Antrian"<<endl;
           cout<<"2. Hapus Antrian"<<endl;
           cout<<"3. Lihat Antrian"<<endl;
           cout<<"4. Keluar"<<endl;
         cout<<endl;
           cout<<"Silahkan masukkan pilihan anda = ";
            pil=getche();
         cout<<endl;
if(pil!='1' && pil !='2' && pil !='3' && pil!='4' )
          cout<<"Andasalah mengetikkan inputan";
            else
            {
               if(pil=='1')   //PUSH
               {
                   if(cek==20)
                       cout<<"Antrian Penuh";
                   else
                   {
                   cout<<"Masukkan nilai = ";
              cin>>x;
                       data[cek]=x;
                       cek++;
                   }
               }
               else
               {
                   if(pil=='2')     //POP
                   {
                       if(cek==0)
                           cout<<"Antrian kosong";
                       else
                       {
                           hapus=data[0];
                           for(int v=0;v<cek;v++)
                               data[v]=data[v+1];
                           data[cek-1]=NULL;
                           cek--;
                      cout<<"Data dengan nilai "<<hapus<<"terhapus";
                       }
                       getch();
                   }
                   else
                   {
                       if(pil=='3')   //CEK DATA
                       {
                           if(cek==0)     
                               cout<<"Antrian Kosong";

                           else
                           {
                               cout<<endl;
                               for(int z=0;z<cek;z++)
                               {
                                   cout<<" | ";
                                   cout<<" "<<data[z];
                                   cout<<" | ";
                               }

                           }
                           getch();
                           return 0;
                       }
                   }
               }
            }

    }while(pil!='4');
}