数据结构实验

最新推荐文章于 2022-08-06 16:47:24 发布

技术搬砖工

最新推荐文章于 2022-08-06 16:47:24 发布

阅读量1.5k

点赞数

分类专栏：数据结构实验文章标签：面试题数据结构线性表结构

本文链接：https://blog.csdn.net/hephec/article/details/26617599

版权

数据结构实验专栏收录该内容

4 篇文章 0 订阅

订阅专栏

实验一链表的插入和删除
一、实验内容：

1.初始化链表L

2.销毁链表L

3.清空链表L

4.求链表L的长度

5.判链表L空否。

6.通过e返回链表L中第i个数据元素的内容

7.在链表L中检索值为e的数据元素

8.返回链表L中结点e的直接前驱结点

9.返回链表L中结点e的直接后继结点

10.在链表L中第i个数据元素之前插入数据元素e

11.将链表L中第i个数据元素删除，并将其内容保存在e中。

二、实验环境：

1.硬件环境

计算机一台

2.软件环境

Microsoft Visual Studio 2008集成开发环境

Windows操作系统(WindowsXP、Windows7、Windows Server 2008)

三、实验步骤：

#include <iostream>

using namespace std;

//实现线性表的链式存储结构的类型定义

typedef int Elemtype;

#define OK 1;

#define ERROR -1;

struct NODE //结点类型

{

Elemtype elem;

NODE *next;

};

struct LINK_LIST //链表类型

{

NODE *head;

};

//典型操作的算法实现

//初始化链表L

int InitList(LINK_LIST *L)

{

L->head = (NODE*)malloc(sizeof(NODE)); //为头结点分配存储单元

if (L->head) {L->head->next=NULL; return OK;}

else return ERROR ;

}

//销毁链表L

void DestoryList(LINK_LIST *L)

{

NODE *p;

while (L->head) //依次删除链表中的所有结点

{

p=L->head; L->head=L->head->next;

free(p);

}

//清空链表L

void ClearList(LINK_LIST *L)

{

NODE *p;

while (L->head->next){ //p指向链表中头结点后面的第一个结点

p=L->head->next;

L->head->next=p->next; //删除p结点

free(p); //释放p结点占据的存储空间

}

//求链表L的长度

int ListLength(LINK_LIST L)

{

NODE *p;

int len;

len=0;

for(p=L.head;p->next!=NULL; p=p->next)

len++ ;

return(len);

}

// 判链表L空否。

int IsEmpty(LINK_LIST L)

{

if (L.head->next==NULL) return true;

else return false;

}

//（）通过e返回链表L中第i个数据元素的内容

void GetElem(LINK_LIST *L,int i,Elemtype *e)

{

NODE *p;

int j;

if (i<1||i>ListLength(*L))

exit(-1); //检测i值的合理性

for (p=L.head,j=0; j!=i; p=p->next,j++);

p = L->head;

for (j=0; j<i; j++) //寻找第i-1个结点

p=p->next;

*e=p->elem; //将第i个结点的内容赋给e指针所指向的存储单元中

}

//在链表L中检索值为e的数据元素

NODE *LocateELem(LINK_LIST L,Elemtype e)

{

NODE *p;

for (p=L.head->next;p&&p->elem!=e;p=p->next); //寻找满足条件的结点

return(p);

}

//返回链表L中结点e的直接前驱结点

NODE *PriorElem(LINK_LIST L,NODE* e)

{

NODE *p;

if (L.head->next==e) return NULL; //检测第一个结点

for (p=L.head;p->next&&p->next!=e;p=p->next);

if (p->next==e) return p;

else return NULL;

}

//返回链表L中结点e的直接后继结点

NODE *NextElem(LINK_LIST L,NODE* e)

{

NODE *p;

for(p=L.head->next;p&&p!=e;p=p->next);

if (p) p=p->next;

return p;

}

//在链表L中第i个数据元素之前插入数据元素e

int ListInsert(LINK_LIST *L,int i,Elemtype e)

{

NODE *p,*s;

if (i<1||i>ListLength(*L)+1) return ERROR;

p=L->head;

for (int j=0; j<i-1; j++) //寻找第i-1个结点

p=p->next;

s=(NODE*)malloc(sizeof(NODE));

if (s==NULL) return ERROR;

s->elem=e;

s->next=p->next; p->next=s; //将s结点插入

return OK;

}

//将链表L中第i个数据元素删除，并将其内容保存在e中。

int ListDelete(LINK_LIST *L,int i,Elemtype *e)

{

NODE *p, *s;

if (i<1||i>ListLength(*L)) return ERROR; //检查i值的合理性

p=L->head;

for(int j=0;j<i-1;j++) //寻找第i-1个结点

p=p->next;

s=p->next; //用s指向将要删除的结点

p->next=s->next; //删除s指针所指向的结点

*e=s->elem;

free(s);

return OK;

}

void main()

{

LINK_LIST NL;

InitList(&NL);

cout<< IsEmpty(NL)<<endl;

int a,b;

a = 11;

ListInsert(&NL,1,a);

a=21;

ListInsert(&NL,1,a);

a=31;

ListInsert(&NL,1,a);

cout<< IsEmpty(NL)<<endl;

GetElem(&NL,1,&b);

cout<< b <<endl;

GetElem(&NL,2,&b);

cout<< b<<endl;

GetElem(&NL,3,&b);

cout<< b<<endl;

ListDelete(&NL,1,&a);

GetElem(&NL,1,&b);

cout<< b <<endl;

DestoryList(&NL);

getchar();

}

实验二多项式相加
一、实验内容：

1.建立多项式链表数据结构

2.生成结点并插入链表

3.释放结点

4.初始化多项式链表

5.创建链表

6.销毁链表

7.在头结点插入数据

8.在头结点删除数据

9.在尾结点添加数据

10.打印多项式

11.多项式加法函数

二、实验环境：

1.硬件环境

计算机一台

2.软件环境

Microsoft Visual Studio 2008集成开发环境

Windows操作系统(WindowsXP、Windows7、Windows Server 2008)

三、实验步骤：

#include <iostream>

using namespace std;

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

typedef int Status;

//项结点数据结构

typedef struct

{

float coef;

int expn;

}term,ElemType;

typedef struct LNode

{

ElemType data;

LNode *next;

}*Link,*Position;

//多项式链表数据结构

struct LinkList

{

Link head;

Link tail;

int len;

};

typedef LinkList polynomial;

//生成结点并插入链表

void MakeNode(Link &p,ElemType e)

{

p=(Link)malloc(sizeof(LNode));

if(!p)

{

exit(ERROR);

}

p->data=e;

}

//释放结点

void FreeNode(Link &p)

{

free(p);

p=NULL;

}

//初始化多项式链表

void InitList(LinkList &L)

{

Link p;

p=(Link)malloc(sizeof(LNode));

if(p)

{

p->next=NULL;

L.head=L.tail=p;

L.len=0;

}

else

{

exit(ERROR);

}

//创建链表

void ClearList(LinkList &L)

{

Link p,q;

if(L.head!=L.tail)

{

p=q=L.head->next;

L.head->next=NULL;

while(p!=L.tail)

{

p=q->next;

free(q);

q=p;

}

free(q);

L.tail=L.head;

L.len=0;

}

//销毁链表

void DestroyList(LinkList &L)

{

ClearList(L);

FreeNode(L.head);

L.tail=NULL;

L.len=0;

}

//头结点插入数据

void InsFirst(LinkList &L,Link h,Link s)

{

s->next=h->next;

h->next=s;

if(h==L.tail)

{

L.tail=h->next;

}

L.len++;

}

//头结点删除数据

Status DelFirst(LinkList &L,Link h,Link &q)

{

q=h->next;

if(q)

{

h->next=q->next;

if(!h->next)

{

L.tail=h;

}

L.len--;

return OK;

}

else

return FALSE;

}

void Append(LinkList &L,Link s)

{

int i=1;

L.tail->next=s;

while(s->next)

{

s=s->next;

i++;

}

L.tail=s;

L.len+=i;

}

ElemType GetCurElem(Link p)

{

return p->data;

}

Status ListEmpty(LinkList L)

{

if(L.len)

return FALSE;

else

return TRUE;

}

Position GetHead(LinkList L)

{

return L.head;

}

Position NextPos(Link p)

{

return p->next;

}

Status LocateElem(LinkList L,ElemType e,Position &q,int (*compare)(ElemType,ElemType))

{

Link p=L.head,pp;

{

pp=p;

p=p->next;

}

while(p&&(compare(p->data,e)<0));

if(!p||compare(p->data,e)>0)

{

q=pp;

return FALSE;

}

else

{

q=p;

return TRUE;

}

int cmp(term a,term b)

{

if(a.expn==b.expn)

return 0;

else

return (a.expn-b.expn)/abs(a.expn-b.expn);

}

void CreatPolyn(polynomial &P,int m)

{

Position q,s;

term e;

int i;

InitList(P);

printf("请依次输入%d个系数,指数\n",m);

for(i=1;i<=m;i++)

{

scanf("%f",&e.coef);

getchar();

scanf("%d",&e.expn);

getchar();

if(!LocateElem(P,e,q,cmp))

{

MakeNode(s,e);

InsFirst(P,q,s);

}

//打印多项式

void PrintPolyn(polynomial P)

{

Link q;

q=P.head->next;

while(q)

{

cout<<q->data.coef<<"x^"<<q->data.expn;

q=q->next;

if (q) cout<<"+";

}

//加法函数

void AddPolyn(polynomial &Pa,polynomial &Pb)

{

Position ha,hb,qa,qb;

term a,b;

ha=GetHead(Pa);

hb=GetHead(Pb);

qa=NextPos(ha);

qb=NextPos(hb);

while(!ListEmpty(Pa)&&!ListEmpty(Pb)&&qa)

{

a=GetCurElem(qa);

b=GetCurElem(qb);

switch(cmp(a,b))

{

case -1:ha=qa;

qa=NextPos(ha);

break;

case 0:qa->data.coef+=qb->data.coef;

if(qa->data.coef==0)

{

DelFirst(Pa,ha,qa);

FreeNode(qa);

}

else

ha=qa;

DelFirst(Pb,hb,qb);

FreeNode(qb);

qb=NextPos(hb);

qa=NextPos(ha);

break;

case 1:

DelFirst(Pb,hb,qb);

InsFirst(Pa,ha,qb);

ha=ha->next;

qb=NextPos(hb);

}

if(!ListEmpty(Pb))

{

Pb.tail=hb;

Append(Pa,qb);

}

DestroyList(Pb);

}

void main()

{

polynomial p,q;

int m;

printf("请输入第一个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(p,m);

printf("请输入第二个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(q,m);

AddPolyn(p,q);

printf("两个一元多项式相加的结果\n");

PrintPolyn(p);

getchar();

}

实验三二叉树的遍历
一、实验内容：

1.构造空二叉树T

2.按层序次序输入二叉树中结点的值

3.返回二叉树是否为空

4.返回二叉树深度

5.若e是T的非根结点,则返回二叉树的双亲

6.返回二叉树的左孩子

7.返回二叉树的右兄弟

8.先序遍历T,对每个结点调用函数Visit一次且仅一次

9.中序遍历T,对每个结点调用函数Visit一次且仅一次

10.后序遍历T,对每个结点调用函数Visit一次且仅一次

11.逐层输出二叉树

二、实验环境：

1.硬件环境

计算机一台

2.软件环境

Microsoft Visual Studio 2008集成开发环境

Windows操作系统(WindowsXP、Windows7、Windows Server 2008)

三、实验步骤：

#include <math.h>

#include <iostream>

using namespace std;

typedef char TElemType;

// 二叉树的顺序存储表示

#define MAX_TREE_SIZE 100 // 二叉树的最大结点数

typedef TElemType SqBiTree[MAX_TREE_SIZE]; // 0号单元存储根结点

typedef struct

{

int level, //结点的层

order; //本层序号(按满二叉树计算)

}position;

typedef int QElemType;

// 队列的顺序存储结构(可用于循环队列和非循环队列)

#define MAXQSIZE 5 // 最大队列长度(对于循环队列，最大队列长度要减)

typedef struct

{

QElemType *base; // 初始化的动态分配存储空间相当于一个数组

int front; // 头指针,若队列不空,指向队列头元素，相当于一个数组下标

int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置

// 相当于一个数组下标

}SqQueue;

#define ClearBiTree InitBiTree // 在顺序存储结构中，两函数完全一样

TElemType Nil = ' '; // 设空为字符型的空格符

// 构造空二叉树T。因为T是固定数组，不会改变，故不需要&

int InitBiTree(SqBiTree T)

{

int i;

for(i=0;i<MAX_TREE_SIZE;i++)

T[i]=Nil; // 初值为空

return 1;

}

void DestroyBiTree()

{

// 由于SqBiTree是定长类型,无法销毁

}

// 按层序次序输入二叉树中结点的值(字符型或整型), 构造顺序存储的二叉树T

int CreateBiTree(SqBiTree T)

{

int i = 0, l;

char s[MAX_TREE_SIZE];

printf("请按层序输入结点的值(字符)，空格表示空结点，结点数≤%d:\n",

MAX_TREE_SIZE);

printf("例如：abcefgh\n");

gets(s); // 输入字符串

l = strlen(s); // 求字符串的长度

for(;i<l;i++) // 将字符串赋值给T

{

T[i]=s[i];

// 此结点(不空)无双亲且不是根,T[(i+1)/2-1] == Nil表示T[i]无双亲

if(i!=0 && T[(i+1)/2-1] == Nil && T[i] != Nil)

{

printf("出现无双亲的非根结点%c\n",T[i]);

exit(0);

}

for(i=l;i<MAX_TREE_SIZE;i++) // 将空赋值给T的后面的结点

T[i]=Nil;

return 1;

}

// 若T为空二叉树,则返回,否则

int BiTreeEmpty(SqBiTree T)

{

if(T[0]==Nil) // 根结点为空,则树空

return 1;

else

return 0;

}

// 返回T的深度

int BiTreeDepth(SqBiTree T)

{

int i,j=-1;

for(i=MAX_TREE_SIZE-1;i>=0;i--) // 找到最后一个结点

if(T[i] != Nil)

break;

i++; // 为了便于计算

j++;

while(i>=pow(2.0,j)); //i > pow(2, depth-1) && i <= pow(2, depth)

return j; //j = depth;

}

// 当T不空,用e返回T的根,返回;否则返回,e无定义

int Root(SqBiTree T,TElemType *e)

{

if(BiTreeEmpty(T)) // T空

return 0;

else

{

*e=T[0];

return 1;

}

// 返回处于位置e(层,本层序号)的结点的值

TElemType Value(SqBiTree T,position e)

{

// 将层、本层序号转为矩阵的序号

return T[((int)pow(2.0,e.level-1) - 1) + (e.order - 1)];

//((int)pow(2,e.level-1) - 1)为该e.level的结点个数，

// (e.order - 1)为本层的位置

}

// 给处于位置e(层,本层序号)的结点赋新值value

int Assign(SqBiTree T,position e,TElemType value)

{

// 将层、本层序号转为矩阵的序号

int i = (int)pow(2.0,e.level-1) + e.order - 2;

if(value != Nil && T[(i+1)/2-1] == Nil) // 叶子非空值但双亲为空

return 0;

else if(value == Nil && (T[i*2+1] != Nil || T[i*2+2] != Nil))

// 双亲空值但有叶子（不空）

return 0;

T[i]=value;

return 1;

}

// 若e是T的非根结点,则返回它的双亲,否则返回＂空＂

TElemType Parent(SqBiTree T,TElemType e)

{

int i;

if(T[0]==Nil) // 空树

return Nil;

for(i=1;i<=MAX_TREE_SIZE-1;i++)

if(T[i]==e) // 找到e

return T[(i+1)/2-1];

return Nil; // 没找到e

}

// 返回e的左孩子。若e无左孩子,则返回＂空＂

TElemType LeftChild(SqBiTree T,TElemType e)

{

int i;

if(T[0]==Nil) // 空树

return Nil;

for(i=0;i<=MAX_TREE_SIZE-1;i++)

if(T[i]==e) // 找到e

return T[i*2+1];

return Nil; // 没找到e

}

// 返回e的右孩子。若e无右孩子,则返回＂空＂

TElemType RightChild(SqBiTree T,TElemType e)

{

int i;

if(T[0]==Nil) // 空树

return Nil;

for(i=0;i<=MAX_TREE_SIZE-1;i++)

if(T[i]==e) // 找到e

return T[i*2+2];

return Nil; // 没找到e

}

// 返回e的左兄弟。若e是T的左孩子或无左兄弟,则返回＂空＂

TElemType LeftSibling(SqBiTree T,TElemType e)

{

int i;

if(T[0]==Nil) // 空树

return Nil;

for(i=1;i<=MAX_TREE_SIZE-1;i++)

if(T[i] == e && i%2 == 0) // 找到e且其序号为偶数(是右孩子)

return T[i-1];

return Nil; // 没找到e

}

// 返回e的右兄弟。若e是T的右孩子或无右兄弟,则返回＂空＂

TElemType RightSibling(SqBiTree T,TElemType e)

{

int i;

if(T[0]==Nil) // 空树

return Nil;

for(i=1;i<=MAX_TREE_SIZE-1;i++)

if(T[i]==e&&i%2) // 找到e且其序号为奇数(是左孩子)

return T[i+1];

return Nil; // 没找到e

}

// 把从q的j结点开始的子树移为从T的i结点开始的子树

// InsertChild()用到

void Move(SqBiTree q,int j,SqBiTree T,int i)

{

if(q[2*j+1] != Nil) // q的左子树不空

Move(q,(2*j+1),T,(2*i+1)); // 把q的j结点的左子树移为T的i结点的左子树

if(q[2*j+2] != Nil) // q的右子树不空

Move(q,(2*j+2),T,(2*i+2)); // 把q的j结点的右子树移为T的i结点的右子树

T[i]=q[j]; // 把q的j结点移为T的i结点

q[j]=Nil; // 把q的j结点置空

}

// 根据LR为或,插入c为T中p结点的左或右子树。p结点的原有左或

// 右子树则成为c的右子树

int InsertChild(SqBiTree T,TElemType p,int LR,SqBiTree c)

{

int j,k,i=0;

for(j=0;j<(int)pow(2.0,BiTreeDepth(T))-1;j++) // 查找p的序号

if(T[j]==p) // j为p的序号

break;

k=2*j+1+LR; // k为p的左或右孩子的序号

if(T[k] != Nil) // p原来的左或右孩子不空

Move(T,k,T,2*k+2); // 把从T的k结点开始的子树移为从k结点的右子树开始的子树

Move(c,i,T,k); // 把从c的i结点开始的子树移为从T的k结点开始的子树

return 1;

}

// 构造一个空队列Q

int InitQueue(SqQueue *Q)

{

(*Q).base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType)); //分配定长的空间，相当于一个数组

if(!(*Q).base) // 存储分配失败

exit(0);

(*Q).front=(*Q).rear=0; //初始化下标

return 1;

}

// 插入元素e为Q的新的队尾元素

int EnQueue(SqQueue *Q,QElemType e)

{

if((*Q).rear>=MAXQSIZE)

{ // 队列满，增加个存储单元

(*Q).base=(QElemType *)realloc((*Q).base,((*Q).rear+1)*sizeof(QElemType));

if(!(*Q).base) // 增加单元失败

return 0;

}

*((*Q).base+(*Q).rear)=e;

(*Q).rear++;

return 1;

}

// 若队列不空,则删除Q的队头元素,用e返回其值,并返回,否则返回

int DeQueue(SqQueue *Q,QElemType *e)

{

if((*Q).front==(*Q).rear) // 队列空

return 0;

*e=(*Q).base[(*Q).front];

(*Q).front=(*Q).front+1;

return 1;

}

// 根据LR为或,删除T中p所指结点的左或右子树

int DeleteChild(SqBiTree T,position p,int LR)

{

int i;

int k=1; // 队列不空的标志

SqQueue q;

InitQueue(&q); // 初始化队列，用于存放待删除的结点

i=(int)pow(2.0,p.level-1)+p.order-2; // 将层、本层序号转为矩阵的序号

if(T[i]==Nil) // 此结点空

return 0;

i=i*2+1+LR; // 待删除子树的根结点在矩阵中的序号

while(k)

{

if(T[2*i+1]!=Nil) // 左结点不空

EnQueue(&q,2*i+1); // 入队左结点的序号

if(T[2*i+2]!=Nil) // 右结点不空

EnQueue(&q,2*i+2); // 入队右结点的序号

T[i]=Nil; // 删除此结点

k=DeQueue(&q,&i); // 队列不空

}

return 1;

}

int(*VisitFunc)(TElemType); // 函数变量

void PreTraverse(SqBiTree T,int e)

{

// PreOrderTraverse()调用

VisitFunc(T[e]); //先调用函数VisitFunc处理根

if(T[2*e+1]!=Nil) // 左子树不空

PreTraverse(T,2*e+1); //然后处理左子树

if(T[2*e+2]!=Nil) // 右子树不空

PreTraverse(T,2*e+2);

}

// 先序遍历T,对每个结点调用函数Visit一次且仅一次。

int PreOrderTraverse(SqBiTree T,int(*Visit)(TElemType))

{

VisitFunc=Visit;

if(!BiTreeEmpty(T)) // 树不空

PreTraverse(T,0);

printf("\n");

return 1;

}

// InOrderTraverse()调用

void InTraverse(SqBiTree T,int e)

{

if(T[2*e+1]!=Nil) // 左子树不空

InTraverse(T,2*e+1);

VisitFunc(T[e]);

if(T[2*e+2]!=Nil) // 右子树不空

InTraverse(T,2*e+2);

}

// 中序遍历T,对每个结点调用函数Visit一次且仅一次。

int InOrderTraverse(SqBiTree T,int(*Visit)(TElemType))

{

VisitFunc=Visit;

if(!BiTreeEmpty(T)) // 树不空

InTraverse(T,0);

printf("\n");

return 1;

}

// PostOrderTraverse()调用

void PostTraverse(SqBiTree T,int e)

{

if(T[2*e+1]!=Nil) // 左子树不空

PostTraverse(T,2*e+1);

if(T[2*e+2]!=Nil) // 右子树不空

PostTraverse(T,2*e+2);

VisitFunc(T[e]);

}

// 后序遍历T,对每个结点调用函数Visit一次且仅一次。

int PostOrderTraverse(SqBiTree T,int(*Visit)(TElemType))

{

VisitFunc = Visit;

if(!BiTreeEmpty(T)) // 树不空

PostTraverse(T,0);

printf("\n");

return 1;

}

// 层序遍历二叉树

void LevelOrderTraverse(SqBiTree T,int(*Visit)(TElemType))

{

int i=MAX_TREE_SIZE-1,j;

while(T[i] == Nil)

i--; // 找到最后一个非空结点的序号

for(j=0;j<=i;j++) // 从根结点起,按层序遍历二叉树

if(T[j] != Nil)

Visit(T[j]); // 只遍历非空的结点

printf("\n");

}

// 逐层、按本层序号输出二叉树

void Print(SqBiTree T)

{

int j,k;

position p;

TElemType e;

for(j=1;j<=BiTreeDepth(T);j++)

{

printf("第%d层: ",j);

for(k=1; k <= pow(2.0,j-1);k++)

{

p.level=j;

p.order=k;

e=Value(T,p);

if(e!=Nil)

printf("%d:%c ",k,e);

}

printf("\n");

}

int visit(TElemType e)

{

printf("%c ",e);

return 0;

}

int main()

{

int i,j;

position p;

TElemType e;

SqBiTree T,s;

/*T[99] = 'p';*/

//T[99] = 'M';

//cout<<T[99]<<endl;

getchar();

InitBiTree(T);

CreateBiTree(T);

printf("建立二叉树后,树空否？%d(1:是0:否) 树的深度=%d\n",

BiTreeEmpty(T),BiTreeDepth(T));

i=Root(T,&e);

if(i)

printf("二叉树的根为：%c\n",e);

else

printf("树空，无根\n");

printf("层序遍历二叉树:\n");

LevelOrderTraverse(T,visit);

printf("中序遍历二叉树:\n");

InOrderTraverse(T,visit);

printf("后序遍历二叉树:\n");

PostOrderTraverse(T,visit);

printf("请输入待修改结点的层号本层序号: ");

scanf("%d%d%*c",&p.level,&p.order);

e=Value(T,p);

printf("待修改结点的原值为%c请输入新值: ",e);

scanf("%c%*c",&e);

Assign(T,p,e);

printf("先序遍历二叉树:\n");

PreOrderTraverse(T,visit);

printf("结点%c的双亲为%c,左右孩子分别为",e,Parent(T,e));

printf("%c,%c,左右兄弟分别为",LeftChild(T,e),RightChild(T,e));

printf("%c,%c\n",LeftSibling(T,e),RightSibling(T,e));

InitBiTree(s);

printf("建立右子树为空的树s:\n");

CreateBiTree(s);

printf("树s插到树T中,请输入树T中树s的双亲结点s为左(0)或右(1)子树: ");

scanf("%c%d%*c",&e,&j);

InsertChild(T,e,j,s);

Print(T);

printf("删除子树,请输入待删除子树根结点的层号本层序号左(0)或右(1)子树: ");

scanf("%d%d%d%*c",&p.level,&p.order,&j);

DeleteChild(T,p,j);

Print(T);

ClearBiTree(T);

printf("清除二叉树后,树空否？%d(1:是0:否) 树的深度=%d\n",

BiTreeEmpty(T),BiTreeDepth(T));

i=Root(T,&e);

if(i)

printf("二叉树的根为：%c\n",e);

else

printf("树空，无根\n");

system("pause");

return 0;

}

实验四无向图的深度优先搜索
一、实验内容：

1.建立图邻接矩阵

2.初始化图

3.增加顶点

4.增加边

5.创建图

6.打印图

7.深度优先搜索

二、实验环境：

1.硬件环境

计算机一台

2.软件环境

Microsoft Visual Studio 2008集成开发环境

Windows操作系统(WindowsXP、Windows7、Windows Server 2008)

三、实验步骤：

#include <iostream>

using namespace std;

#define MAX_VERTEX_NUM 10 //最大顶点个数

typedef char VERTYPE;

typedef struct

{

VERTYPE vexs[MAX_VERTEX_NUM]; //顶点向量

int visited[MAX_VERTEX_NUM]; //访问标志数组

int arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; //邻接矩阵

int vexnum,arcnum; //图的当前顶点数和弧数

}mgraph, * MGraph;

void init_mgraph(MGraph &g) //初始化图

{

int i;

g=(MGraph)malloc(sizeof(mgraph));

g->vexnum=0;

g->arcnum=0;

for( i=0;i<MAX_VERTEX_NUM;i++)

g->vexs[i]=0;

for(i=0;i<MAX_VERTEX_NUM;i++)

g->visited[i]=0; //访问标志数组置，表示没有被访问

for(i=0;i<MAX_VERTEX_NUM;i++)

for(int j=0;j<MAX_VERTEX_NUM;j++)

g->arcs[i][j]=0;

}

void add_vexs(MGraph &g) //增加顶点

{

cout<<"请输入顶点的个数:"<<endl;

cin>>g->vexnum;

cout<<"请输入顶点的值"<<endl;

for(int i=0;i<g->vexnum;i++)

{

cin>>g->vexs[i];

}

void add_arcs(MGraph &g) //增加边

{

cout<<"请输入边的个数:"<<endl;

cin>>g->arcnum;

VERTYPE ch1,ch2;

int row,col;

for(int i=0;i<g->arcnum;i++)

{

cin>>ch1>>ch2;

for(int j=0;j<g->vexnum;j++)

{

if(g->vexs[j]==ch1)

{

row=j;

}

if(g->vexs[j]==ch2)

{

col=j;

}

g->arcs[row][col]=1;

g->arcs[col][row]=1; //无向图加上此行

}

void creat_mgraph(MGraph &g) //创建图

{

add_vexs(g); //增加顶点

add_arcs(g); //增加边

}

void print_mgraph(MGraph &g) //打印图

{

int i;

for(i=0;i<g->vexnum;i++)

cout<<" "<<g->vexs[i];

cout<<endl;

for(i=0;i<g->vexnum;i++)

{

cout<<g->vexs[i]<<" ";

for(int j=0;j<g->vexnum;j++)

{

cout<<g->arcs[i][j]<<" ";

}

cout<<endl;

}

void Visit(MGraph &g,int i)

{

cout<<g->vexs[i]<<" ";

g->visited[i]=1;

}

//深度优先搜索

void DFSTraverse(MGraph &g,int i) //从第i个顶点开始搜索

{

Visit(g,i);

for(int j=0;j<g->vexnum;j++)

if(g->arcs[i][j] && !g->visited[j])

DFSTraverse(g,j);

}

void main()

{

MGraph G;

init_mgraph(G); //初始化图

creat_mgraph(G); //创建图

print_mgraph(G); //打印图

DFSTraverse(G,0); //深度优先搜索

getchar();

}

实验五二叉排序树设计
一、实验内容：

1.建立二叉树结点数据结构

2.二叉树插入节点，

3.构造二叉排序树

4.中序遍历二叉排序树，输出有序序列

二、实验环境：

1.硬件环境

计算机一台

2.软件环境

Microsoft Visual Studio 2008集成开发环境

Windows操作系统(WindowsXP、Windows7、Windows Server 2008)

三、实验步骤：

#include<iostream>

using namespace std;

typedef struct node

{

int element;

struct node* left;

struct node* right;

}Node,*NodePtr;

//插入节点，注意这用了指向指针的指针

void insertNode(NodePtr *head,int data)

{

if (*head==NULL)

{

*head=new Node;

(*head)->element=data;

(*head)->left=NULL;

(*head)->right=NULL;

}

else

{

if (data< (*head)->element)

{

insertNode(&((*head)->left),data);

}

else if (data> (*head)->element)

{

insertNode(&((*head)->right),data);

}

//构造二叉排序树，控制台下输入整数，表示结束输入

NodePtr creatTree()

{

NodePtr head=NULL;

int data;

scanf("%d",&data);

while(data!=0)

{

insertNode(&head,data);

scanf("%d",&data);

}

return head;

}

//中序遍历二叉排序树，得到有序序列

void printTree(NodePtr head)

{

if(head!=NULL)

{

printTree(head->left);

printf("%d ",head->element);

printTree(head->right);

}

void main()

{

NodePtr head;

printf("请输入一串整数，空格隔开，表示输入结束\n");

head=creatTree();

printf("中序遍历二叉排序树\n");

printTree(head);

printf("\n");

getchar();

}

技术搬砖工

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构实验

实验一链表的插入和删除1
复制链接

扫一扫

专栏目录