单链表的插入和删除实验报告

.

实验一、单链表的插入和删除

一、目的

了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。

二、要求：

建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。

三、程序源代码

#include"stdio.h"

#include"string.h"

#include"stdlib.h"

#include"ctype.h"

typedef struct node //定义结点

{

char data[10]; //结点的数据域为字符串

struct node *next; //结点的指针域

}ListNode;

typedef ListNode * LinkList; // 自定义LinkList单链表类型

LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表

ListNode *LocateNode(); //函数，按值查找结点

void DeleteList(); //函数，删除指定值的结点void printlist(); //函数，打印链表中的所有值

void DeleteAll(); //函数，删除所有结点，释放内存

//==========主函数==============

void main()

{

char ch[10],num[10];

LinkList head;

head=CreatListR1(); //用尾插入法建立单链表，返回头指针printlist(head); //遍历链表输出其值

printf(" Delete node (y/n):");//输入“y”或“n”去选择是否删除结点scanf("%s",num);

if(strcmp(num,"y")==0 || strcmp(num,"Y")==0){

printf("Please input Delete_data:");

scanf("%s",ch); //输入要删除的字符串

DeleteList(head,ch);

printlist(head);

}

DeleteAll(head); //删除所有结点，释放内存

}

//==========用尾插入法建立带头结点的单链表

===========

LinkList CreatListR1(void)

{

char ch[10];

LinkList head=(LinkList)malloc(sizeof(ListNode)); //生成头结点ListNode *s,*r,*pp;

r=head;

r->next=NULL;

printf("Input # to end "); //输入“#”代表输入结束

printf("Please input Node_data:");

scanf("%s",ch); //输入各结点的字符串

while(strcmp(ch,"#")!=0) {

pp=LocateNode(head,ch); //按值查找结点，返回结点指针

if(pp==NULL) { //没有重复的字符串，插入到链表中s=(ListNode *)malloc(sizeof(ListNode));

strcpy(s->data,ch);

r->next=s;

r=s;

r->next=NULL;

}

printf("Input # to end ");

printf("Please input Node_data:");

scanf("%s",ch);

}

return head; //返回头指针

}

//==========按值查找结点，找到则返回该结点的位置，否则返回NULL==========

ListNode *LocateNode(LinkList head, char *key)

{

ListNode *p=head->next; //从开始结点比较

while(p&&strcmp(p->data,key)!=0 ) //直到p为NULL或p-> data为key止

p=p->next; //扫描下一个结点

return p; //若p=NULL则查找失败，否则p指向找到的值key

的结点

}

//==========删除带头结点的单链表中的指定结点======= void DeleteList(LinkList head,char *key)

{

ListNode *p,*r,*q=head;

p=LocateNode(head,key); //按key值查找结点的

if(p==NULL ) { //若没有找到结点，退出

printf("position error");

exit(0);

}

while(q->next!=p) //p为要删除的结点，q为p的前结点

q=q->next;

r=q->next;

q->next=r->next;

free(r); //释放结点

}

//===========打印链表=======

void printlist(LinkList head)

{

ListNode *p=head->next; //从开始结点打印

while(p){

printf("%s, ",p->data);

p=p->next;

}

printf("\n");

}

//==========删除所有结点，释放空间===========

void DeleteAll(LinkList head)

{

ListNode *p=head,*r;

while(p->next){

r=p->next;

free(p);

p=r;

}

free(p);

}

运行结果：

加的添加结点的代码：

int Insert(ListNode *head) // the insert function {

ListNode *in,*p,*q;

int wh;

printf("input the insert node:");

in=(ListNode *)malloc(sizeof(ListNode));in->next=NULL;

p=(ListNode *)malloc(sizeof(ListNode));p->next=NULL;

q=(ListNode *)malloc(sizeof(ListNode));q->next=NULL;

if(!in)

return 0;

scanf("%s",in->data);

printf("input the place where you want to insert you data:");

scanf("%d",&wh);

for(p=head;wh>0;p=p->next,wh--);

q=p->next;

p->next=in;

in->next=q;

return 1;

}

运行结果：

最后提示为OK 添加成功。

实验心得：这个实验中主要修改的是ch 和num 把它们由指针改成数组因为不改的话在后面delect函数中会出现没有地址的情况找不到地址就不能执行功能然后把locate函数的判断语句改一下避免矛盾的出现。

实验二、二叉树操作

一、目的

掌握二叉树的定义、性质及存储方式，各种遍历算法。

二、要求

采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作。

三、程序源代码

#include"stdio.h"

#include"string.h"

#define Max 20 //结点的最大个数

typedef struct node{

char data;

struct node *lchild,*rchild;

}BinTNode; //自定义二叉树的结点类型

typedef BinTNode *BinTree; //定义二叉树的指针

int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数

//==========基于先序遍历算法创建二叉树==============

//=====要求输入先序序列，其中加入虚结点“#”以示空指针的位置

==========

BinTree CreatBinTree(void)

{

BinTree T;

char ch;

if((ch=getchar())=='#')

return(NULL); //读入#，返回空指针

else{

T=(BinTNode *)malloc(sizeof(BinTNode)); // 生成结点

T->data=ch;

T->lchild=CreatBinTree(); //构造左子树

T->rchild=CreatBinTree(); //构造右子树

return(T);

}

}

//========NLR 先序遍历=============

void Preorder(BinTree T)

{

if(T) {

printf("%c",T->data); //访问结点

Preorder(T->lchild); //先序遍历左子树

Preorder(T->rchild); //先序遍历右子树

}

}

//========LNR 中序遍历===============

void Inorder(BinTree T)

{

if(T) {

Inorder(T->lchild); //中序遍历左子树

printf("%c",T->data); //访问结点

Inorder(T->rchild); //中序遍历右子树

}

}

//==========LRN 后序遍历============

void Postorder(BinTree T)

{

if(T) {

Postorder(T->lchild); //后序遍历左子树

Postorder(T->rchild); //后序遍历右子树

printf("%c",T->data); //访问结点

}

}

//=====采用后序遍历求二叉树的深度、结点数及叶子数的递归算法========

int TreeDepth(BinTree T)

{

int hl,hr,max;

if(T){

hl=TreeDepth(T->lchild); //求左深度

hr=TreeDepth(T->rchild); //求右深度

max=hl>hr? hl:hr; //取左右深度的最大值

NodeNum=NodeNum+1; //求结点数

if(hl==0&&hr==0) leaf=leaf+1; //若左右深度为0，即为叶子。

return(max+1);

}

else return(0);

}

//====利用“先进先出”（FIFO）队列，按层次遍历二叉树==========

void Levelorder(BinTree T)

{

int front=0,rear=1;

BinTNode *cq[Max],*p; //定义结点的指针数组cq

cq[1]=T; //根入队

while(front!=rear)

{

front=(front+1)%NodeNum;

p=cq[front]; //出队

printf("%c",p->data); //出队，输出结点的值

if(p->lchild!=NULL){

rear=(rear+1)%NodeNum;

cq[rear]=p->lchild; //左子树入队

}

if(p->rchild!=NULL){

rear=(rear+1)%NodeNum;

cq[rear]=p->rchild; //右子树入队

}

}

}

//==========主函数=================

void main()

{

BinTree root;

int i,depth;

printf("\n");

printf("Creat Bin_Tree；Input preorder:"); //输入完全二叉树的先序序

列，

// 用#代表虚结点，如

ABD###CE##F##

root=CreatBinTree(); //创建二叉树，返回根结点

do { //从菜单中选择遍历方式，输入序号。

printf("\t********** select ************\n");

printf("\t1: Preorder Traversal\n");

printf("\t2: Iorder Traversal\n");

printf("\t3: Postorder traversal\n");

printf("\t4: PostTreeDepth,Node number,Leaf number\n");

printf("\t5: Level Depth\n"); //按层次遍历之前，先选择4，求出该树的结点数。

printf("\t0: Exit\n");

printf("\t*******************************\n");

scanf("%d",&i); //输入菜单序号（0-5）

switch (i){

case 1: printf("Print Bin_tree Preorder: ");

Preorder(root); //先序遍历

break;

case 2: printf("Print Bin_Tree Inorder: ");

Inorder(root); //中序遍历

break;

case 3: printf("Print Bin_Tree Postorder: ");

Postorder(root); //后序遍历

break;

case 4: depth=TreeDepth(root); //求树的深度及叶子数

printf("BinTree Depth=%d BinTree Node number=%d",depth,NodeNum);

printf(" BinTree Leaf number=%d",leaf);

break;

case 5: printf("LevePrint Bin_Tree: ");

Levelorder(root); //按层次遍历

break;

default: exit(1);

}

printf("\n");

} while(i!=0);

}

执行程序

1.先序遍历

2.中序遍历

3.后序遍历

4.结点数叶子数高度

5..层次遍历

自己设计的：

abdhl##m##i##e#jn###cf#ko###g##

1.预计先序遍历结果：abdhlmiejncfkog

2.预计中序遍历结果：lhmdibenjafokcg

3.预计后序遍历结果：lmhidnjebokfgca

4.结点数15 高度5 叶子数6

实际结果：

实验心得：这次实验主要是要让我们熟练树及其相关知识熟练掌握先序中序后序遍历，层次遍历然后我们自己画一个图会实现以上功能以及叶子数结点数还有高度的计算程序里面大量运用了递归以及队的应用，

实验三、图的遍历操作

一、目的

掌握有向图和无向图的概念；掌握邻接矩阵和邻接链表建立图的存储结构；掌握DFS及BFS对图的遍历操作；了解图结构在人工智能、工程等领域的广泛应用。

二、要求

采用邻接矩阵和邻接链表作为图的存储结构，完成有向图和无向图的DFS和BFS操作。

三、DFS和BFS 的基本思想

深度优先搜索法DFS的基本思想：从图G中某个顶点Vo出发，首先访问Vo，然后选择一个与Vo相邻且没被访问过的顶点Vi访问，再从Vi出发选择一个与Vi相邻且没被访问过的顶点Vj访问，……依次继续。如果当前被访问过的顶点的所有邻接顶点都已被访问，则回退到已被访问的顶点序列中最后一个拥有未被访问的相邻顶点的顶点W，从W出发按同样方法向前遍历。直到图中所有的顶点都被访问。

广度优先算法BFS的基本思想：从图G中某个顶点Vo出发，首先访问Vo，然后访问与Vo相邻的所有未被访问过的顶点V1，

V2，……，Vt；再依次访问与V1，V2，……，Vt相邻的起且未被访问过的的所有顶点。如此继续，直到访问完图中的所有顶点。

四、程序源代码

1．邻接矩阵作为存储结构的程序示例

#include"stdio.h"

#include"stdlib.h"

#define MaxVertexNum 100 //定义最大顶点数

typedef struct{

char vexs[MaxVertexNum]; //顶点表

int edges[MaxVertexNum][MaxVertexNum]; //邻接矩阵，可看作边表

int n,e; //图中的顶点数n和边数e

}MGraph; //用邻接矩阵表示的图的类型

//=========建立邻接矩阵=======

void CreatMGraph(MGraph *G)

{

int i,j,k;

char a;

printf("Input VertexNum(n) and EdgesNum(e): ");

scanf("%d,%d",&G->n,&G->e); //输入顶点数和边数

scanf("%c",&a);

printf("Input Vertex string:");

for(i=0;in;i++)

{

scanf("%c",&a);

G->vexs[i]=a; //读入顶点信息，建立顶点表

}

for(i=0;in;i++)

for(j=0;jn;j++)

G->edges[i][j]=0; //初始化邻接矩阵

printf("Input edges,Creat Adjacency Matrix\n");

for(k=0;ke;k++) { //读入e条边，建立邻接矩阵

scanf("%d%d",&i,&j); //输入边（Vi，Vj）的顶点序号

G->edges[i][j]=1;

G->edges[j][i]=1; //若为无向图，矩阵为对称矩阵；若建立有向图，去掉该条语句

}

}

//=========定义标志向量，为全局变量=======

typedef enum{FALSE,TRUE} Boolean;

Boolean visited[MaxVertexNum];

//========DFS：深度优先遍历的递归算法======

void DFSM(MGraph *G,int i)

{ //以Vi为出发点对邻接矩阵表示的图G进行DFS搜索，邻接矩阵是