fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <assert.h>
  5.  
  6. struct data{
  7.   int integer;              
  8.   int level;                
  9.   struct data *rlink;       
  10.   struct data *llink;
  11.   struct data *connect;     
  12. };
  13.  
  14. struct QUEUE{
  15.     struct data *rear,*front;
  16. };
  17.  
  18. void insertion(void);     
  19. void access(int);      
  20. void preorder(struct data*);            //preorder traversal
  21. void inorder(struct data*);             //inorder traversal
  22. void postorder(struct data*);           //postorder traversal
  23. void breadth_first(struct data*);       //breadth-first traversal
  24.  
  25. struct data *root, *ptr;
  26.  
  27.  
  28. int main()
  29. {
  30.     int i=0;
  31.     int a;
  32.     int exit=0;
  33.     srand(time(NULL));
  34.  
  35.  
  36.     FILE *fp;                         
  37.     fp=fopen("data.txt","w");
  38.     assert( fp != NULL );
  39.     for(i=0;i<10;i++)
  40.     fprintf(fp,"%d\n",rand()%100+1);
  41.     fclose(fp);
  42.  
  43.     insertion();
  44.     while(exit!=5)
  45.     {
  46.         printf("\n----HELLO!THIS IS PROJECT4!----\n");
  47.         printf("(1)preorder\n(2)inorder\n(3)postorder\n(4)breadth-first\n(5)exit\n");
  48.         printf("please select one operation:");
  49.         scanf("%d",&a);
  50.  
  51.        switch(a)
  52.        {
  53.         case 1:
  54.               preorder(root);
  55.               break;
  56.  
  57.         case 2:
  58.               inorder(root);
  59.               break;
  60.  
  61.         case 3:
  62.               postorder(root);
  63.               break;
  64.  
  65.         case 4:
  66.               breadth_first(root);
  67.               break;
  68.  
  69.         case 5:
  70.             printf("exit!\n");
  71.             exit = 5;
  72.             break;
  73.        }
  74.       }
  75.     return 0;
  76. }
  77.  
  78. void insertion(void)
  79. {
  80.     FILE *fptr;
  81.     int integer;
  82.     printf("\nFile loading...\n");
  83.     if((fptr = fopen("data.txt","r")) == NULL)
  84.     {
  85.          printf("failed......");
  86.          return;
  87.     }
  88.     while(fscanf(fptr,"%d\n",&integer)!=EOF)
  89.      access(integer);
  90.      fclose(fptr);
  91.      printf("loading success\n");
  92. }
  93.  
  94. void access(int integer)
  95. {
  96.     struct data *node, *prev;
  97.     ptr = (struct data *)malloc(sizeof(struct data));
  98.     ptr->integer=integer;
  99.     ptr->llink = ptr->rlink = NULL;
  100.     if(root == NULL)     
  101.        root = ptr;
  102.     else              
  103.     {
  104.         node = root;
  105.         while(node!=NULL)
  106.         {
  107.             prev = node;
  108.             if((ptr->integer) < (node->integer))     
  109.                 node = node->llink;
  110.             else
  111.                 node = node->rlink;                  
  112.         }
  113.         if((ptr->integer) < (prev->integer))
  114.                 prev->llink = ptr;
  115.         else
  116.                 prev->rlink = ptr;
  117.      }
  118. }
  119.  
  120. void preorder(struct data *node)
  121. {
  122.     if(node!=NULL)
  123.     {
  124.       printf("%d.",node->integer);
  125.       preorder(node->llink);
  126.       preorder(node->rlink);
  127.     }
  128. }
  129.  
  130. void inorder(struct data *node)
  131. {
  132.     if(node!=NULL)
  133.     {
  134.         inorder(node->llink);
  135.         printf("%d.",node->integer);
  136.         inorder(node->rlink);
  137.     }
  138. }
  139.  
  140. void postorder(struct data *node)
  141. {
  142.     if(node!=NULL)
  143.     {
  144.         postorder(node->llink);
  145.         postorder(node->rlink);
  146.         printf("%d.",node->integer);
  147.     }
  148.  
  149. }
  150.  
  151. void breadth_first(struct data *node)
  152. {
  153.     struct QUEUE *p;
  154.     p = (struct QUEUE *)malloc(sizeof(struct QUEUE));
  155.     int i;
  156.  
  157.      for(i=0;;i++)
  158.      {
  159.       if(i==0)
  160.       {
  161.             p->front=root;                      
  162.             root->level=i+1;                    
  163.             printf("%d.",root->integer);
  164.             p->rear=root;
  165.       }
  166.       else
  167.       {
  168.        while(p->front->level==i)
  169.        {
  170.             if(p->front->llink!=NULL)            
  171.                 {
  172.                     p->rear->connect = p->front->llink;
  173.                     p->rear = p->front->llink;
  174.                     p->rear->level = i+1;
  175.                     printf("%d.",p->rear->integer);
  176.                 }
  177.             if(p->front->rlink!=NULL)            
  178.                 {
  179.                     p->rear->connect = p->front->rlink;
  180.                     p->rear = p->front->rlink;
  181.                     p->rear->level=i+1;
  182.                     printf("%d.",p->rear->integer);
  183.                 }
  184.             if(p->front->connect!=NULL)
  185.                 {
  186.                      p->front=p->front->connect;
  187.                 }
  188.             else
  189.                 {
  190.                     break;
  191.                 }
  192.        }
  193.       }
  194.  
  195.       if((p->front->llink==NULL) && (p->front->rlink==NULL) && (p->front->connect==NULL))  
  196.       {
  197.         break;
  198.       }
  199.  
  200.      }
  201. }
  202.  
Runtime error #stdin #stdout 0.01s 1804KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/uMzhQ3
language:
C (gcc 8.3)
created:
13 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!