数据结构作业大合集

这一篇包含了数据结构从线性表到树的大部分基本操作以及一些典例（是数据结构上机考试前花了一下午时间写的）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct binode
{
 char data;
 struct binode *lchild,*rchild;
}Binode,*Bitree;
int initbitree(Bitree &L)
{
 L=(Bitree)malloc(sizeof(Binode));
 L->lchild=L->rchild=NULL;
 return 1;
}
/*递归创建二叉树*/
void createbitree(Bitree &L)
{
 char e;
 scanf("%c",&e);
 if(e!='#')
 {
  L=(Bitree)malloc(sizeof(Binode));
  L->lchild=L->rchild=NULL;
  L->data=e;
  createbitree(L->lchild);
  createbitree(L->rchild);
 }
}
/*递归遍历*/
void dispbitree(Bitree L)
{
 if(L)
 {
  printf("%c ",L->data);
  dispbitree(L->lchild);
  dispbitree(L->rchild);
 }
}
/*队列*/
typedef struct squeue
{
 Bitree *data;
 int rear,first;
 int maxsize;
}Squeue;
int initqueue(Squeue *S)
{
 S->data=(Bitree *)malloc(sizeof(Bitree)*100);
 S->first=S->rear=0;
 S->maxsize=100;
 return 1;
}
int enqueue(Squeue *S,Bitree T)
{
 S->data[S->rear]=T;
 S->rear=(S->rear+1)%S->maxsize;
 return 1;
}
Bitree gettop(Squeue S)
{
 Bitree e;
 e=S.data[S.first];
 return e;
}
Bitree dequeue(Squeue *S)
{
 Bitree T;
 T=S->data[S->first];
 S->first=(S->first+1)%S->maxsize;
 return T;
}
/*读入边的创建二叉树*/
void Createbitree(Bitree &T)
{
 char fa,ch;
 char flag;
 Squeue S;Bitree Q;
 initqueue(&S);
 Bitree P;
 scanf("%c %c %c\n",&fa,&ch,&flag);
 while(ch!='#')
 {
  P=(Bitree)malloc(sizeof(Binode));
  P->data=ch;
  P->lchild=P->rchild=NULL;
  enqueue(&S,P);
  if(fa=='#')
   T=P;
  else
  {
   Q=gettop(S);
   while(Q->data!=fa)
   {
    dequeue(&S);
    Q=gettop(S);
   }
   if(flag=='0')
    Q->lchild=P;
   else
    Q->rchild=P;
  }
  scanf("%c %c %c\n",&fa,&ch,&flag);
 }
}
/*二叉树的复制*/
void copybitree(Bitree &T,Bitree &P)
{
 if(T)
 {
  P=(Bitree)malloc(sizeof(Binode));
  P->data=T->data;
  P->lchild=P->rchild=NULL;
  if(T->lchild)
   copybitree(T->lchild,P->lchild);
  if(T->rchild)
   copybitree(T->rchild,P->rchild);
 }
}

/*根据先序遍历和中序遍历创建二叉树*/
void bianlicreate(Bitree &T,char pre[],char in[],int prel,int prer,int inl,int inr)
{
 int n,flag;
 int i=inl;
 while(in[i]!=pre[prel])
 {
  i++;
 }
 
 T=(Bitree)malloc(sizeof(Binode));
 T->data=in[i];
 T->lchild=T->rchild=NULL;
 int len;
 len=i-inl;
 
 if(i<inr)
  bianlicreate(T->rchild,pre,in,len+prel+1,prer,i+1,inr);
 if(i>inl)
  bianlicreate(T->lchild,pre,in,prel+1,prel+len,inl,i-1);
}
/*表达式二叉树*/ 
typedef struct snode
{
 char *data;
 int top;
}Snode;
typedef struct stack
{
 Bitree *data;
 int top;
}Stack;
int initsnode(Snode *S)
{
 S->data=(char *)malloc(sizeof(char)*100);
 S->top=0;
 return 1;
}
int initstack(Stack *S)
{
 S->data=(Bitree *)malloc(sizeof(Bitree)*100);
 S->top=0;
 return 1;
}
int ensnode(Snode *S,char e)
{
 S->data[S->top]=e;
 S->top++;
 return 1;
}
char desnode(Snode *S)
{
 char e;
 e=S->data[--S->top];
 return e;
}
int enstack(Stack *S,Bitree e)
{
 S->data[S->top++]=e;
 return 1;
}
Bitree destack(Stack *S)
{
 Bitree e;
 e=S->data[--S->top];
 return e;
}
char gettop(Snode S)
{
 char e;
 e=S.data[S.top-1];
 return e;
}
Bitree gettop(Stack S)
{
 Bitree e;
 e=S.data[S.top-1];
 return e;
}
int level(char e)
{
 if(e=='#')
  return 1;
 else if(e=='(')
  return 2;
 else if(e=='+'||e=='-')
  return 3;
 else if(e=='*'||e=='/')
  return 4;
}

Bitree biaodashi(char data[])
{
 int i=0;Bitree a,b;Bitree T;
 int n=strlen(data);char e1;char e;
 data[n]='#';
 data[n+1]='\0';
 e=data[i];
 Snode S;
 Stack P;
 initsnode(&S);
 initstack(&P);
 ensnode(&S,'#');
 while(e!='\0')
 {
  switch(e)
  {
   case '(' : ensnode(&S,e);
      break;
   case ')' :  e1=gettop(S);
     while(e1!='(')
     {
      e1=desnode(&S);
      a=destack(&P);
      b=destack(&P);
      T=(Bitree)malloc(sizeof(Binode));
      T->lchild=b;
      T->rchild=a;
      T->data=e1;
      enstack(&P,T);
      e1=gettop(S);
     }
     desnode(&S);
     break;
   case '+': case '-': case '*': case '/': case '#':
      e1=gettop(S);
      while(level(e1)>level(e))
      {
       e1=desnode(&S);
       switch(e1)
       {
        case '+':  b=destack(&P);
           a=destack(&P);
           T=(Bitree)malloc(sizeof(Binode));
           T->data=e1;
           T->lchild=a;
           T->rchild=b;
           enstack(&P,T);
           break;
        case '-': b=destack(&P);
           a=destack(&P);
           T=(Bitree)malloc(sizeof(Binode));
           T->data=e1;
           T->lchild=a;
           T->rchild=b;
           enstack(&P,T);
           break;
        case '*': b=destack(&P);
           a=destack(&P);
           T=(Bitree)malloc(sizeof(Binode));
           T->data=e1;
           T->lchild=a;
           T->rchild=b;
           enstack(&P,T);
           break;
        case '/': b=destack(&P);
           a=destack(&P);
           T=(Bitree)malloc(sizeof(Binode));
           T->data=e1;
           T->lchild=a;
           T->rchild=b;
           enstack(&P,T);
           break;
       }
       e1=gettop(S);
      }
      ensnode(&S,e);
      break;
   default: T=(Bitree)malloc(sizeof(Binode));
      T->data=e;
      T->lchild=T->rchild=NULL;
      enstack(&P,T);
      break; 
   
  }
  e=data[++i];
 }
 
 
 T=destack(&P);
 return T;
}
/*任务书遍历*/
typedef struct SNODE
{
 Bitree data;
 int task; 
}SNODE;
typedef struct 
{
 SNODE *data;
 int top;
}rensnode;
int initrensnode(rensnode *S)
{
 S->data=(SNODE *)malloc(sizeof(SNODE)*100);
 S->top=0;
 return 1;
}
int enrensnode(rensnode *S,SNODE e)
{
 S->data[S->top++]=e;
 return 1;
}

SNODE derensnode(rensnode *S)
{
 SNODE e;
 e=S->data[--S->top];
 return e;
}
void renwushu(Bitree T)
{
 rensnode S;
 initrensnode(&S);
 SNODE E,e;
 e.data=T;
 e.task=1;
 enrensnode(&S,e);
 while(S.top>0)
 {
  e=derensnode(&S);
  if(e.task==1)
  {
   printf("%c ",e.data->data);
   if(e.data->rchild)
   {
    E.data=e.data->rchild;
    E.task=1;
    enrensnode(&S,E);
   }
   E.data=e.data;
   E.task=0;
   enrensnode(&S,E);
   if(e.data->lchild)
   {
    E.data=e.data->lchild;
    E.task=1;
    enrensnode(&S,E);
   }
  }
    
 }  
}
/*路径分析遍历*/
typedef struct
{
 Bitree *data;
 int top; 
}lunsnode;
int initlunsnode(lunsnode *S)
{
 S->data=(Bitree *)malloc(sizeof(Binode)*100);
 S->top=0;
 return 1;
}
int enlunsnode(lunsnode *S,Bitree e)
{
 S->data[S->top++]=e;
 return 1;
}
Bitree delunsnode(lunsnode *S)
{
 Bitree e;
 e=S->data[--S->top];
 return e;
} 
void lunjing(Bitree T)
{
 lunsnode S;Bitree P;
 initlunsnode(&S);
 enlunsnode(&S,T);
 while(S.top>0)
 {
  P=delunsnode(&S);
  while(P)
  {
  printf("%c ",P->data);
  if(P->rchild)
   enlunsnode(&S,P->rchild);
   P=P->lchild;
  }
  
 }
} 

/*创建孩子兄弟链表创建树*/
typedef struct SNode
{
 char data;
 struct SNode *firstchild,*nextsibling;
}tree,*Tree;
typedef struct queue
{
 Tree *data;
 int first,rear;
 int maxsize;
}SQueue;
int Initqueue(SQueue *S)
{
 S->data=(Tree *)malloc(sizeof(tree)*100);
 S->first=S->rear=0;
 S->maxsize=100;
 return 1;
}
int Enqueue(SQueue *S,Tree e)
{
 S->data[S->rear%S->maxsize]=e;
 S->rear=(S->rear+1)%S->maxsize;
 return 1;
}
Tree Dequeue(SQueue *S)
{
 Tree e;
 e=S->data[S->first%S->maxsize];
 S->first=(S->first+1)%S->maxsize;
 return e;
}
Tree gettop(SQueue S)
{
 Tree e;
 e=S.data[S.first];
 return e;
}
void createtree(Tree &T)
{
 char fa,ch;Tree P,r,Q;SQueue S;
 Initqueue(&S);T=NULL;
 scanf("%c%c",&fa,&ch);
 while(ch!='#')
 {
  P=(Tree)malloc(sizeof(tree));
  P->data=ch;
  P->firstchild=P->nextsibling=NULL;
  if(fa=='#')
   T=P;
  else
  {
   Q=gettop(S);
   while(Q->data!=fa)
   {
    Dequeue(&S);
    Q=gettop(S);
   }
   if(Q->firstchild==NULL)
   {
    Q->firstchild=P;r=P;
   }
   else
   {
    r->nextsibling=P;r=P;
   }
   
   
  }
  scanf("%c%c",&fa,&ch);
 }
}
void disptree(Tree T)
{
 if(T)
 {
  printf("%c ",T->data);
  disptree(T->firstchild);
  disptree(T->nextsibling);
 }
}

int main()
{
 Bitree L;Bitree P;Bitree T;char pre[20],in[20];
 createbitree(L);
 Createbitree(L);
 dispbitree(L);
 printf("\n-----------\n");
 copybitree(L,P);
 dispbitree(P);
 printf("\n");
 printf("\n------------\n");
 scanf("%s",pre);
 scanf("%s",in); 
 bianlicreate(T,pre,in,0,strlen(pre),0,strlen(in));
 dispbitree(T);
 char data[20];Bitree T;
 scanf("%s",data);
 T=biaodashi(data);
 dispbitree(T);
 Bitree L;
 createbitree(L);
 renwushu(L);
 lunjing(L);
 Tree T;
 createtree(T);
 disptree(T);
 system("pause");
 return 0;
}