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

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

一、目的

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

二、要求：

建立一个数据域定义为字符串的单链表，在链表中不允许有重复

的字符串；根据输入的字符串，先找到相应的结点，后删除之。

三、程序源代码

#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 CreatListR1();

带头结点的单链表

// 定义结点

// 结点的数据域为字符

串

// 结点的指针域

自定义LinkList 单链表类型函数，用尾插入法建

}

// 函数，按值查找结点

// 函数，删除指定值的结点

// 函数，打印链表中的所有值

// 函数，删除所有结点，释放内存

//========== 主函数 ============== 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);

}

ListNode *LocateNode(); void DeleteList(); void printlist(); void DeleteAll();

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);

you printf("input the place where you want to insert 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->lchil d);

Preorder(T->rchil d);

// 先序遍历左子

树

// 先序遍历右子

树

}

}

//========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; return(max+1);

}

else return(0);

}

//==== 利用 “先 进 先出

void Levelorder(BinTree T)

{

int front=0,rear=1; BinTNode *cq[Max],*p; // 定义结点的指针数组 cq

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

FIFO ) // 求左深度 // 求右深度

// 取左右深度的最大值

// 求结点数

// 若左右深度为 0 ，即为叶子

队列，按层次遍历二叉树

//

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:"); // 输入完全二叉树

的先序序列，

// 用 # 代 表 虚 结 点 ， 如

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 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); // 中序遍历

root=CreatBinTree();

// 创建二叉树，返回根结点 do {

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

ABD###CE##F##

printf("\t selec

t

\n"); \n");

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. 先序遍历