算法与数据结构课程设计报告

设计方案:

第一步：根据设计任务，设计DOS菜单。

第二步：添加功能函数。

在程序合适的位置添加相应的函数实现各功能模块。

实现过程：

#include"iostream"

using namespace std;

void ShowMainMenu(){

cout<<"\n";

cout<<"*******************算法与数据结构******************\n"; cout<<"* 1 单链表的基本操作及应用*\n"; cout<<"* 2 栈的基本操作及应用*\n"; cout<<"* 3 数组的基本操作及应用*\n"; cout<<"* 4 树的基本操作及应用*\n"; cout<<"* 5 图的基本操作及应用*\n"; cout<<"* 6 退出*\n"; cout<<"***************************************************\n"; }

void LinkListModule(){

int choice;

do{

cout<<"\n";

cout<<"**************单链表的基本操作及应用***************\n"; cout<<"* 1 创建*\n"; cout<<"* 2 插入*\n"; cout<<"* 3 删除*\n"; cout<<"* 4 查找*\n"; cout<<"* 5 显示*\n"; cout<<"* 6 通讯录（应用）*\n"; cout<<"* 7 退出*\n"; cout<<"***************************************************\n"; cout<<"请选择：";

cin>>choice;

switch(choice){

case 1:

cout<<"--------创建链表-------"; break;

case 2:

cout<<"--------插入元素-------";break;

case 3:

cout<<"--------删除元素-------";break;

case 4:

cout<<"--------查找元素-------";break;

case 5:

cout<<"--------显示链表-------";break;

case 6:

cout<<"--------通讯录---------";break;

case 7: break;

default:

cout<<"ERROR!";break;

}

}while(choice!=7);

}

void StackModule (){

int choice;

do{

cout<<"\n";

cout<<"****************栈的基本操作及应用*****************\n"; cout<<"* 1 进栈*\n"; cout<<"* 2 出栈*\n"; cout<<"* 3 取栈顶元素*\n"; cout<<"* 4 表达式求解（应用）*\n"; cout<<"* 5 退出*\n"; cout<<"***************************************************\n"; cout<<"请选择：";

cin>>choice;

switch(choice){

case 1:

cout<<"--------进栈-------";break;

case 2:

cout<<"--------出栈-------";break;

case 3:

cout<<"--------取栈顶元素-------";break;

case 4:

cout<<"--------表达式求值-------";break;

case 5:break;

default:

cout<<"ERROR!";break;

}

}while(choice!=5);

}

void ArrayModule (){

int choice;

do{

cout<<"\n";

cout<<"*************稀疏矩阵的压缩存储及应用**************\n"; cout<<"* 1 创建*\n"; cout<<"* 2 显示*\n"; cout<<"* 3 矩阵乘法（应用）*\n"; cout<<"* 4 退出*\n"; cout<<"***************************************************\n"; cout<<"请选择：";

cin>>choice;

switch(choice){

case 1:

cout<<"---------创建-------";break;

case 2:

cout<<"---------显示-------";break;

case 3:

cout<<"---------矩阵乘法-------";break;

case 4:break;

default:

cout<<"ERROR!";break;

}

}while(choice!=4);

}

void BiTreeModule (){

int choice;

do{

cout<<"\n";

cout<<"**************二叉树的基本操作及应用***************\n"; cout<<"* 1 创建二叉树*\n"; cout<<"* 2 遍历二叉树（先/中/后）*\n"; cout<<"* 3 计算树的深度*\n"; cout<<"* 4 计算叶子结点个数*\n"; cout<<"* 5 查找双亲*\n"; cout<<"* 6 查找兄弟*\n"; cout<<"* 7 Huffman编码（应用）*\n"; cout<<"* 8 退出\n";

cout<<"***************************************************\n"; cout<<"请选择：";

cin>>choice;

switch(choice){

case 1:

cout<<"---------创建二叉树--------";break;

cout<<"---------*遍历二叉树-------";break;

case 3:

cout<<"---------计算树的深度------";break;

case 4:

cout<<"---------计算叶子结点个数-------";break;

case 5:

cout<<"---------查找双亲-------";break;

case 6:

cout<<"---------查找兄弟-------";break;

case 7:

cout<<"---------Huffman编码-------";break;

case 8:break;

default:

cout<<"ERROR!";break;

}

}while(choice!=8);

}

void GraphModule (){

int choice;

do{

cout<<"\n";

cout<<"****************图的基本操作及应用*****************\n"; cout<<"* 1 创建无向图*\n"; cout<<"* 2 创建无向网*\n"; cout<<"* 3 创建有向图*\n"; cout<<"* 4 创建有向网*\n"; cout<<"* 5 遍历*\n"; cout<<"* 6 拓扑排序*\n"; cout<<"* 7 最小生成树（应用）*\n"; cout<<"* 8 最短路径（应用）*\n"; cout<<"* 9 关键路径（应用）*\n"; cout<<"* 10 退出*\n"; cout<<"***************************************************\n"; cout<<"请选择：";

cin>>choice;

switch(choice){

case 1:

cout<<"---------创建无向图-------";break;

case 2:

cout<<"---------创建无向网-------";break;

case 3:

cout<<"---------创建有向图-------";break;

cout<<"---------创建有向网-------";break; case 5:

cout<<"---------遍历-------";break;

case 6:

cout<<"---------拓扑排序-------";break; case 7:

cout<<"---------最小生成树-------";break; case 8:

cout<<"---------最短路径-------";break;

case 9:

cout<<"---------关键路径-------";break;

case 10:break;

default:

cout<<"ERROR!";break;

}

}while(choice!=10);

}

void main(){

int choice;

do{

ShowMainMenu();

cout<<"请选择：";

cin>>choice;

switch(choice){

case 1:LinkListModule ();break;

case 2:StackModule ();break;

case 3:ArrayModule ();break;

case 4:BiTreeModule ();break;

case 5:GraphModule ();break;

case 6:break;

default:cout<<"ERROR!";break;

}

}while(choice!=6);

}

实现代码：

1.链表：

typedef struct LNode{//单链表结构体char name[20];

char Iphonedata[11];

int qq;

ElemType data;

struct LNode*next;

}LNode,*LinkList;

Status InitList_L(LinkList&L);//初始化单链表

void CreateList_L(LinkList&L,int n);//创建

Status ListInsert_L(LinkList&L,int i,ElemType e);//插入Status ListDelete_L(LinkList&L,int i,ElemType&e);//删除Status GetElem_L(LinkList L,int i,ElemType&e);//查找

Status ListTraverse_L(LinkList L);//显示

Status DestroyList_L(LinkList&L);//退出

//初始化单链表

Status InitList_L(LinkList&L)

{

L=(LinkList)malloc(sizeof(LNode));

if(!L)

return ERROR;

L->next=NULL;

return OK;

}

void CreateList_L(LinkList&L,int n)

//随机产生n个元素的值，建立带表头结点的单链表（表头插入法）

{

int i;

LinkList p;

L=(LinkList)malloc(sizeof(LNode));

L->next=NULL;//先建立一个带头结点的单链线性表

for(i=n;i> 0;--i)

{

p=(LinkList)malloc(sizeof(LNode));//生成新结点

scanf_s("%d",&p->data);//输入元素值

p->next=L->next;

L->next=p;//查到表头

}

}//CreateList_L

Status ListInsert_L(LinkList&L,int i,ElemType e)

//在L中第i个元素之前插入新的元素e，插入成功返回OK，反之返回ERROR {

LinkList p,s;

int j= 0;

p=L;

while(p->next&&j

{

p=p->next;

j++;

}

if(!p||j>i- 1)//i小于1或大于表长加1

return ERROR;

s=(LinkList)malloc(sizeof(LNode));//生成新结点

s->data=e;

s->next=p->next;

p->next=s;//插入表中

return OK;

}//ListInsert_L

Status ListDelete_L(LinkList&L,int i,ElemType&e)

//在L中删除第i个元素的值,其值返回给e，删除成功返回OK，反之返回ERROR {

LinkList p,q;

int j= 0;

p=L;

while(p->next&&j

p=p->next;

j++;

}

if(!(p->next)||j>i- 1)//删除位置不合理

return ERROR;

q=p->next;

p->next=q->next;

e=q->data;

free(q);//删除并释放结点

return OK;

}//ListDelete_L

Status GetElem_L(LinkList L,int i,ElemType&e)

{

LinkList p;

int j;

p=L->next;

j= 1;

while(p&&j

{

p=p->next;++j;

}

if(!p||j>i)

return ERROR;

e=p->data;

return OK;

}//查找

Status ListTraverse_L(LinkList L)

{//依次对L的每个数据元素的值进行输出

LinkList p=L->next;

while(p)

{

printf(" %d\t",p->data);

p=p->next;

}

printf("\n");

return OK;

}//输出

Status DestroyList_L(LinkList&L)

{

LinkList q;

while(L)

{

q=L->next;

free(L);

L=q;

}

return OK;

}//退出

void CreatList1(LinkList&L)

{

int i;

LinkList r,p;

L=(LinkList)malloc(sizeof(LNode));

r=L;

printf("进行通信录的输入,1 or 0?\n");

scanf_s("%d",&i);

getchar();

while(i)

{

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

printf("请输入姓名:\n");

cin>>p->name;

printf("请输入电话号码:\n");

cin>>p->Iphonedata;

printf("请输入qq号:\n");

scanf_s("%d",&p->qq);

r->next=p;

r=p;

printf("进行通信录的输入,1 or 0?\n");

scanf_s("%d",&i);

getchar();

}

r->next=NULL;

}

//显示通讯录

void OutPut(LinkList L)

{

LinkList p;

p=L->next;

while(p!=NULL)

{

printf("姓名:%s\t手机号:%s\tqq号:%d\t\n",p->name,p->Iphonedata,p->qq);

p=p->next;

}

}

void LinkList1(){

LinkList L;

InitList_L(L);

ElemType e;

int i,n,m;

do{

printf("\n");

printf("**************单链表的基本操作及应用***************\n");

printf("* 1 创建 *\n");

printf("* 2 插入 *\n");

printf("* 3 删除 *\n");

printf("* 4 查找 *\n");

printf("* 5 显示 *\n");

printf("* 6 通讯录（应用） *\n");

printf("* 7 退出 *\n");

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

printf("请选择：");

scanf_s("%d",&n);

switch(n){

case 1:

printf("请输入链表元素个数和元素值：");scanf_s("%d",&n);CreateList_L(L, n);break;

case 2:

printf("请输入插入位序和元素值：");scanf_s("%d %d",&i,&n);

ListInsert_L(L,i,n);break;

case 3:

printf("请输入删除元素位序：");scanf_s("%d",&i);ListDelete_L(L,i,m); break;

case 4:

printf("请输入被查找元素位序：");scanf_s("%d",&i);

if(GetElem_L(L,i,e))

printf("第%d个元素的值为%d\n",i,e);

else

printf("第%d个元素不存在\n",i);

break;

case 5:

ListTraverse_L(L);break;

case 6:

CreatList1(L);printf("该通讯录为：\n");OutPut(L);break;

case 7:DestroyList_L(L);break;

default:

printf("ERROR!");break;

}

}while(n!= 7);

}

2.栈：

constexpr auto STACK_INIT_SIZE= 100;

constexpr auto STACKINCREMENT= 10;

typedef struct//栈的结构体

{

SElemType*base;

SElemType*top;

int stacksize;

}SqStack;

Status InitStack(SqStack&S);//建立空栈

Status Push(SqStack&S,SElemType e);//入栈

Status Pop(SqStack&S,SElemType&e);//出栈

Status GetTop(SqStack S,SElemType&e);//取栈顶元素

Status DestroyStack(SqStack&S);//销毁栈

Status InitStack(SqStack&S)//建立空栈

{

S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));

if(!S.base)

exit(OVERFLOW);//存储分配失败

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

return OK;

}

Status GetTop(SqStack S,SElemType&e)//取栈顶元素

{

//若栈不空，则用e返回S的栈顶元素，并返回OK，否则返回ERROR

if(S.top==S.base)

return ERROR;

e=*(S.top- 1);

return OK;

}

Status Push(SqStack&S,SElemType e)//入栈

{

if(S.top-S.base>=S.stacksize){//栈满，追加存储空间

S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)* sizeof(SElemType));

if(!S.base)

exit(OVERFLOW);//存储分配失败

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*S.top++=e;

return OK;

}

Status Pop(SqStack&S,SElemType&e)//出栈

{

if(S.top==S.base)

return ERROR;

e=*--S.top;

return OK;

}

Status DestroyStack(SqStack&S)//销毁栈

{

free(S.base);

S.stacksize= 0;

S.top=S.base=NULL;

return OK;

}

void Stack1(){

int n;

SqStack S;

SElemType e;

InitStack(S);

do{

printf("\n");

printf("****************栈的基本操作及应用*****************\n");

printf("* 1 进栈 *\n");

printf("* 2 出栈 *\n");

printf("* 3 取栈顶元素 *\n");

printf("* 4 表达式求解（应用） *\n");

printf("* 5 退出 *\n");

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

printf("请选择：");

scanf_s("%d",&n);

switch(n){

case 1:

printf("请输入进栈的元素值：");scanf_s("%d",&e);Push(S,e);break;

case 2:

Pop(S,e);printf("出栈元素值为：");cout<

case 3:

GetTop(S,e);printf("栈顶元素值为：");cout<

case 4:

printf("--------表达式求值-------");break;

case 5:break;

default:

printf("ERROR!");break;

}

}while(n!= 5);

DestroyStack(S);

}

3.数组：

//稀疏矩阵的三元组顺序表存储表示

typedef struct{

int i,j;//该非零元的行下标和列下标

ElemType e;

}Triple;

typedef struct{

Triple data[MAXSIZE+ 2];//非零元三元组表，data[0]未用

int rops[MAXROW+ 1];//

int mu,nu,tu;//矩阵的行列和非零元个数

}TSMatrix;

//创建

int CreateSMatrix(TSMatrix&M)

{

int i,m,n;

ElemType e;

int k;

printf("请输入矩阵的行数,列数,非零元素数：");

scanf_s("%d %d %d",&M.mu,&M.nu,&M.tu);

M.data[0].i= 0;// 为以下比较顺序做准备

for(i= 1;i<=M.tu;i++)

{

do

{

printf("请按行序顺序输入第%d个非零元素所在的行(1～%d),列(1～%d),元素值：", i,M.mu,M.nu);

scanf_s("%d %d %d",&m,&n,&e);

k= 0;

if(m<1 ||m>M.mu||n<1 ||n>M.nu)// 行或列超出范围

k= 1;

if(m

k= 1;

}while(k);

M.data[i].i=m;

M.data[i].j=n;

M.data[i].e=e;

}

return OK;

}

//显示

Status PrintSMatrix(TSMatrix M)

{

int m,n,t,b,c,a= 1;

m=M.mu;n=M.nu;t=M.tu;

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

{

for(c= 1;c<=n;++c)

{

if(b==M.data[a].i&&c==M.data[a].j)

{

printf("%d ",M.data[a].e);

a++;

}

else

printf("0 ");

}

printf("\n");

}

return OK;

}

bool Count(TSMatrix&T)

{

int num[MAXROW+ 1];

for(int row= 1;row<=T.mu;row++)num[row]= 0;

for(int col= 1;col<=T.tu;col++)++num[T.data[col].i];//

T.rops[1]= 1;

for(int i= 2;i<=T.mu;i++)T.rops[i]=T.rops[i- 1]+num[i- 1];// return true;

}

//矩阵的乘法函数

bool MultSMatrix(){

TSMatrix M,N,Q;

CreateSMatrix(M);PrintSMatrix(M);

CreateSMatrix(N);PrintSMatrix(N);

Count(M);

Count(N);

cout<<"输入的两矩阵的乘矩阵为："<

if(M.nu!=N.mu)return false;

Q.mu=M.mu;

Q.nu=N.nu;

Q.tu= 0;//初始化

int ctemp[MAXROW+ 1];//辅助数组

int arow,tp,p,brow,t,q,ccol;

if(M.tu*N.tu){

for(arow= 1;arow<=M.mu;arow++){

for(int x= 1;x<=N.nu;x++)ctemp[x]= 0;

Q.rops[arow]=Q.tu+ 1;

if(arow

tp=M.rops[arow+ 1];

else tp=M.tu+ 1;

for(p=M.rops[arow];p

brow=M.data[p].j;

if(brow

else t=N.tu+ 1;

for(q=N.rops[brow];q

ccol=N.data[q].j;

ctemp[ccol]+=M.data[p].e*N.data[q].e;

}

}

for(ccol= 1;ccol<=Q.nu;ccol++)

if(ctemp[ccol]){

if(++Q.tu>MAXSIZE)return false;

Q.data[Q.tu].e=ctemp[ccol];

Q.data[Q.tu].i=arow;

Q.data[Q.tu].j=ccol;

}

}

}

PrintSMatrix(Q);

return true;

}

void Array1(){

int n;

TSMatrix M;

do{

printf("\n");

printf("*************稀疏矩阵的压缩存储及应用**************\n");

printf("* 1 创建 *\n");

printf("* 2 显示 *\n");

printf("* 3 矩阵乘法（应用） *\n");

printf("* 4 退出 *\n");

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

printf("请选择：");

scanf_s("%d",&n);

switch(n){

case 1:

printf("创建矩阵M: \n");CreateSMatrix(M);break;

case 2:

printf("矩阵M为：\n");PrintSMatrix(M);break;

case 3:

MultSMatrix();break;

case 4:break;

default:

printf("ERROR!");break;

}

}while(n!= 4);

}

4.二叉树：

typedef struct BiTNode//二叉树结构体

{

TElemType data;

struct BiTNode*lchild,*rchild;

}BiTNode,*BiTree;

Status CreateBiTree(BiTree&T)//创建二叉树

{

TElemType e;

cin>>e;

if(e=='0')

T=NULL;

else

{

T=new BiTNode;

T->data=e;

CreateBiTree(T->lchild);

CreateBiTree(T->rchild);

}

return OK;

}//CreateBiTree

Status PreOrderTraverse(BiTree T,Status(*Visit)(TElemType e))//先序遍历{

if(T== 0)

return 1;

cout<<(T->data);

PreOrderTraverse(T->lchild,Visit);

PreOrderTraverse(T->rchild,Visit);

return 1;

}

Status InOrderTraverse(BiTree T,Status(*Visit)(TElemType e))//中序遍历{

if(T== 0)

return 1;

InOrderTraverse(T->lchild,Visit);

Visit(T->data);

InOrderTraverse(T->rchild,Visit);

return OK;

}

Status PostOrderTraverse(BiTree T,Status(*Visit)(TElemType e))//后序遍历{

if(T== 0)

return 1;

PostOrderTraverse(T->lchild,Visit);

PostOrderTraverse(T->rchild,Visit);

Visit(T->data);

return OK;

}

Status PrintElement(TElemType e)//输出

{

cout<

return OK;

}

int Height(BiTree T)//求二叉树的高度

{

int LD,RD;

if(T==NULL){

return 0;

}

else{

LD=Height(T->lchild);

RD=Height(T->rchild);

return(LD>RD?LD:RD)+ 1;

}

}

int Leave(BiTree T)//求二叉树中的叶子节点数

{

if(T==NULL)

return 0;

else{

if(T->lchild==NULL&&T->rchild==NULL)

return 1;

else

return(Leave(T->lchild)+Leave(T->rchild));

}

}

Status Parent(BiTree T,TElemType e)//查找双亲

// 二叉树T存在，e是T中某个结点

// 若e是T的非根结点，则返回它的双亲；否则返回“空”

{

Status m;

if(T==NULL)// 空树

return 0;

if((T->lchild&&T->lchild->data==e)||(T->rchild&&T->rchild->data==e)) return T->data;

m=Parent(T->lchild,e);

if(m== 0)m=Parent(T->rchild,e);

return m;

}

Status Brother(BiTree T,TElemType e)//查找兄弟

{

Status m;

if(T==NULL)// 空树

return 0;

if(T->lchild&&T->lchild->data==e)

return T->rchild->data;

if(T->rchild&&T->rchild->data==e)

return T->lchild->data;

m=Brother(T->lchild,e);

if(m== 0)m=Brother(T->rchild,e);

return m;

}

void BiTree1(){

int n;

BiTree T=NULL;

TElemType e,m;

int height,num;

do{

printf("\n");

printf("**************二叉树的基本操作及应用***************\n");

printf("* 1 创建二叉树 *\n");

printf("* 2 遍历二叉树（先/中/后） *\n");

printf("* 3 计算树的深度 *\n");

printf("* 4 计算叶子结点个数 *\n");

printf("* 5 查找双亲 *\n");

printf("* 6 查找兄弟 *\n");

printf("* 7 Huffman编码（应用） *\n");

printf("* 8 退出\n");

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

printf("请选择：");

scanf_s("%d",&n);

switch(n){

case 1:

printf("请输入二叉树的元素：\n");CreateBiTree(T);

break;

case 2:

printf("\n按先序遍历法输出该二叉树的元素为：");PreOrderTraverse(T, PrintElement);

printf("\n按中序遍历法输出该二叉树的元素为：");InOrderTraverse(T, PrintElement);

printf("\n按后序遍历法输出该二叉树的元素为：");PostOrderTraverse(T, PrintElement);

break;

case 3:

height=Height(T);printf("该二叉树深度为：");cout<

break;

case 4:

num=Leave(T);printf("该二叉树叶子结点个数为：");cout<

break;

case 5:

printf("请输入结点：");cin>>e;

m=Parent(T,e);printf("该结点双亲为：");cout<

break;

case 6:

printf("请输入结点：");cin>>e;

m=Brother(T,e);printf("该结点兄弟为：");cout<

break;

case 7:

printf("---------Huffman编码-------");

break;

case 8:

break;

default:

printf("ERROR!");

break;

}

}while(n!= 8);

}

5.图：

typedef struct//定义邻接矩阵图结构

{

char Vertex[VERTEX_MAX];//保存顶点信息(序号或字母)

int Edges[VERTEX_MAX][VERTEX_MAX];//保存边的权

int isTrav[VERTEX_MAX];//遍历标志

int VertexNum;//顶点数量

int EdgeNum;//边数量

int GraphType;//图的类型

}MGraph;

//构造无向图

void CreateUDG(MGraph*G){

int i,j,k;

char start,end;//边的起始顶点

cout<<"输入图的顶点数量和边数量:\n";

cin>>G->VertexNum>>G->EdgeNum;//输入图顶点数和边数

for(i= 0;iVertexNum;i++)//清空矩阵

{

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

G->Edges[i][j]=MINVALUE;//设置矩阵中各元素的值为最小值}

cout<<"输入各顶点信息\n";

for(i= 0;iVertexNum;i++)//输入顶点

{

printf("第%d个顶点:",i+ 1);

cin>>G->Vertex[i];//保存到各顶点数组元素中

}

printf("输入构成各边的两个顶点:\n");

for(k= 0;kEdgeNum;k++)//输入边的信息

{

printf("第%d条边：",k+ 1);

cin>>start>>end;

for(i= 0;start!=G->Vertex[i];i++);//在已有顶点中查找始点

{

for(j= 0;end!=G->Vertex[j];j++);//在已有顶点中查找结终点