关于单链表，二叉树，图，查找和排序的软件编程

课程名称：计算机软件

使用软件：devcpp

注意：这里列出了关于单链表，二叉树，图，查找和排序的编程，全部程序由博主一人编写，会有瑕疵，谨慎使用。

1.单链表

要求：(1)建立单向链表，表长任意；

           (2)可交互输出单链表中的内容；

           (3)编写算法计算出自己所建单链表的长度并输出；

           (4)删除自己所建单链表中的第K个结点，并将剩余结点输出；

           (5)将单链表倒排，输出结果。

程序：

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

//定义链表中的节点 
struct node
{  unsigned char data;//链表中的数据 
   struct node * next;//指向下一节点的指针 
};

//变量定义
struct node  *p,*p1,*p2,*head;

//函数声明
void ListCreate();
void ListTraverse();
void ListLength();
int ListDelete();
int ListReverse();

//主函数 
int main()
{
 ListCreate();        //单向链表的建立
 ListTraverse();      //单向链表的输出
 ListLength();        //单向链表长度计算
 ListDelete();        //单向链表结点的删除
 ListReverse();      //单链表的倒排 
}

//单向链表的建立
void ListCreate()
{   
    head=p=(struct node * )malloc(sizeof(struct node));
 printf("请输入链表数据元素值(0为结束标志,中间不能用任何符号)： "); 
    scanf("%c",&p->data);//头结点的数据成员 
    while(p->data!='0')//给出0结束条件,退出循环
    {   
   p1=p; 
      p=(struct node * )malloc(sizeof(struct node)); 
      scanf("%c",&p->data);//中间结点数据成员
      p1->next=p;//中间结点的指针成员值
    } 
    p->next=NULL;//尾结点的指针成员值 
}

//单向链表的输出
void ListTraverse()
{ 
    p=head;
    printf(" 链表数据成员是："); 
    while(p->next!=NULL) 
    { 
      printf("%c  ",p->data);  //输出成员数据
      p=p->next; 
    }   
}

//单向链表长度计算
void ListLength()
{
    p2=head->next;
    int  j=1;            //j用来存放链表的长度
    while((p2->data)-48)
    {
      p2=p2->next;
      j++;
    }
    printf(" 链表长度是:  %d",j);
}

//单向链表结点的删除
int ListDelete()
{
    p2 = head;

    int j = 1,M,K;
   
    printf(" 要删除第几个节点: ");
 scanf("%d",&K);

    if ( j > (K-1)) //删除头节点
   {
      struct node  *p3;
      p3=p2;
      p2=p3->next;
    }
    else   //删除其它节点
    {
    while ((p2->next)-48 && j < (K-1))
 {
        p2 = p2->next;
        ++j;
    }
     if (p2->next == NULL )
 {
        printf("Position Error ");
        return 0;
    }
    struct node *temp = p2->next;  //执行删除操作
    p2->next = temp->next;
    }   
    p=head;
    printf("删除后的链表数据成员是："); 
    while(p->next!=NULL) 
    { 
      printf("%c  ",p->data);  //输出成员数据
      p=p->next; 
    } 
}

//单链表的倒排
int ListReverse()
{
    struct node *h,*h1,*h2;
    h=head;
    h1=h;                    
    h=NULL;
    while(h1->next!=NULL)      //通过循环使h从最后一个元素依次向前
    { 
        h2 = h1->next; 
        h1->next = h; 
        h = h1; 
        h1 = h2;
    }  
    printf(" 倒排后的链表数据成员是："); 
    while(h!=NULL)  //输出数据元素
    { 
      printf("%c  ",h->data); 
      h=h->next; 
    }  
}

难点：单链表的倒排，这里有两种方法实现

1）逆序单链表的循环算法：

 1 LINK_NODE *ReverseLink(LINK_NODE *head)
 2     {
 3         LINK_NODE *next;
 4         LINK_NODE *prev = NULL;
 5     
 6         while(head != NULL)
 7         {
 8             next = head->next;
 9             head->next = prev;
10             prev = head;
11             head = next;
12         }
13     
14         return prev;
15     }

2）逆序单链表的递归算法：

 1 LINK_NODE *ReverseLink2(LINK_NODE *head)
 2    {
 3         LINK_NODE *newHead;
 4     
 5         if((head == NULL) || (head->next == NULL))
 6             return head;
 7     
 8         newHead = ReverseLink2(head->next); /*递归部分*/
 9         head->next->next = head; /*回朔部分*/
10         head->next = NULL;
11     
12         return newHead;
13    }

循环还是递归？这是个问题。当面对一个问题的时候，不能一概认为哪种算法好，哪种不好，而是要根据问题的类型和规模作出选择。对于线性数据结构，比较适合用迭代循环方法，而对于树状数据结构，比如二叉树，递归方法则非常简洁优雅。原文链接：https://blog.csdn.net/lycnjupt/article/details/47103433

如果想了解关于逆序单链表的其它实现方法，可以查看链接：

http://blog.sina.com.cn/s/blog_68e4d2910100tc0i.html

2.二叉树

要求：(1)动态交互建立二叉树，结点个数任意；

           (2)分别用DLR,LDR,LRD三种方式对二叉树进行遍历，并输出结果；

           (3)计算二叉树中的结点个数并输出；

           (4)计算二叉树的深度并输出。

我自己的程序:

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

//节点声明，数据域、左指针、右指针
typedef struct BiTNode
{
   int data;//二叉树数据元素
   struct BiTNode *Left,*Right;//二叉树左右指针
}BiTNode,*BiTree;

//函数声明
int CreateBiTree(BiTNode **T);
void DLR_BiTree(BiTNode *T);
void LDR_BiTree(BiTNode *T);
void LRD_BiTree(BiTNode *T);
int BiTreeCount(BiTNode *T);
int BiTreeDeep(BiTNode *T);

//主函数
int main()
{
   BiTree T;
   int depth,Count = 0;
  
   printf("请输入第一个节点的值(0表示没有该节点)： ");
   CreateBiTree(&T);//二叉树建立
   printf(" ");
  
   printf("先序遍历二叉树：");
   DLR_BiTree(T);//二叉树先序遍历
   printf(" ");
  
   printf("中序遍历二叉树：");
   LDR_BiTree(T);//二叉树中序遍历
   printf(" ");
  
   printf("后序遍历二叉树：");
   LRD_BiTree(T);//二叉树后序遍历
   printf(" ");
  
   Count = BiTreeCount(T);//求二叉树结点个数  
   printf("二叉树结点个数：%d ",Count); 
  
   depth = BiTreeDeep(T);//求二叉树深度 
   printf("二叉树的深度为：%d ",depth);
}

//先序创建二叉树 
int CreateBiTree(BiTNode **T) 
{ 
    int ch; 
    scanf("%d",&ch);//给二叉树第一个节点赋值 
    if (ch == 0) 
    { 
        *T = NULL;  //输入为0表示没有该节点
        return 0; 
    } 
    else 
    { 
        *T = (BiTNode *)malloc(sizeof(BiTNode));  //给二叉树节点分配内存
        if (T == NULL) 
        { 
            printf("failed "); 
            return 0; 
        } 
        else 
        { 
            (*T)->data = ch; 
            printf("输入%d的左子节点：",ch); 
            CreateBiTree(&((*T)->Left));  //递归给二叉树左节点赋值
            printf("输入%d的右子节点：",ch); 
            CreateBiTree((&(*T)->Right)); //递归给二叉树右节点赋值
        } 
    } 
 
    return 1; 
}

//二叉树先序遍历
void DLR_BiTree(BiTNode *T)
{
 if( T == NULL) return;//递归调用的结束条件
 printf("%d",T->data);//访问节点的数据域
 DLR_BiTree(T->Left);//先序递归遍历左子树
 DLR_BiTree(T->Right);//先序递归遍历右子树
}

//二叉树中序遍历
void LDR_BiTree(BiTNode *T)
{
 if(T==NULL) return;//递归调用的结束条件
 LDR_BiTree(T->Left);//中序递归遍历左子树
 printf("%d",T->data);//访问节点的数据域
 LDR_BiTree(T->Right);//中序递归遍历右子树
}

//二叉树后序遍历
void LRD_BiTree(BiTNode *T)
{
 if(T==NULL) return;//递归调用的结束条件
 LRD_BiTree(T->Left);//后序递归遍历左子树
 LRD_BiTree(T->Right);//后序递归遍历右子树
 printf("%d",T->data);//访问节点的数据域
}

//求二叉树结点个数
int BiTreeCount(BiTNode *T)
{
    if(T==NULL)
        return 0;//空二叉树结点数为0
    else                           
        return BiTreeCount(T->Left)+BiTreeCount(T->Right)+1;//左右子树结点总数加1
}
 
//求二叉树深度
int BiTreeDeep(BiTNode *T) 
{ 
    int deep = 0; 
    if (T != NULL) 
    { 
        int leftdeep = BiTreeDeep(T->Left);//递归得到左子树深度 
        int rightdeep = BiTreeDeep(T->Right);//递归得到右子树深度
        deep = leftdeep >= rightdeep?leftdeep+1:rightdeep+1;//比较得到二叉树深度 
    } 
 
    return deep; 
} 

3.图

要求：(1)根据教材上算法，完成图的深度和广度优先遍历，要求任意给定起始点，输出结果。

          (2)根据教材上算法，完成图的单元最短路径的算法，要求任意给定源点，输出结果。

程序：

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

#define MAXVEX  100                      //最大顶点数  
#define INFINITY 65535                //用65535来代表无穷大  

//定义访问标记 
int visited[MAXVEX]={0};  
  
//定义图结构体  
typedef struct  
{  
    char vexs[MAXVEX];                //顶点表  
    int  arc[MAXVEX][MAXVEX];         //邻接矩阵，可看作边  
    int  numVertexes, numEdges;       //图中当前的顶点数和边数  
}Graph;   

//辅助数组中的元素定义  
typedef struct 
{  
    int distance;  
    int path[MAXVEX];  
}ArrayNode;

//函数声明
void CreateGraph(Graph *g);
void DFS(Graph g,int v);
void BFS(Graph g,int v);
void SHORT(Graph *g,int from,int to);
void SHORT(Graph *g,int from,int to);

//主函数 
int main()
{
	Graph g;
	int i,from,to;
	printf("t为1-4,分别表示无向图、有向图、带权无向图、带权有向图
");
    CreateGraph(&g);//创建图 
    
    printf("
输入遍历起点: ");  
    scanf("%d",&i);  
    printf("
深度优先搜索遍历：");
    DFS(g,i);//深度优先遍历函数 
    printf("NULL
");
    
    printf("广度优先搜索遍历："); 
    BFS(g,i);//广度优先遍历函数 
    printf("NULL
");
    
    printf("
Dijkstra算法单元最短路径：");
    printf("
请输入起点和终点（中间用空格）：");
    scanf("%d %d",&from,&to);
    SHORT(&g,from,to);//Dijkstra算法单元最短路径函数	
}
  
//创建图  
void CreateGraph(Graph *g)  
{    
     int i,j,k,w,t;  
     printf("输入顶点数，边数和t（中间用空格）:");  
     scanf("%d %d %d", &(g->numVertexes), &(g->numEdges),&t);  
     printf("
");  
     for(i=1;i<=g->numVertexes;i++)//通过循环输入顶点信息  
     {  
     getchar();  
     printf("输入第%d顶点信息vexs[%d]=",i,i);  
     scanf("%c",&(g->vexs[i]));  
     }  
     printf("
");  
     for(i=1;i<=g->numVertexes;i++)  
        for(j=1;j<=g->numVertexes;j++)  
                if (t>2)    g->arc[i][j] = INFINITY;//区别是否带权值  
                else        g->arc[i][j]=0;   
     for(k=1;k<=g->numEdges;k++)//通过循环输入边的信息  
           {  
            printf("输入有联系的两个顶点（中间用空格）:");  
            scanf("%d %d",&i,&j);  
            if(i>g->numVertexes ||j>g->numVertexes)  exit(0);  
            if(t>2)  
            {  
                  printf("输入权值:");  
                  scanf("%d",&w);  
                  g->arc[i][j]=w;  
                  if(t==3)  g->arc[j][i]=w;  
            }  
            else  
            {     g->arc[i][j]=1;  
                  if (t==1)    g->arc[j][i]=1;  
            }  
     }  
     printf("
");  
     printf("输出邻接矩阵:
");  
     for(i=1;i<=g->numVertexes ;i++)  
     {  
     for(j=1;j<=g->numVertexes ;j++)  
     {  
     printf("%8d",g->arc[i][j]);  //输出邻接矩阵 
       
     /*if(t>2&&g->arc[i][j]==65535)  
       g->arc[i][j]=0;  
     else if(t>2&&g->arc[i][j]!=65535)  
              g->arc[i][j]=1; */ 
     }  
      printf("
");  
     }  
}  

//深度优先遍历
void DFS(Graph g,int v)
{
    int j;  
    printf("%d->",v);         //输出访问顶点  
    visited[v]=1;            //全局数组访问标记置1表示已经访问  
    for(j=1; j<=g.numVertexes; j++)  
       if ((g.arc[v][j]!=0)&&(g.arc[v][j]!=65535)&&(!visited[j]))  
            DFS (g,j);//递归访问非0非无穷顶点 
} 

//广度优先遍历
void BFS(Graph g,int v)
{
	int  q[g.numVertexes+1] ;  
    int  i,f,r,j ;
	for(i=0;i<g.numVertexes;i++)
	visited[i]=0;  //重置访问标记 
    f=r=0 ;  
    printf("%d->",v);//输出第一个顶点  
    visited[v]=1 ;//标记已访问  
    r++;  
    q[r]=v;  
    while (f<r)  
    {    
	  f++; 
	  v=q[f];  
      for (j=1; j<=g.numVertexes; j++) //广度优先遍历依次访问与上一顶点有联系的点 
        {
		if ((g.arc[v][j]!=0)&&(g.arc[v][j]!=65535)&&(!visited[j]))  
        {       
		    printf("%d->",j);//输出访问顶点 
		    visited[j]=1 ;     
		    r++; 
	    	q[r]=j ;  
		}
		}  
    }  
} 

//单元最短路径算法
void SHORT(Graph *g,int from,int to)
{
	int i,j,index=-1;  
    int n=1;//记录已经求出的两个点之间的最短距离的个数  
    ArrayNode shortestPath[MAXVEX];  
    int flag[MAXVEX]={0};//标记，为1表示到这个顶点的最短距离已求出  
   
    //1.求from到各个顶点的直接距离，即初始化shortestPath数组  
    for(i=1;i<=g->numVertexes;i++)
	{  
        if(from==i)
		{  
            shortestPath[i].distance=0;  
            shortestPath[i].path[0]=i;  
            flag[from]=1;  
        }  
        else if(g->arc[from][i]>0)
		{  
            shortestPath[i].path[0]=from;  
            shortestPath[i].path[1]=i;  
            shortestPath[i].distance=g->arc[from][i];  
        }
		else 
            shortestPath[i].distance=INFINITY;  
    }  
    //2.每次求一个最短路径  
    while(n<=g->numVertexes)
	{  
        //选择shortestPath中距离最小的，求出from到这个顶点的最短路径  
        index=-1;  
        for(i=1;i<=g->numVertexes;i++)
		{  
            if(i==from)  
                continue;  
            if(flag[i]==0 && index==-1 && shortestPath[i].distance!=INFINITY)  
                index=i;  
            if(flag[i]==0 && index!=-1 && shortestPath[i].distance<shortestPath[index].distance)  
                index=i;  
        }  
        flag[index]=1;  
        //修改到各个顶点的最短路径  
        for(i=1;i<=g->numVertexes;i++)
		{  
            if(i==from)  
                continue;  
            if(g->arc[index][i]>0 && g->arc[index][i]+shortestPath[index].distance<shortestPath[i].distance)
			{  
                shortestPath[i].distance=g->arc[index][i]+shortestPath[index].distance;  
                //修改路径  
                j=0;  
                while(1)
				{  
                    shortestPath[i].path[j]=shortestPath[index].path[j];  
                    if(shortestPath[index].path[j]==index)  
                        break;  
                    j++;  
                }  
                shortestPath[i].path[j+1]=i;  
            }  
        }  
        n++;  
    }  
    //输出from到to的最短路径及长度  
    if(shortestPath[to].distance==INFINITY){  
        printf("%d到%d没有路径
",from,to);  
        return;  
    }  
    printf("%d到%d的最短路径长度是：%d
",from,to,shortestPath[to].distance);  
    printf("经过的顶点：  ");  
    i=0;  
    while(1){  
        printf("%-3d",shortestPath[to].path[i]);  
        if(shortestPath[to].path[i]==to)  
            break;  
        i++;  
    }  
    printf("
");
} 

4.查找和排序

要求：(1)任意给定无序序列，用对半检索法，交互检索任意给定的关键字KEY；

           (2)任意给定无序序列，用快速排序法对序列进行排序，并统计交换次数；

           (3)任意给定无序序列，用冒泡排序法对序列进行排序，并统计交换次数和排序趟数。

程序：

#include "stdio.h"
#define N 6//序列长度(可修改)

//函数声明 
int halfSort(int *b,int n); 
void quickSort(int *b,int l,int r);
void bubbleSort(int *bb,int r);

//全局变量定义 
int o,p,k;
int KEY; //检索的关键字 

//主函数 
int main()
{
	int i,j,q;
	int a[100],aa[100],aaa[100];//以数组方式定义序列 
	printf("Hello World!
");
	
	printf("
1.请输入任意序列(用回车隔开)
");
	for(i=1;i<=N;i++)
	scanf("%d",&a[i]);//输入无序序列 
	quickSort(a,1,N);//先排序再进行对半检索
	printf("排序后序列为：");
	for(j=1;j<=N;j++)
	printf("%d ",a[j]);//输出有序序列 
	printf("
请输入需要检索的关键字KEY:"); 
	scanf("%d ",&KEY);
    q=halfSort(a,N);//对半检索函数调用 
    printf("对半检索-关键字位置为：%d
",q);
    
    printf("
2.请输入任意序列(用回车隔开)
");
	for(i=0;i<N;i++)
	scanf("%d",&aa[i]);//输入无序序列 
    quickSort(aa,0,N-1);//快速排序函数调用 
    printf("快速排序后序列为：");
	for(j=0;j<N;j++)
	printf("%d ",aa[j]);//输出有序序列 
	printf("
交换次数为：%d
",k);
	
	printf("
3.请输入任意序列(用回车隔开)
");
	for(i=0;i<N;i++)
	scanf("%d",&aaa[i]);//输入无序序列 
	bubbleSort(aaa,N);
	printf("冒泡排序后序列为：");//冒泡排序函数调用 
	for(j=0;j<N;j++)
	printf("%d ",aaa[j]);//输出有序序列 
	printf("
交换次数为：%d
",o);
	printf("排序趟数为：%d
",p);
	
	return 0; 
}

//对半检索函数 
int halfSort(int *b,int n)
{
	int high,mid,low;
	int rs=0;
	low=1;high=n;//初始状态 
	while(low<=high)//判断查找是否结束 
	{
		mid=(low+high)/2;
		if(KEY<b[mid]) high=mid-1;//关键字在前半区 
		else
		if(KEY>b[mid]) low=mid+1;//关键字在后半区 
		else {rs=mid;break;}
	}
	return rs;
}

//快速排序函数 
void quickSort(int *bb,int l,int r)
{
   int m,n;
   int temp;
   if(l>=r) return;//只有一个记录或无记录，无须排序 
   m=l;
   n=r;
   temp=bb[m];
   while(m!=n)//寻找temp的最终位置 
   {
   while((bb[n]>=temp)&&(n>m))
   n--;//从右向左扫描，查找第一个小于temp的记录 
   if(m<n)
   {bb[m++]=bb[n];k++;}
   while((bb[m]<=temp)&&(n>m))
   m++;//从左向右扫描，查找第一个大于temp的记录 
   if(m<n)
   {bb[n--]=bb[m];k++;}
   }
   bb[m]=temp;//找到temp的最终位置 
   quickSort(bb,l,m-1);//递归处理左区间 
   quickSort(bb,m+1,r);//递归处理右区间 
}

//冒泡排序函数 
void bubbleSort(int *bbb,int r)
{
	int m,n,noswap;
	int temp;
	for(m=0;m<(r-1);m++)//外循环，做N-1次起泡 
	{
		noswap=1;
		for(n=0;n<(r-m-1);n++)//内循环，置交换标志 
		if(bbb[n+1]<bbb[n])//比较 
		{
			temp=bbb[n];
			bbb[n]=bbb[n+1];
			bbb[n+1]=temp;//交换 
			o++;
			noswap=0;
		}
		if(noswap) break;//本趟起泡未发生记录交换，算法结束 
		p++;
	}
}