数据结构常用算法程序（C语言）

本文章所有程序均摘取自老师课件，仅供自己方便查看。

插入排序

#include 
typedef struct
{int key;
}datatype;
void D_InsertSort(datatype R[ ],int n)
/*待排序的n个元素放在数组R中，用直接插入法进行排序*/
{   int i,j;
	for ( i=2; i<=n; i++)  /*i控制第i-1次插入,最多进行n-1次插入*/
      if (R[i].key0&&R[0].key

迪杰斯特拉算法

#include 
#define MaxVertexNum 100
/* 最大顶点数设为100 */
#define MaxCost 9999
/* 边的权值最大为9999 */
typedef char VertexType;
/* 顶点类型设为字符型 */
typedef int  EdgeType;
/* 边的权值设为整型 */
typedef struct
   { VertexType vexs[MaxVertexNum];
       /* 存放顶点信息 */
      EdgeType  edges[MaxVertexNum][MaxVertexNum];
/* 存放邻接关系 */
      int  n,e; /*顶点数和边数*/
}Mgraph;
void CreateMGraph(Mgraph *G)
  {int i,j,k,w;
    printf("请输入顶点数和边数(输入格式为:顶点数,边数):\n") ;
    scanf("%d,%d",&(G->n),&(G->e));
    printf("请输入顶点信息:\n");
    for(i=0;in;i++) 
        scanf("\n%c",&(G->vexs[i]));
	for(i=0;in;i++)
        for(j=0;jn;j++) 
            G->edges[i][j]=MaxCost;
    printf("请输入每条边对应的两个顶点的序号(输入格式为:i,j,w):\n");
              for(k=0;ke;k++) 
                   { scanf("%d,%d,%d",&i,&j,&w);
                         G->edges[i][j]=w;  }
  }
void ShortestPath(Mgraph *G,int P[ ],int D[ ])
   {  int final[MaxVertexNum],i,j,k,min;
	  final[0]=1; /* 初始时集合S中只有0号顶点 */
      D[0]=0; 
      P[0]=-1; /* 0号顶点 无前驱顶点 ，用-1表示 */
      for(i=1;in;i++)
         { final[i]=0;
           D[i]=G->edges[0][i];
           P[i]=0; /* P[i]存放i号顶点的前驱顶点 */
        }
      for(i=1;in; i++) /*重复G->n-1次*/
        { min=MaxCost;
          for(k=0;kn;k++)
	      if(final[k]==0&&D[k]n;k++)
	     if(final[k]==0 && D[j]+G->edges[j][k]< D[k])
                 { D[k]=D[j]+G->edges[j][k]; 
		           P[k]=j; }
       } 
}
void main()
{Mgraph G;
 int P[MaxVertexNum],D[MaxVertexNum];
 int i,pre;
 CreateMGraph(&G);
 ShortestPath(&G,P,D);	
 for(i=1;i=0)
             { printf("<-%d",pre); 
                pre=P[pre];
              }
         printf("\n");
      }                     
}

普利姆算法

#include 
#define MaxVertexNum 100
/* 最大顶点数设为100 */
#define MaxCost 9999
/* 边的权值最大为9999 */
typedef char VertexType;
/* 顶点类型设为字符型 */
typedef int  EdgeType;
/* 边的权值设为整型 */
typedef struct
   { VertexType vexs[MaxVertexNum];
       /* 存放顶点信息 */
      EdgeType  edges[MaxVertexNum][MaxVertexNum];
/* 存放邻接关系 */
      int  n,e; /*顶点数和边数*/
}Mgraph;
void CreateMGraph(Mgraph *G)
  {int i,j,k,w;
    printf("请输入顶点数和边数(输入格式为:顶点数,边数):\n") ;
    scanf("%d,%d",&(G->n),&(G->e));
    printf("请输入顶点信息:\n");
    for(i=0;in;i++) 
        scanf("\n%c",&(G->vexs[i]));
	for(i=0;in;i++)
        for(j=0;jn;j++) 
            G->edges[i][j]=MaxCost;
    printf("请输入每条边对应的两个顶点的序号(输入格式为:i,j,w):\n");
              for(k=0;ke;k++) 
                   { scanf("%d,%d,%d",&i,&j,&w);
                         G->edges[i][j]=w; 
						 G->edges[j][i]=w;  }
    }
void Prim(int gm[][MaxVertexNum],int tree[],int cost[],int n)
  { int i,j,k,mincost,flag[MaxVertexNum];
    for (i=1; i

佛洛依德算法

#include 
#define MaxVertexNum 100
/* 最大顶点数设为100 */
#define MaxCost 9999
/* 边的权值最大为9999 */
typedef char VertexType;
/* 顶点类型设为字符型 */
typedef int  EdgeType;
/* 边的权值设为整型 */
typedef struct
   { VertexType vexs[MaxVertexNum];
       /* 存放顶点信息 */
      EdgeType  edges[MaxVertexNum][MaxVertexNum];
/* 存放邻接关系 */
      int  n,e; /*顶点数和边数*/
}Mgraph;
void CreateMGraph(Mgraph *G)
  {int i,j,k,w;
    printf("请输入顶点数和边数(输入格式为:顶点数,边数):\n") ;
    scanf("%d,%d",&(G->n),&(G->e));
    printf("请输入顶点信息:\n");
    for(i=0;in;i++) 
        scanf("\n%c",&(G->vexs[i]));
	for(i=0;in;i++)
        for(j=0;jn;j++) 
            G->edges[i][j]=MaxCost;
    printf("请输入每条边对应的两个顶点的序号(输入格式为:i,j,w):\n");
              for(k=0;ke;k++) 
                   { scanf("%d,%d,%d",&i,&j,&w);
                         G->edges[i][j]=w;  }
  }
void floyd(Mgraph G,int D[MaxVertexNum][MaxVertexNum],int P[MaxVertexNum][MaxVertexNum])
  { int i,j,k;
    for(i=0;iD[i][k]+D[k][j])
	    {D[i][j]=D[i][k]+D[k][j];
	     P[i][j]=P[i][k];  /* i到j的路径上i的后继顶点改为i到k路径上i的后继顶点 */ 	 
         }
  }
  void opfloy(int n,int D[MaxVertexNum][MaxVertexNum],int P[MaxVertexNum][MaxVertexNum])
     {int i,j,k,c,min,next;
       for (i=0;i%d",next);
		 next=P[next][j];  }
	     if (D[i][j]==MaxCost)
	     printf("->%d",j);
	     printf("\t%d",D[i][j]); }
	 }
   }
void main()
{Mgraph G;
 int n,D[MaxVertexNum][MaxVertexNum],P[MaxVertexNum][MaxVertexNum];
 CreateMGraph(&G);
 floyd(G,D,P); 
 opfloy(G.n,D,P);
 printf("\n");
}

克鲁斯卡尔算法

#include 
#define MaxVertexNum 100
/* 最大顶点数设为100 */
#define MaxEdgeNum 100
/* 最大边数设为100 */
#define MaxCost 9999
/* 边的权值最大为9999 */
typedef char VertexType;
/* 顶点类型设为字符型 */
typedef int  EdgeCost;
/* 边的权值设为整型 */
typedef struct
   { VertexType vexs[MaxVertexNum];
       /* 存放顶点信息 */
      EdgeCost  edges[MaxVertexNum][MaxVertexNum];
/* 存放邻接关系 */
      int  n,e; /*顶点数和边数*/
}Mgraph;
typedef struct
   { int v1;
     int v2;
	 EdgeCost cost;
}EdgeType;
void CreateMGraph(Mgraph *G)
  {int i,j,k,w;
    printf("请输入顶点数和边数(输入格式为:顶点数,边数):\n") ;
    scanf("%d,%d",&(G->n),&(G->e));
    printf("请输入顶点信息:\n");
    for(i=0;in;i++) 
        scanf("\n%c",&(G->vexs[i]));
	for(i=0;in;i++)
        for(j=0;jn;j++) 
            G->edges[i][j]=MaxCost;
    printf("请输入每条边对应的两个顶点的序号(输入格式为:i,j,w):\n");
              for(k=0;ke;k++) 
                   { scanf("%d,%d,%d",&i,&j,&w);
                         G->edges[i][j]=w; 
						 G->edges[j][i]=w;  }
    }
void Sort(Mgraph *G, EdgeType e[],int *EdgeNum)  /* 用Kruskal方法求最小生成树  */ 
  {EdgeType e1;
   int i,j,k,m;
   int mincost;
    m=-1;
    for(i=0;in;i++)
    for(j=i+1;jn;j++)
     if(G->edges[i][j]!=MaxCost)
       {m++;
	    e[m].v1=i;
	    e[m].v2=j;
	    e[m].cost=G->edges[i][j]; 
       }  /*将边存入数组e中*/
   for(i=0;i=0)
      t=father[t];
    return(t);
  }
void Kruskal(EdgeType edges[],EdgeType T[],int m,int n)
/* 假定edges[]中的数据已按cost值由小到大排序 */
 { int father[MaxVertexNum];
   int i,j,vf1,vf2;
   for(i=0;i

堆排序

#include 
typedef int keytype;
typedef struct 
{keytype key;
}datatype;
void HeapAdjust(datatype R[],int s,int t)
{   int i,j;
    datatype rc;
	rc=R[s];  /*用rc暂存R[S]*/
    i=s;  j=2*i;
    for (j=2*i;j<=t;j=2*j)
      { if (jR[j].key)
	      break;
	    R[i]=R[j];  /*j号元素上移*/
    	i=j;     /*准备继续向下调整*/
      }
    R[i]=rc; /*将rc中的元素放到R[i]中*/
}
void heapsort(datatype R[],int n)
{      int i;
	   for(i=n/2;i>=1;i--)
           HeapAdjust(R,i,n);
       for(i=n;i>1;i--)
          { R[0]=R[1];
	        R[1]=R[i];
	        R[i]=R[0];
	        HeapAdjust(R,1,i-1);
           }
      }
void main()
{ int i;
  datatype a[]={0,1,7,9,54,33,656,342,2,2224,123};
  heapsort(a,10);
  for(i=1;i<=10;i++) printf("%d ",a[i]);
  printf("\n");
}

二叉排序树

#include  
#include  
#define  MAXNUM  20 
#define NULL 0
typedef int keytype;
typedef struct
   { keytype key;    /* 关键码 */
   }datatype;
typedef struct bistnode
     {datatype data; 
      struct bistnode *lchild, *rchild;
     }BiSTNode,*BiSTree;	
BiSTree BST_InsertNode(BiSTree t,keytype kx)
/* 将关键码为kx的元素插入二叉排序树中 */
{    BiSTNode *f,*p,*s; 
     p=t;
     while(p)
	 { if (kx==p->data.key) {printf("kx已存在，不需插入!"); return(t);}
       else { f=p;
	          if(kxdata.key) p=p->lchild;
			  else p=p->rchild;}
	 }
	 s=(BiSTNode *)malloc(sizeof(BiSTNode));
     s->data.key=kx;
	 s->lchild=NULL;
	 s->rchild=NULL;
     if (!t) t=s;    /*  向空树中插入时  */
     else  { if(kxdata.key)  f->lchild=s;
             else f->rchild=s; } 
     return(t);
}   /* 利用该算法便可构造一棵二叉排序*/

BiSTree  BST_Creat( )      	/*生成二叉排序树*/
{BiSTree t=NULL;
 keytype kx;
 scanf("%d",&kx);    	/*假设关键码是整型的*/
 //scanf（… ）;                     /*读入其它信息*/
 while(kx!=0)           	             /*假设读入0结束*/
  { t=BST_InsertNode(t,kx);  /*向二叉排序树t中插入关键码为kx的结点*/
    scanf("%d",&kx);   	/*输入下一关键码*/
   //scanf（… ）;
  }
  return(t);
}
BiSTNode* BST_Search1(BiSTree t, keytype kx)
/*在二叉排序树t上查找关键码为kx的元素，若找到，返回所在结点的地址，否则返回空指针*/
{ BiSTNode *p;
  p=t;
  while(p)	/*从根结点开始查找*/
    {if (kx==p->data.key) return(p); /*kx等于当前结点p的关键码，查找成功*/
    if(kxdata.key) p=p->lchild; /*kx小于p的关键码转左子树查找*/
    else  p=p->rchild; 	                /*kx大于p的关键码转右子树查找*/
    }
  return NULL; 	/*查找失败*/
 }                        
BiSTNode* BST_Search2 (BiSTree t, keytype kx)
{ /*在二叉排序树t上查找关键码为kx的元素，若找到，返回所在结点的地址，否则返回空指针*/
 if (t==NULL || t->data.key==kx)
     return(t); 	/*若树空，或者根结点的关键码等于kx，返回t*/
else if(kxdata.key)   
               BST_Search2(t->lchild, kx);  /*kx小于p的关键码在左子树查找*/
        else   BST_Search2(t->rchild, kx); /*kx大于p的关键码在右子树查找*/
}
void inorder(BiSTree t)
{if(t)
{   inorder(t->lchild);
	printf("%d ",t->data);
	inorder(t->rchild);}
}

void main()
{BiSTree bt,p;
 bt=BST_Creat( ); 
 inorder(bt);	 
 p=BST_Search1(bt,99);
 if(p) printf("\n%d",p->data.key);
 p=BST_Search2(bt,99);
 if(p) printf("\n%d",p->data.key);
 printf("\n");
}

广度优先搜索

#include 
#define MaxVertexNum 100
/* 最大顶点数设为100 */
typedef char VertexType;
/* 顶点类型设为字符型 */
typedef int  EdgeType;
/* 边的权值设为整型 */
typedef struct
   { VertexType vexs[MaxVertexNum];
       /* 存放顶点信息 */
      EdgeType  edges[MaxVertexNum][MaxVertexNum];
/* 存放邻接关系 */
      int  n,e; /*顶点数和边数*/
}Mgraph;
int flag[MaxVertexNum];
void CreateMGraph(Mgraph *G)
  {int i,j,k;
   printf("请输入顶点数和边数(输入格式为:顶点数,边数):\n") ;
    scanf("%d,%d",&(G->n),&(G->e));
    printf("请输入顶点信息:\n");
    for(i=0;in;i++) 
	  scanf("\n%c",&(G->vexs[i])); 
    for(i=0;in;i++)
        for(j=0;jn;j++) 
            G->edges[i][j]=0;
    printf("请输入每条边对应的两个顶点的序号(输入格式为:i,j):\n");
              for(k=0;ke;k++) 
                   { scanf("\n%d,%d",&i,&j);
                         G->edges[i][j]=1; 
						 G->edges[j][i]=1; }
        } 

void BFSM(Mgraph *G,int k) 
/*从vk出发，广度优先遍历图G*/
 { int i,j; 
   int Q[MaxVertexNum],front,rear;
   front=-1;rear=-1;  /* 初始化队列Q */
   printf("%c ",G->vexs[k]); 
   flag[k]=1;
   rear++; Q[rear]=k;  /* k入到队列Q中 */
   while(front!=rear) /* 队列Q不空时 */
    { front++;i=Q[front];
      for (j=0;jn;j++)
     if(G->edges[i][j]==1&&!flag[j]) 
        { printf("%c ",G->vexs[j]); 
          flag[j]=1;
          rear++; Q[rear]=j; /* j入队 */
        }
   }
  }
void BFSTraverseAL(Mgraph *G)
 { int i;
   for (i=0;in;i++) 
     flag[i]=0;
   /* 给所有顶点一个未被访问标记 */
   for (i=0;in;i++)
     if(!flag[i]) BFSM(G,i); 
   /*若vi未被访问过,从vi 开始进行广度优先遍历*/
  } /* 要特别注意非连通图的遍历 */
void main()
{Mgraph G;
 CreateMGraph(&G);
 BFSTraverseAL(&G);
 printf("\n");
}

深度优先搜索

#include 
#include 
#define NULL 0
#define MaxVerNum  100
/* 最大顶点数设为100 */
typedef char vertexType;
/* 顶点类型设为字符型 */
typedef struct node
  { int adjvex;
    struct node *next;
  }EdgeNode;
typedef struct vnode
   { vertexType vertex;
     EdgeNode *firstedge;
   }VertexNode;
typedef VertexNode AdjList[MaxVerNum];
typedef  struct
   { AdjList adjlist;
      int n,e ;
    }ALGraph;
int flag[MaxVerNum]; 
void CreateALGraph(ALGraph *G)
   {int i,j,k;
     EdgeNode *s;
    printf("请输入顶点数和边数(输入格式为:顶点数,边数):\n" );
     scanf("%d,%d",&(G->n),&(G->e));
   printf("请输入顶点信息:\n");
     for(i=0;in;i++)
	 { scanf("\n%c",&(G->adjlist[i].vertex));
       G->adjlist[i].firstedge=NULL;}
     printf("请输入边的信息(输入格式:i,j):\n");
     for(k=0;ke;k++)
        {scanf("%d,%d",&i,&j);
         s=(EdgeNode*)malloc(sizeof(EdgeNode));
         s->adjvex=j;
         s->next=G->adjlist[i].firstedge;
         G->adjlist[i].firstedge=s;
	     s=(EdgeNode*)malloc(sizeof(EdgeNode));
         s->adjvex=i;
         s->next=G->adjlist[j].firstedge;
         G->adjlist[j].firstedge=s;}  
}
void DFSAL(ALGraph *G,int i)
  {  EdgeNode *p; int j;
     printf("%c ",G->adjlist[i].vertex);/*访问顶点vi*/
     flag[i]=1;    /* 标记顶点vi已被访问过 */ 
     p= G->adjlist[i].firstedge; /*取vi边表头指针*/
     while (p) /* 若p存在 */
       {  j=p->adjvex;
           if ( !flag[j])    /* 若顶点 j 未被访问过 */
              DFSAL(G,j);
            /* 从顶点 j 出发开始深度优先遍历图 */
           p=p->next; /*找和vi 相邻的下一邻接顶点*/
       }
 }
void DFSTraveseAL(ALGraph *G)
    { int i;
       for (i=0; in;i++)  flag[i]=0;                 
      /* 给每个顶点一个未访问过标记 */
       for (i=0; in; i++)
          if (!flag[i]) DFSAL(G,i);    
 /*若顶点vi未访问过,从vi开始深度优先遍历图*/
     }  /* 要特别注意非连通图的遍历 */
void main()
{ALGraph G;
 CreateALGraph(&G);
 DFSTraveseAL(&G);
 printf("\n");
}

归并排序

1.非递归

#include 
typedef struct
{int key;
}datatype;
void Merge ( datatype R[ ], datatype R1[ ], int s, int  m, int t  )
/* 将有序的 R[s..m] 和 R[m＋1..t]  归并为有序的 R1 [ s..t] */
     { int i,j,k;
	   i=s; j = m+1; k= s;
        while( i <= m &&  j<= t)
            { if ( R[i].key <=R[j].key )  R1[k++] = R[ i++];
             else R1[k++] = R[ j++]; 
             } /* 将 R 中的记录由小到大依次并入到 R1中 */
       while  ( i <= m ) R1[k++] = R[ i++];  /* 将剩余的 R[i..m] 复制到 R1中 */
        while ( j <= t )  R1[k++] = R[ j++];   /* 将剩余的 R[j..t]  复制到 R1中 */
     }
void MergePass(datatype R[],datatype R1[],int len,int n)
 /* len是本趟归并中有序表的长度,从R[1..n]归并到R1[1..n]中 */
{ int i;
  // for(i=1;i+2*len-1<=n;i+2*len) Merge(R,R1,i,i+len-1,i+2*len-1);/* 对两个长度为len的有序表进行合并 */
  i=1;
  while(i+2*len-1<=n)
  { Merge(R,R1,i,i+len-1,i+2*len-1);
    i=i+2*len;}
  if (i+len-1

2.递归

#include 
#define maxnum 20
typedef struct
{int key;
}datatype;
void Merge(datatype R[ ], datatype R1[ ], int s, int  m, int t)
/* 将有序的 R[s..m] 和 R[m＋1..t]  归并为有序的 R1 [ s..t] */
     { int i,j,k;
	   i=s; j = m+1; k= s;
        while( i <= m &&  j<= t)
            { if ( R[i].key <=R[j].key )  R1[k++] = R[ i++];
             else R1[k++] = R[ j++]; 
             } /* 将 R 中的记录由小到大依次并入到 R1中 */
       while  ( i <= m ) R1[k++] = R[ i++];  /* 将剩余的 R[i..m] 复制到 R1中 */
        while ( j <= t )  R1[k++] = R[ j++];   /* 将剩余的 R[j..t]  复制到 R1中 */
     }

void Msort(datatype R[ ],datatype R1[ ],int s,int t)
 {  int m;
    datatype R2[maxnum];
    if  (s==t) R1[s]=R[s];
         else
           {  m=(s+t)/2 ; 	/* 将R[s..t]分为R[s..m]和R[m+1..t] */
              Msort(R,R2,s,m);   /* 递归地将R[s..m]归并为有序的R2[s..m] */
              Msort(R,R2,m+1, t);  /* 递归地将R[m+1..t]归并为有序的R2[m+1..t] */
              Merge(R2,R1,s,m,t);  /* 将R2[s..m]和R2[m+1..t] 归并到R1[s..t]*/
		 }
  }
/*void Msort(datatype R[ ],int s,int t)
 {  int m,i;
    datatype R1[maxnum];
    if  (s

快速排序

#include 
typedef int keytype;
typedef struct
   { keytype key;    /* 关键码 */
   }datatype;
int Partition(datatype R[],int low,int high)
{   R[0]=R[low];  /* 暂存界点元素到R[0]中*/
    while(low=R[0].key) high--;
	     if(low

哈夫曼

#include 
#include 
#define MAXVALUE 10000 /*最大权值为10000 */
#define MAXLEAF 30 /* 最多有30个叶子结点 */
#define MAXNODE MAXLEAF*2-1 
/* 因哈夫曼树无度为1的结点,总结点数
n=n0+n2 。当n0 =30时,根据二叉树性质
n0=n2+1, n2 = n0 –1=29，所以哈夫曼树
最多有30+29 =59个结点 */
#define MAXBIT 10  
typedef struct 
  {int weight;
   int parent;
   int lchild;
   int rchild;
  }HNodeType;  
typedef struct 
        { int bit[MAXBIT ];  /*保存各字符哈夫曼编码的空间*/
           int start;      /* 保存各字符哈夫曼编码的开始位置 */
         }HCodeType;
void Create_HuffMTree(HNodeType HFMTree[ ],int n)
    {int m1,m2,x1,x2;
     int i,j;
      for(i=0;i<2*n-1;i++)
         {HFMTree[i].weight=0;
           HFMTree[i].parent=-1;
           HFMTree[i].lchild=-1;
           HFMTree[i].rchild=-1;}
      for (i=0;i

单链表

#include 
#include 
#define null 0
typedef int datatype;
typedef struct node
    {datatype data;
     struct node *next;  
    }LNode,*LinkList;

LNode  *create_head ( )
 { LNode *head;
   head = (LNode *)malloc(sizeof(LNode));    
   head->next = NULL;    
   return (head);
 }   

LinkList Create_LinkList1( )
{ LNode *s;
  LinkList head; 	
  int x;
  head =create_head (); 
  scanf("%d",&x); /*假设数据域为整型*/
  while(x!=-1)             /*-1为结束标志*/
    {s=(LNode*)malloc(sizeof(LNode)); /*为新结点申请空间*/
	 s->data=x; s->next=head->next; /*为新结点赋值*/
	 head->next=s;                  /*修改头指针*/
	 scanf("%d",&x);}
	 return(head);
   }
LinkList Create_LinkList2( )
{ LNode *s;
LinkList head,r;
  //LinkList head，r; 	
  int x;
  head =create_head (); 
  r=head; /*尾结点也是头结点*/
  scanf("%d",&x); /*假设数据域为整型*/
	while(x!=-1)             /*-1为结束标志*/
  {s=(LNode*)malloc(sizeof(LNode)); /*为新结点申请空间*/
	 s->data=x; s->next=NULL; /*为新结点赋值*/
	 r->next=s; /*将新结点连到表尾*/ 
     r=s;               /*修改尾指针的值*/
	 scanf("%d",&x);}
	 return head;
 }
LNode *Get_LinkList(LinkList L,int i)
    {	LNode *p=L;
	int j=0;
	while(p->next!=NULL&&jnext; j++; }
	if(j==i) return p;
	else return NULL;
   }
int Insert_LinkList(LinkList L,int i,datatype x)
  { LNode *p,*s;
    p=Get_LinkList(L,i-1);
	  if(p==NULL)
	    { printf("i is wrong!");
		  return 0;}
	  else
	    { s=(LNode*)malloc(sizeof(LNode));
		  s->data=x;
		  s->next=p->next;
		  p->next=s;
		  return 1;	}
   }
int Del_LinkList(LinkList L,int i)
  {	LinkList p,s;
	p=Get_LinkList(L,i-1);
	if(p==NULL)
	  { printf("i-1 not exist!\n");  return -1; }
	else if(p->next==NULL)
	  { printf("i not exist!\n");  return 0; }
	     else
	       { s=p->next;
		  p->next=s->next;
		  free(s);
	         return 1; }
   }
void output(LNode *h)
  { LNode *p;
    printf("Output:");
    p=h->next;
    while (p!=null)
      { printf("%d ",p->data);
        p=p->next;
       }
    printf("\n");
   }

void main()
  {LNode *L2;
   L2=Create_LinkList1( );
   output(L2);
   L2=Create_LinkList2( );
   output(L2);
   Insert_LinkList(L2,3,99);
   output(L2);
   Del_LinkList(L2,1);
   output(L2);
  }

顺序表

#include 
#include 
#define maxsize 10
typedef int datatype;
typedef struct
  {datatype data[maxsize];
   int last;
  }seqlist;
seqlist *init()
  {seqlist *L;
   L=(seqlist*)malloc(sizeof(seqlist));
   L->last=-1;
   return(L);
  }
void input(seqlist *L)
  {int i,k;
   printf("Input element number:");
   scanf("%d",&k);
   for(i=0;i<=k-1;i++)
     scanf("%d",&L->data[i]);
   L->last=k-1;
  }
void output(seqlist *L)
 {int i;
  printf("\noutput:");
  for(i=0;i<=L->last;i++)
    printf("%d ",L->data[i]);
  }
int insert(seqlist *L,int i,datatype x)
  {int j;
   if (L->last==maxsize-1)
     {printf("List full!");
      return(-1); }
    if (i<1||i>L->last+2)
     {printf("Error!");
      return(0); }
    for (j=L->last;j>=i-1;j--)
      L->data[j+1]=L->data[j];
    L->data[i-1]=x;
    L->last++;
    return(1);
  }
int delete(seqlist *L,int i)
  {int j;
   if (i<1||i>L->last+1)
     {printf("No exist!");
      return(0);  }
   for (j=i;j<=L->last;j++)
     L->data[j-1]=L->data[j];
   L->last--;
   return(1);
  }
void main()
  { seqlist *L1;
    L1=init();
    input(L1);
    output(L1);
    delete(L1,2);
    output(L1);
    insert(L1,3,88);
    output(L1);
  }

顺序队列

#include 
#include 
#define MAXSIZE 10
typedef int datatype;
typedef  struct
   { datatype data[MAXSIZE];
      int front,rear;
    }C_SeQueue;
C_SeQueue  *Int_SeQueue( )  
    { C_SeQueue *q;
	   q=(C_SeQueue*)malloc(sizeof(C_SeQueue));
       q->front=q->rear=0;    /* 或MAXSIZE-1等 */
        return q;
    }
int Empty_SeQueue(C_SeQueue *q)
            {if(q->front ==q->rear ) return 1;
              else return 0;
            }

int In_SeQueue(C_SeQueue *q,datatype x)
    { if ((q->rear+1)%MAXSIZE==q->front)
          {  printf("队满");
              return -1;  }
      else
         { q->rear=(q->rear+1)%MAXSIZE;
            q->data[q->rear]=x;
             return 1;  }
     }
int Out_SeQueue(C_SeQueue *q, datatype *x)
   { if (q-> front == q->rear)
      //if (Empty_SeQueue(q))
         {  printf("队空");
             return -1;}
     else
         { q->front=(q->front+1)% MAXSIZE;
           *x=q->data[q->front];
           return 1;   }
    } 
void main()
  {C_SeQueue *sq;
  int x;
  sq=Int_SeQueue( );
  printf("输入（-1结束）：");
  scanf("%d",&x);
  while (x!=-1)
  {if (In_SeQueue(sq,x)==-1) break;
   scanf("%d",&x);}
  while (!Empty_SeQueue(sq))
  {if(Out_SeQueue(sq,&x)) printf("%d ",x);
   }
}

顺序栈

#include 
#include 
#define MAXSIZE 10
typedef  int  datatype;
typedef  struct
    {  datatype  data[MAXSIZE];
        int top;   /*  栈顶指针  */
    } SeqStack;
SeqStack *init_SeqStack( )
   { SeqStack *S;
     S=(SeqStack*)malloc
(sizeof(SeqStack));
     S->top=-1;
     return S;
   }
		
int Empty_SeqStack(SeqStack *S)
   { if(S->top==-1)	 return 1;
     else return 0;
    }

int Push_SeqStack(SeqStack *S,datatype x)
   {if(S->top==MAXSIZE-1) return(0);
    else { S->top++;   S->data[S->top]=x;
	    return(1);	}
   }
int Pop_SeqStack(SeqStack *S,datatype *x)
   { if(Empty_SeqStack(S)==1) return 0;
     else { *x=S->data[S->top];
	     S->top--;
	     return 1;}
   }
datatype Top_SeqStack(SeqStack *S)
       { if(Empty_SeqStack(S)==1)
		       return 0;
	       else
		       return(S->data[S->top]);
       }

void conversion1(int N,int r)
   {SeqStack *s;
     datatype x;
     s=init_SeqStack( );
     while(N) 
        { Push_SeqStack(s,N%r);
                N=N/r;  }
     while(!Empty_SeqStack(s))
           {Pop_SeqStack(s,&x) ;
              printf("%d",x);}
   } 
void conversion2(int N,int r)
    {int s[10],top;
      int x;
      top=-1;
      while(N)
         {s[++top]=N%r;
           N=N/r; }
      while(top!=-1)
         {x=s[top--];
           printf("%d",x);}
    }


int fact(int n) //算法功能是求解并返回n的阶乘
     {     
    if (n==0) return(1);   
       else  return(n*fact(n-1));
     }

void main()
{
 SeqStack *S;
 int x; 
 S=init_SeqStack( );
 Push_SeqStack(S,1);
 Push_SeqStack(S,2);
 Push_SeqStack(S,3);
 printf("%d",Top_SeqStack(S));
 Pop_SeqStack(S,&x);
 printf("\n%d",x);
 printf("\n%d",Top_SeqStack(S));
 Pop_SeqStack(S,&x);
 printf("\n%d",x);
 printf("\n%d",Top_SeqStack(S));
 printf("\n");
 conversion1(3467,8);
 printf("\n");
 conversion2(3467,8);
 printf("\n");
 printf("%ld",fact(4));
}

链队列

#include 
#include 
#define MAXSIZE 10
typedef int datatype;
typedef struct node
  { datatype data;
    struct node *next;
   }QNode;
typedef struct 
  { QNode *front, *rear;
   }LQueue;
LQueue *Init_LQueue()
  { LQueue *q;
	  QNode *p;
	  q=(LQueue*)malloc(sizeof(LQueue));
	  p=(QNode*)malloc(sizeof(QNode));
	  p->next=NULL;
	  q->front=q->rear=p;
	  return q;
   }
void In_LQueue(LQueue *q,datatype x)
  { QNode *p;
    p=(QNode*)malloc(sizeof(QNode));
    p->data=x;
    p->next=NULL;
    q->rear->next=p;
    q->rear=p;}
int Empty_LQueue(LQueue *q)
  {	if(q->front==q->rear) 
		  return 1;
	   else
		  return 0;
  }
int Out_LQueue(LQueue *q,datatype *x)
  { QNode *p;
	  if(Empty_LQueue(q)==1) return 0;
	  else { p=q->front->next;
		     q->front->next=p->next;
		     *x=p->data;
		     free(p);
		     if(q->front->next==NULL) q->rear=q->front;
		     return 1;	}
  }

void main()
  { LQueue *lq;
  int x;
  lq=Init_LQueue();
  printf("输入（-1结束）：");
  scanf("%d",&x);
  while (x!=-1)
  {In_LQueue(lq,x);
   scanf("%d",&x);}
  while (!Empty_LQueue(lq))
  {if(Out_LQueue(lq,&x)) printf("%d ",x);
   }
}

链栈

#include 
#include 
#define NULL 0
typedef int datatype;
typedef struct node 
        { datatype data; 
           struct node *next;
        }StackNode,*LinkStack;

LinkStack Init_LinkStack( )
    {
	return NULL;
    }
int Empty_LinkStack(LinkStack top)
    { if(top==NULL) return 1;
      else return 0; }
LinkStack Push_LinkStack(LinkStack top,datatype x)
  { StackNode *s;
    s=(StackNode*)malloc(sizeof(StackNode));
    s->data=x;	s->next=top;
    top=s; return top;
  }
LinkStack Pop_LinkStack(LinkStack top,datatype *x)
   { StackNode *p;
     if (top==NULL) return NULL;
     //if(Empty_LinkStack(top)) { printf("Stack Empty!");return NULL;}
     else{   *x=top->data;
	     p=top;
	     top=top->next;
	     free(p);
	     return top; }
    }
void main()
{ LinkStack top; 
int  x;
 top=Init_LinkStack( );
 top=Pop_LinkStack(top,&x);
 top=Push_LinkStack(top,1);
 top=Push_LinkStack(top,2);
 top=Push_LinkStack(top,3);
 top=Pop_LinkStack(top,&x);
 printf("%d ",x);
 top=Pop_LinkStack(top,&x);
 printf("%d ",x);
 top=Pop_LinkStack(top,&x);
 printf("%d ",x);
}