数据结构试验实验程序代码下载

合集下载

文件下载数据结构的大型实验

[选题要求]1）选题采用1+X的方式，二类排序算法研究是基本任务。

X指代另外的题类不限，每组可任选题类，完成类别中的一小题要求即可。

2）每组选完题后，请e-mail告之选题中要求的X是什么，并告诉同组的构成。

3）16周前可以预先安排答辩时间，请e-mail：mgh@ , rhliang@ 或644844预约。

[报告规范] 实习报告的开头应该给出题目、班级、姓名、学号、和完成日期，并包括以下七个内容：1．需求分析：以无歧义的陈述说明程序设计的任务，强调的是程序要做什么？明确规定：（1）输入的形式和输入值的范围；（2）输出的形式；（3）程序所能达到的功能；（4）测试数据：包括正确的输入及其输出结果和含有错误的输入及其输出结果。

2．概要设计说明本程序序中用到的所有抽象数据类型的定义、主程序的流程及各程序模块之间的层次（调用）关系。

3．详细设计：实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法；对主程序和其他模块都要写出伪码算法（伪码算法达到的详细程度建议为：按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序）；画出各类和各函数之间的调用关系。

4．调试分析内容包括：（1）调试过程中遇到的问题是如何解决的以及对设计与实现的回顾讨论与分析；（2）算法的效率分析（基本操作和其他算法的时间复杂度）和改进想法（3）经验和体会等。

5．用户使用说明：说明如何使用编写的程序，详细列出每一步的操作步骤。

6．测试结果：列出你的测试结果，包括输入和输出。

这里的测试数据应该完整和严格，最好多于需求分析中所列。

7．附录：带注释的源程序。

如果提交源代码，可以在实验报告列出程序文件名的清单。

实验报告可以以电子档提交。

[题目]一、离散事件模拟①银行业务模拟【问题描述】客户业务分为两种，第一种是申请从银行得到一笔资金，即取款或者借款。

第二种是向银行投入一笔资金，即存款或者还款。

银行有两个服务窗口，相应的有两个队列。

客户到达银行后先排第一个队。

数据结构实验报告代码

《数据结构》实验报告实验序号：5 实验项目名称：链式栈五、分析与讨论对上机实践结果进行分析，上机的心得体会。

六、教师评语成绩签名：日期：附源程序清单：实验要求编程实现如下功能：（1）按照输入的栈中元素个数n和各元素值成立一个顺序栈，并输出栈中各元素值。

（2）将数据元素e入栈，并输出入栈后的顺序栈中各元素值。

（3）将顺序栈中的栈顶元素出栈，并输出出栈元素的值和出栈后顺序栈中各元素值。

2. 实验相关原理：栈是一种插入和删除操作都限制在表的一端进行的特殊线性表，它的操作具有“先进后出”的特性。

采用顺序存储结构的栈称为顺序栈。

栈的存储结构描述如下：#define MAXSIZE 100; /*顺序栈的最大长度*/typedef struct{ Selemtype base[MAXSIZE]; /*存储栈中数据元素的数组*/int top; /*top为栈顶指针，它指示栈顶元素的存储空间的下一个存储单元*/}Sqstack;【核心算法提示】1．顺序栈入栈操作的大体步骤：第一判断顺序栈是不是为满，若是满，则函数返回ERROR，不然将待入栈的数据元素寄存在top所指示的存储单元中，再使top后移一个存储单元位置，即将top值加1，最后函数返回OK。

2．顺序栈出栈操作的大体步骤：第一判断顺序栈是不是为空，若是空，则函数返回ERROR，不然将栈顶指针前移一个存储单元位置，即将top值减1,再将top所指示的栈顶元素用e返回其值，并使函数返回OK。

【核心算法描述】status Push(Sqstack &S,Selemtype e)/*将数据元素e压入到顺序栈S中，使其成为新的栈项元素*/{ if >=MAXSIZE) /*若是栈满，则函数返回ERROR*/return ERROR;[++]=e;/*将新元素e寄存在top所指示的存储单元中,并使top值加1*/return OK;}status Pop(Sqstack &S,Selemtype &e)/*将顺序栈S中的栈顶元素从栈中删除，并用e返回其值*/{ if ==0) /*若是栈空，则函数返回ERROR*/Return ERROR;e=[];/*将top值减1,并用e保留top所指示的栈顶元素值*/return OK;}3．源程序代码参考#define MAXSIZE 100typedef struct{ int base[MAXSIZE];int top; /*top指示存储栈顶元素的下一存储单元*/}Sqstack; /*顺序栈的类型概念*/Sqstack Push(Sqstack S,int e) /*顺序栈的入栈操作函数*/{ if >=MAXSIZE)printf("Stack is Overflow\n");else[++]=e;return S;}Sqstack Pop(Sqstack S,int *e) /*顺序栈的出栈操作函数*/{ if ==0)printf("Stack is Empty\n");else*e=[];return S;}void Stack_display(Sqstack S) /*顺序栈的输出函数*/{ int i;for(i=0; i<;i++) /*依次输出栈中各元素的值，栈顶元素在表的尾部*/printf("%4d", [i]);printf("\n");}main(){ Sqstack S;int i,j,n,x,e;printf("please input the length:");/*请求输入顺序栈中元素个数*/scanf("%d",&n);printf("please input the Value:\n ");/*请求输入顺序栈中各个元素值*/for(i=0;i<n;i++)scanf("%d",&[i]);=n;printf("the stack is:\n");Stack_display(S);printf("please input the insert node:");/*请求输入需要入栈的新元素*/scanf("%d",&x);S=Push(S,x);printf("the stack after push is:\n");/*提示输出入栈后栈中各个元素值*/Stack_display(S); /*挪用顺序栈的输出函数*/S=Pop(S,&e);printf("the pop value is:%d\n",e); /*输出出栈元素的值*/printf("the stack after pop is:\n");/*提示输出出栈后栈中各个元素值*/Stack_display(S); /*挪用顺序栈的输出函数*/}（1）按照输入的栈中元素个数和各元素值成立一个链栈，并输出链栈中各元素值, 观察输入的内容与输出的内容是不是一致,特别注意栈顶元素的位置。

数据结构实验系统源代码(期末作业)

/* 树子系统*/#include <stdio.h>#include <malloc.h> #define MAX 100int count=0; /* 定义计算结点个数的变量*/ typedef struct tnode{char data;struct tnode *lchild,*rchild;}BT;BT *CreateBTree(){BT *t;char ch;scanf("%c",&ch);getchar();if(ch=='0')t=NULL;else{t=(BT *)malloc(sizeof(BT));t->data=ch;printf("请输入％c结点的左孩子结点:t->lchild=CreateBTree();printf("请输入％c结点的右孩子结点:t->rchild=CreateBTree();}return t;}void ShowBTree(BT *T){ if (T!=NULL){ printf("%c",T->data);if(T->lchild!=NULL){ printf("(");ShowBTree(T->lchild);if(T->rchild!=NULL){ printf(",");ShowBTree(T->rchild);}printf(")");}else",t->data);",t->data/* 用广义表表示法显示二叉树*//*当二叉树非空时*//*输入该结点数据域*//* 若其左子树非空*//* 输入左括号*//* 递归调用该函数输出其左子树各结点*/ /* 若其右子树非空*//* 输出逗号*//* 递归调用该函数输出其右子树各结点*//* 二叉树左子树为空，右子树不为空时*/ if(T->rchild!=NULL){printf("(");ShowBTree(T->lchild);if(T->rchild!=NULL){ printf(",");ShowBTree(T->rchild);} printf(")");}}}void PreOrder(BT *T){ if(T==NULL) return;else{ printf("%c",T->data);PreOrder(T->lchild);PreOrder(T->rchild);}}void InOrder(BT *T){ if(T==NULL) return;else{ InOrder(T->lchild);printf("%c",T->data);InOrder(T->rchild);}}void PostOrder(BT *T){ if (T==NULL) return;else{ PostOrder(T->lchild);PostOrder(T->rchild);printf("%c",T->data);}}void LevelOrder(BT *T){ int f,r;BT *p,*q[MAX];p=T;/* 输入左括号*//* 递归调用该函数输出其左子树各结点*/ /* 若其右子树非空*//* 输出逗号*//*递归调用该函数输出其右子树各结点*//* 先序遍历二叉树T*//*递归调用的结束条件*//* 输出结点的数据域*//*先序递归遍历左子树*//*先序递归遍历右子树*//* 中序遍历二叉树T*//* 递归调用的结束条件*//* 中序递归遍历左子树*//* 输出结点的数据域*//* 中序递归遍历右子树*//* 后序遍历二叉树T*//* 递归调用的结束条件*//* 后序递归遍历左子树*//* 后序递归遍历右子树*//* 输出结点的数据域*//* 按层次遍历二叉树T*//* 定义队头队尾指针*//* 定义循环队列，存放结点指针*if(p!=NULL){ f=1; q[f]=p; r=2; } while(f!=r) { p=q[f];printf("%c",p->data); if(p->lchild!=NULL) { q[r]=p->lchild; r=(r+1)%MAX; }if(p->rchild!=NULL) { q[r]=p->rchild; r=(r+1)%MAX; }f=(f+1)%MAX; }}/* 若二叉树非空，则根结点地址入队*//* 队列不空时 *//* 访问队首结点的数据域 */ /* 将队首结点的左孩子入队 *//* 将队首结点的右孩子入队 */void Leafnum(BT *T) /* 求二叉树叶子结点数 */ { if(T)/* 若树不为空 */{ if(T->lchild==NULL && T->rchild==NULL)count++; Leafnum(T->lchild); Leafnum(T->rchild);} }/* 全局变量 count 为计数值，其初值为 0*/ /* 递归统计 T 的左子树叶子结点数 */ /* 递归统计 T 的右子树叶子结点数 */return rdep+1;void Nodenum(BT *T) { if(T) { count++;Nodenum(T->lchild); Nodenum(T->rchild);}} int TreeDepth(BT *T) { int ldep=0,rdep=0; 的深度 */ if(T==NULL) return 0; else { ldep=TreeDepth(T->lchild); rdep=TreeDepth(T->rchild); if(ldep>rdep)return ldep+1; else /* 若树不为空 *//* 全局变量 c ount 为计数值，其初值为0*/ /* 递归统计 T 的左子树结点数 */ /* 递归统计 T 的右子树结点数 *//* 求二叉树深度 *//* 定义两个整型变量，用以存放左、右子树/* 递归统计 T 的左子树深度 */ /* 递归统计 T 的右子树深度 */二叉树子系统");printf （"\n ================================================="）; printf （"\n| 1——建立一个新二叉树 |"）; printf （"\n| 2 --- 广义表表示法显示 |"）; printf （"\n| 3 --- 先序遍历 |"）; printf （"\n| 4 --- 中序遍历 |"）; printf （"\n| 5 --- 后序遍历 |"）; printf （"\n| 6 --- 层次遍历 |"）; printf （"\n| 7 --- 求叶子结点数目 |"）; printf （"\n| 8 --- 求二叉树总结点数目 |"）; printf （"\n| 9——求树深度 |"）; printf （"\n|0 --- 返回|"）;printf （"\n ================================================"）; printf （"\n 请输入菜单号（0-9 ）:"）;btree （）（BT *T=NULL; char ch1,ch2,a; ch1='y';while （ch1=='y'||ch1=='Y'） { MenuTree （）;scanf （"%c",&ch2）; getchar （）; switch （ch2） {case '1':printf （"请按先序序列输入二叉树的结点： \n"）;printf （"说明：输入结点后按回车（’0'表示后继结点为空）：\n"）; printf （"请输入根结点："）； T=CreateBTree （）;printf （"二叉树成功建立！ "）;break; case '2':printf （"二叉树广义表表示法如下： "）; ShowBTree （T ）;break; case '3':printf （"二叉树的先序遍历序列为： "）; PreOrder （T ）;break; case '4':printf(" 二叉树的中序遍历序列为： ");void （MenuTree （）/*显示菜单子函数*/printf （"\nInOrder(T);break;case '5':printf(" 二叉树的后序遍历序列为：");PostOrder(T);break;case '6':printf(" 二叉树的层次遍历序列为：");LevelOrder(T);break;case '7':count=0;Leafnum(T);printf("该二叉树有％~个叶子。

数据实验四程序代码中国矿业大学

中国矿业大学计算机学院实验报告
课程名称：数据结构
实验名称：搜索
班级：
姓名：
实验报告要求：
一、实验目的
1熟练掌握顺序搜索、折半搜索和索引搜索等基本搜索算法，熟悉这些算法适合在何种存储结构下实现
2熟练掌握二叉排序树的特性、建立方法以及动态搜索算法
3熟练掌握散列表的特点及构造方法
二、实验内容与代码
基本题
1、实现基于有序顺序表的折半搜索。
{
*addr = Hash(key);//求散列表的地址;
while(Head->elem[*addr] != key)//如果不为空，则发生冲突;
{
*addr = (*addr + 1) % iLenHashTable;
if (Head->elem[*addr] == NULLKEY || *addr == Hash(key))
}
//定义散列函数；
int Hash(int key)
{
return key / 2;//折半法;
}
//插入关键字进散列表;
void InsertHash(HashTable* Head,int key)
{
int iAddr = Hash(key);//求散列表的地址;
while(Head->elem[iAddr] != NULLKEY)//如果不为空，则发生冲突;
程序代码：
#include"stdafx.h"
#include<iostream>
#defineMaxSize100
usingnamespacestd;
//排序连续顺序文件的折半查找方法
intBin_Search(intkey[],intn,intk)

(完整word版)数据结构程序代码(C语言版)

(完整word版)数据结构程序代码(C语言版)P39一元多项式的表示#include〈stdio.h>#include〈stdlib.h>#include<math.h>typedef struct｛float coef;int expn;｝ElemType;typedef struct LNode｛ElemType data；struct LNode ＊next；}LNode，*LinkList;typedef LinkList polyn;void CreatP（polyn p，int m）｛int x;float y;int i;polyn q,s；q=p；for(i=1;i<=m;i++）｛s=（polyn)malloc(sizeof(LNode）);scanf（”%f%d",&y,＆x)；s—>data.coef=y；s—〉data。

expn=x；q->next=s；q=s;｝s->next=NULL；}void PrintP（polyn p）｛polyn q；q=p—〉next;printf("\n")；while（q)｛printf("％4。

1fx%d+",q-〉data.coef，q-〉data.expn）;q=q—>next；}}int cmp（ElemType a,ElemType b）｛if（a。

expn>b.expn) return -1;else if(a.expn==b.expn） return 0；else return 1；}void AddPolyn(polyn pa，polyn pb){ //完成多项式的相加，即：Pa=Pa+Pb，并销毁Pbpolyn ha，hb,qa，qb,qt；float sum;ElemType a，b;ha=pa；hb=pb;qa=ha-〉next；qb=hb->next;while(qa&＆qb){a=qa-〉data；b=qb—〉data;switch（cmp(a，b)){case —1： //Pa中当前结点的指数值小ha=qa；qa=ha—〉next;break;case 0： //两者指数值相等sum=a.coef+b.coef；if(fabs(sum)>1e-4）{//修改多项式Pa中当前结点的系数qa->data。

httpreadpudncomdownloads13sourcecodeasm54602数据结构实习

httpreadpudncomdownloads13sourcecodeasm54602数据结构实习报告二叉树的集合操作链表、堆栈和队列差不多上线性数据结构，而树则是一种某些特定特点的非线性的二维数据结构。

大伙儿明白，数组和链表在处理大批量数据的时候各有优劣，前者能够实现随机访问然而在添加、删除和移动数据时要作大量的数据移动；后者在修改数据时操作简便，但查找数据则颇为不便。

树能够说是两者的折衷，它尽管不能直截了当实现随机访问，然而查找的效率要比链表高的多，同时也能够快捷地实现数据的变动和修改，这使得它在查找领域用途广泛。

同时，由于树在层次划分方面的特性，使得它能够抽象许多现实问题，实现一些常用的算法。

二叉树是树中最常用到的一种，它在查找，排序，模拟子集问题等等方面都有着重要的应用。

这次程序设计要紧表达的确实是二叉树的集合操作。

以下是程序的详细分析过程:一、问题的描述和分析编写一段程序，对二叉树进行复合操作，包括创建一棵二叉树，显示二叉树的树型结构，对创建的二叉树进行先根、中根、后根三种方式进行遍历，同时打印出叶子结点，同时能够随时删除我们创建的二叉树，然后用循环语句将上述的操作封装起来，使之能够进行可重复、连续的操作。

二、算法的设计要实现上述的功能，我们第一要深刻的了解二叉树的数据结构，然后依据它的特点，着手如何去创建一棵二叉树，然后，用不同的方法对这棵二叉树进行不同的遍历，实现其它的功能，包括用户友好界面的实现等等一系列的后续操作。

三、数据结构的设计本程序要用到的数据类型struct BinTreeNode{ DataType info；PBinTreeNode llink；PBinTreeNode rlink；}；然后定义我们需要的指针类型typedef struct BinTreeNode *PBinTreeNode；/ 定义指向二叉树结点的指针类型/typedef PBinTreeNode *PBinTree; /定义指向树型结点的指针类型/四、程序需要用到的自定义函数1．创建一个二叉树根节点PBinTree Create_BinTreeRoot(void)2．创建一个二叉树的节点PBinTreeNode Create_BinTreeNode(void)3．创建一棵二叉树PBinTreeNode Create_BinTree(void)4．用先根的方法遍历一棵二叉树void preOrder(PBinTreeNode pbnode)5．用中根的方法遍历一棵二叉树void inOrder(PBinTreeNode pbnode)6．用后根的方法遍历一棵二叉树void postOrder(PBinTreeNode pbnode)7．打印出我们创建的二叉树的树型结构void outputTree(PBinTreeNode pbnode,int totalSpace)8．打印出二叉树的叶子结点void leaves(PBinTreeNode pbnode)9．开释我们所申请的所有结点空间void freeAllNodes(PBinTreeNode pbnode)10．判定我们输入的是否是合格的字符，我们把它们定义为a-z或者是A-Z之间的字符，用‘@’字符作为终止当前结点的标识符int isalphabet(char i)五、具体程序的实现1．PBinTreeNode Create_BinTreeNode(void)我们定义一个指向二叉树结点类型的指针PBinTreeNode，然后，申请一个二叉树结点大小的空间，对左右子结点赋为空。

数据结构实验6源码

顺序查找验证#include<stdio.h>#define MAX 100typedefstruct{intelem[MAX];int length;}SSTable;intSearch_Seq(SSTableST,int key); int main(){inti=1,m,n;inta,key;SSTable ST;printf("请输入数字个数\n"); scanf("%d",&n);printf("请输入数字序列\n"); scanf(" %d",&a);while(i<n){ST.elem[i++]=a;scanf("%d",&a);}ST.length=--i;printf("请输入需要查找的数字\n"); scanf("%d",&key);m=Search_Seq(ST,key);if(m==0)printf("无法找到\n");elseprintf("%d是第%d个数\n",key,m); getch();}intSearch_Seq(SSTableST,int key){ inti;ST.elem[0]=key;for(i=ST.length;ST.elem[i]!=key;--i); returni;}折半查找验证#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0void main(){int score[100];int length;intkey,i;printf("输入数据个数:\n");scanf("%d",&length);for(i=1;i<=length;i++){ printf("输入第%d个元素",i);scanf("%d",&score[i]);}printf("\n输入要查找的关键字\n");scanf("%d",&key);intlow,high,mid;low=1;high=length;while(low<=high){mid=(low+high)/2;if(score[mid]==key) //找到待查元素{printf("数据位置%d",mid);system("pause");}else if(key<score[mid])high=mid-1; //继续在前半区间进行查找else if(key>score[mid])low=mid+1; //继续在后半区间进行查找}printf("无此数据");system("pause");}二叉排序树的建立#include<stdio.h>#include<stdlib.h> typedefintdatatype;typedefstruct node{datatype key;struct node *lchild,*rchild;}bsnode;typedefbsnode *bstree; voidinsertbstree(bstree *t,datatype x) {bstreef,p;p = *t;while(p){f = p;if(x < p->key)p = p ->lchild;elsep = p ->rchild;}p =(bstree)malloc(sizeof(bsnode));p->key = x;p->lchild=p->rchild=NULL;if(*t == NULL)*t = p;else{if(x < (f->key))f->lchild = p;elsef->rchild = p;}}bstreecreatbstree(bstree t){datatype key;scanf("%d",&key);while(key != -1){insertbstree(&t,key);scanf("%d",&key);}return t;}voidinorder(bstree t){if (t){inorder(t->lchild);printf("%d ",t->key);inorder(t->rchild);}}voidqorder(bstree t){ if(t){printf("%d ",t->key);qorder(t->lchild);qorder(t->rchild);}}voidhorder(bstree t){if(t){horder(t->lchild);horder(t->rchild);printf("%d ",t->key);}}int main(){bstree t = NULL,p;printf("请输入一个-1为结束标记的结点序列:\n");p = creatbstree(t);printf("中序遍历：");inorder(p);printf("\n");printf("先序遍历：");qorder(p);printf("\n");printf("后序遍历：");horder(p);system("pause");return 0;}#include <stdio.h>#include <malloc.h>#define INIT_MAXSIZE 10typedefstructLnode{int data;structLnode *next;}Lnode, *ListLink; //建立链表结点typedefstruct{intpos;ListLinkfirstnode; //建立数组结点}HashBox;typedefstruct{HashBoxHArrary[INIT_MAXSIZE]; //建立哈希数组(哈希表的地址表头) }HashArray;void InitHashList(HashArray&l, int input[], int account); //建立哈希表void VistHashList(HashArray&l); //遍历输出哈希表int main(void){ int account = 0, i = 0, input[256];HashArray l;printf("请输入要插入哈希表元素的个数:");scanf("%d", &account);printf("请输入要插入哈希表的元素:");for (i = 0; i< account; i++){ scanf("%d", &input[i]);}InitHashList(l, input, account);printf("\n哈希表如下:\n");VistHashList(l);return 0;}void InitHashList(HashArray&l, int input[], int account) //建立哈希表{ inti = 0, j = 0, pos = 0;ListLink q, p;charch = 'A';for (i = 0; i< INIT_MAXSIZE; i++) //初始化哈希表头{ l.HArrary[i].pos = ch++;l.HArrary[i].firstnode = NULL;}for (i = 0; i< account; i++){ pos = input[i] % INIT_MAXSIZE; //计算元素地址q = new Lnode; //申请结点q->data = input[i];q->next = NULL;if(l.HArrary[pos].firstnode == NULL)//判断当前地址表头是否还没有元素连入l.HArrary[pos].firstnode = q;else{ p = l.HArrary[pos].firstnode;while (p->next != NULL){ p = p->next; //找到链表表尾}p->next = q; //将要插入的结点接入表尾}}}void VistHashList(HashArray&l) //输出哈希表{ ListLink p;inti;for (i = 0; i< INIT_MAXSIZE; i++){ printf("%c. ", l.HArrary[i].pos);p = l.HArrary[i].firstnode;while (p != NULL){ printf("->%d", p->data);p = p->next;}printf("\n");}}。

数据结构课程设计交通咨询系统实验参考代码

数据结构课程设计交通咨询系统实验参考代码#include<stdio.h>#include<stdlib.h>#define MVNum 100//最大顶点数#define Maxint 32767enum boolean{FALSE,TRUE};typedef char VertexType;typedef int Adjmatrix;typedef struct{VertexType vexs[MVNum];//顶点数组，类型假定为charAdjmatrix arcs[MVNum][MVNum];//邻接矩阵，类型假定为int 型}MGraph;int D1[MVNum],P1[MVNum];int D[MVNum][MVNum],P[MVNum][MVNum];/*建立有向图的储存结构*/void CreateMGraph(MGraph * G,int n,int e){//采用邻接矩阵表示法构造有向图G，n、e表示图的当前顶点数和边数int i,j,k,w;for(i=1;i<=n;i++)//输入顶点信息G->vexs[i]=(char)i;for(i=1;i<=n;i++)for(j=1;j<=n;j++)G->arcs[i][j]=Maxint;//初始化邻接矩阵printf("输入%d条边人i、j及w：\n",e);for(k=1;k<=e;k++)//读入e条边，建立邻接矩阵{scanf("%d,%d,%d",&i,&j,&w);G->arcs[i][j]=w;}printf("有向图人存储结构建立完毕！\n");}/*迪杰斯特拉算法*/void Dijkstra(MGraph *G,int v1,int n){//利用迪杰斯特拉算法，求出有向图G的v1顶点到其他顶点v 的最短路径P[v]及权D[v]int D2[MVNum],P2[MVNum];int v,i,w,min;enum boolean S[MVNum];for(v=1;v<=n;v++)//初始化S和D{S[v]=FALSE;//置空最短路径终点集D2[v]=G->arcs[v1][v];//置初始的最短路径值if(D2[v]<Maxint)P2[v]=v1;//v1是v的前趋（双亲）elseP2[v]=0;//v无前趋（双亲）}D2[v1]=0;S[v1]=TRUE;//S集初始时只有源点，距离为0for(i=2;i<n;i++)//其余n-1个顶点{min=Maxint;for(w=1;w<=n;w++)if(!S[w] && D2[w]<min){ v=w;min=D2[w]; }//w顶点离v1顶点更近S[v]=TRUE;for(w=1;w<=n;w++)//更新当前最短路径及距离if(!S[w]&&(D2[v]+G->arcs[v][w]<D2[w])) { D2[w]=D2[v]+G->arcs[v][w];P2[w]=v;}}printf("路径长度，路径\n");for(i=1;i<=n;i++){ printf("%5d",D2[i]);printf("%5d",i); v=P2[i];while(v!=0){printf("<-%d",v);v=P2[v];}printf("\n");}}/*费洛伊德算法*/void Floyd(MGraph *G,int n){//利用费洛伊德算法，求出最短路径int i,j,k;for(i=1;i<=n;i++)for(j=1;j<=n;j++){if(G->arcs[i][j]!=Maxint)P[i][j]=j;elseP[i][j]=0;D[i][j]=G->arcs[i][j];}for(k=1;k<=n;k++){for(i=1;i<=n;i++)for(j=1;j<=n;j++){ if(D[i][k]+D[k][j]<D[i][j]){D[i][j]=D[i][k]+D[k][j];P[i][j]=P[i][k];}}}}void main(){MGraph *G;int n,e,v,w,k;int xz=1;G=(MGraph *)malloc(sizeof(MGraph));printf("输入图中顶点个数和边数n，e：");scanf("%d,%d",&n,&e);CreateMGraph(G,n,e);//建立图的存储结构while(xz!=0){printf("***********求城市之间的最短距离***********\n");printf("================================= =========\n");printf("1.求一个城市到所有城市的最短距离\n");printf("2.求任意的两个城市之间的最短距离\n");printf("================================== ========\n");printf("请选择：1或2，选择0 退出：\n");scanf("%d",&xz);if(xz==2){Floyd(G,n);////调用费洛伊德算法printf("输入源点和终点：v，w：\n");scanf("%d,%d",&v,&w);k=P[v][w];if(k==0)printf("顶点 %d 到 %d 无路径！\n",v,w);else{printf("从顶点 %d 到 %d 最短路径是 %d",v,w,v); while(k!=w){printf("->%d",k);k=P[k][w];//k为v的后继顶点}printf("->%d",k);//输出后继顶点printf("路径长度：%d\n",D[v][w]);}}elseif(xz==1){printf("求单源路径，输入源点v;");scanf("%d",&v);Dijkstra(G,v,n);//调用迪杰斯特拉算法}}printf("结束求最短路径，再见！\n");}。

数据结构—多项式求和

实验一多项式求和实验一、程序验证1、源代码：#include<iostream.h>//cout,cin#include"process.h"//exit()#define Max 20typedef struct{float coef;int exp;}PolyArray[Max];struct PolyNode{float coef;int exp;PolyNode *next;};class Poly{private:PolyNode *head;public:Poly();//构造函数，建立空多项式~Poly();//析构函数，释放多项式void Create(PolyArray a,int n);//键盘输入，创建多项式链表void Disp();//多项式显示void Sort();//有序表排序void Add (Poly LB);//多项式加//void Substract(PolyNode * hbQ);//多项式减//void Multiply(PolyNode * hb);//多项式乘};Poly::Poly(){ //创建一空多项式head=new PolyNode;head->next=NULL;}Poly::~Poly(){//释放多项式所占空间PolyNode *p;while(head!=NULL){//从头结点开始，依次释放结点p=head;head=head->next;delete p;}head=NULL;//头结点指向空}void Poly::Disp (){PolyNode *p;p=head->next;while(p!=NULL){cout<<p->coef <<"x^"<<p->exp<<'\t' ;p=p->next ;}cout<<endl;}void Poly::Create (PolyArray a,int n){//由多项式数组创建多项式链表PolyNode *s,*r;int i;r=head;for(i=0;i<n;i++){s=new PolyNode;s->coef =a[i].coef;s->exp =a[i].exp;s->next =NULL;r->next =s;r=s;}}void Poly::Sort(){PolyNode *p,*q,*r;p=head->next ;if(p!=NULL){r=p->next ;//r指向p的后继结点p->next =NULL;//构造只有一个结点的有序表p=r;while(p!=NULL){r=p->next;q=head;while(q->next!=NULL && q->next ->exp < p->exp )q=q->next ;//在有序表中插入*p的前驱结点*q p->next =q->next ;//*p插入到*q之后q->next =p;p=r;}}}void Poly::Add(Poly LB){float sum;PolyNode *pa,*pb,*qa,*qb;pa=head;qa=pa->next;pb=LB.head ;qb=pb->next;while (qa!=NULL && qb!=NULL ){if (qa->exp < qb->exp ){//pa=qa;qa=qa->next; }else if ( qa->exp > qb->exp ){ //pb->next =qb->next;qb->next=qa;pa->next=qb;pa=qb;qb=pb->next;}else{//sum=qa->coef+qb->coef;if (sum==0 ){//pa->next=qa->next;delete qa;qa=pa->next;pb->next=qb->next;delete qb;qb=pb->next;}else{qa->coef=sum;pa=qa; qa=qa->next;pb->next=qb->next;delete qb;qb=pb->next;}}}//whileif(qb!=NULL)qa->next=qb;//}//Addvoid main(){Poly LA,LB;PolyArray a={{7.0,0},{3.0,1},{9.0,8},{5.0,16}};PolyArray b={{8.0,1},{22,7},{-9.0,8}};LA.Create (a,4);LB.Create (b,3);cout<<"原多项式A为：";LA.Disp ();cout<<"原多项式B为：";LB.Disp ();LA.Sort ();LB.Sort ();cout<<"有序多项式A为：";LA.Disp ();cout<<"有序多项式B为：";LB.Disp();LA.Add (LB);cout<<"和多项式为：";LA.Disp ();}2、运行结果：实验二有序表合并一、实验设计1、问题描述把两个有序表归并为一个有序表。

数据结构实验程序参考

printf(" ===========================\n");
printf(" Seqential list operation\n");
printf(" 1. creat\n");
printf(" 2. insert\n");
printf(" 3. delete\n");
printf(" 4. print \n");
scanf("%d",&x);
n=LocatElem_L(head,x);
printf("The location of %d is :%d.",x,n);
getch();break;
case '6': n=ListLength_L(head);
printf("The length of the link_list is: %d.",n);
scanf("%d",&n);
k=Delete_Linklist( &head, n, &x);
if(k) printf("The deleted number is %d.",x);
getch();break;
case '4': print(head);break;
case '5': printf("input a number to locate. x=");
L->data[j+1]=L->data[j]; /*元素右移*/
L->data[i-1]=e; /*插入元素e*/

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

第一个程序，未运行验证 #include #include #include #include #define letter #define N 2400 #define MAX 100 typedef struct{ unsigned int weight; unsigned int parent,lchild,rchild; }HTNode; void Select(HTNode *HT,int i,int &s1,int &s2) { //在HT[1,...,i-1]选择parent为0且weight最小的2个结点，序号分别为s1,s2 int j; s2=0; for(j=1;j<=i;j++) if(HT[j].parent==0) {s1=j;break;} for(j=s1+1;j<=i;j++) if(HT[j].parent==0) { if(HT[j].weight{s2=s1;s1=j;} else if(s2==0||HT[j].weight} }

void HuffumanCoding(HTNode *HT,char **HC,int w[],int n) { //w存放的是n个字符的权值（>0)，构造最优树HT //HC用于存放n个字符的编码。 int i,m,f,c,j,s1,s2,start; char *cd=0; HTNode *p=0; if(n<=1) return; m=2*n-1; for(p=HT+1,i=1;i<=n;i++,p++) { p->weight=w[i-1];p->parent=0;p->lchild=0; p->rchild=0;} for(;i<=m;i++,p++) { p->weight=0;p->parent=0;p->lchild=0; p->rchild=0;} for(i=n+1;i<=m;i++) {

Select(HT,i-1,s1,s2); //注意：值传递的形参并不能用来改变实参的值 //在HT[1,...,i-1]选择parent为0且weight最小的2个结点，序号分别为s1,s2 HT[s1].parent=i; HT[s2].parent=i; HT[i].lchild=s1;HT[i].rchild=s2; HT[i].weight=HT[s1].weight+HT[s2].weight; } #ifdef letter //预编译 //无栈非递归遍历最优数，求最优编码

int p1=m; int cdlen=0; cd=new char[n]; for(i=1;i<=m;i++) HT[i].weight=0; while(p1) { if(HT[p1].weight==0) { //向左遍历 HT[p1].weight=1; if(HT[p1].lchild!=0) {p1=HT[p1].lchild;cd[cdlen++]='0';} else if(HT[p1].rchild==0){ //对于最优树，这个条件可以去掉 HC[p1]=new char[cdlen+1]; cd[cdlen]='\0'; strcpy(HC[p1],cd); } } else if(HT[p1].weight==1) { //向右遍历 HT[p1].weight=2; if(HT[p1].rchild!=0) {p1=HT[p1].rchild;cd[cdlen++]='1';} } else { //从结点向上退 HT[p1].weight=0; p1=HT[p1].parent; cdlen--; } } delete []cd; cout<<"无栈非递归求霍夫曼编码"<}

#else //从叶子到根逆向求每个字符的最优编码 cd=new char[n]; cd[n-1]='\0'; for(i=1;i<=n;i++) { start=n-1; for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent) if(HT[f].lchild==c) cd[--start]='0'; else cd[--start]='1';//为了区分权值比较小的2个字符 HC[i]=new char[n-start]; for(j=start;jHC[i][j-start]=cd[j]; //把cd[start,...,n-1]复制给HC[i] } delete []cd; cout<<"从叶子到根求霍夫曼编码"<} #endif

int main() {

int i; HTNode HT[2*N]; char *HC[N+1]; int w[N]; //每个符号对应的出现几率，根据它写出每个符号的编码 srand(time(NULL)); for(i=0,w[0]=1,w[1]=2;i// w[i]=w[i-1]+w[i-2]+1; //当w数组满足 w[i]>=w[i-1]+w[i-2]+1时，编码的情况最坏，即此时树最深 w[i]=rand()%MAX+1; HuffumanCoding(HT,HC,w,N); for(i=1;iprintf("%d 's huffumancode is %s\n",w[i-1],HC[i]); printf("\n"); /* for(i=1;i<2*N;i++) printf("%d--%d--%d--%d\n",HT[i].weight,HT[i].parent,HT[i].lchild,HT[i].rchild);*/ printf("\n"); return 1; }

/* void translate(char code[],int n,char *parentcode) { // 译码 p=m; k=0; for(i=0;i{ if(str[i]=='0') { p=HT[p].lchild; if(p==0) { str[k,...,i]-> 译成原来的字符//即在HC中查找与之相匹配的字符串 k=i+1; p=m; }

} else //即str[i]=='1' { p=HT[p].lchild; if(p==0) { str[k,...,i]-> 译成原来的字符//即在HC中查找与之相匹配的字符串 k=i+1; p=m; } } } }

第二个程序未运行 C语言的 #include #define max 500 typedef struct { char data; int weight; int parent; int left; int right; }huffnode; typedef struct { char cd[max]; int start; }huffcode; char elem[1000]; char input[1000]; int weight[1000]={0}; int m=0; int find_char(char a[],char c,int n) { int i; for(i=0;i<=n;i++) { if(a[i]==c) return i; } return -1; } int get_elem_weight() { int i,n=-1; for(i=0;i<100;i++) elem[i]=' '; char c; while(1) { c=getchar(); input[m++]=c; if(c==10) break; else if(c!=' ') { if(find_char(elem,c,n)==-1) { n++; elem[n]=c; weight[n]=1; } else weight[find_char(elem,c,n)]+=1; } } printf("除空格和回车之外各字符的出现频率如下：\n"); for(i=0;i<=n;i++) { printf("%c %d",elem[i],weight[i]); printf("\n"); } return n+1; } main() { huffnode ht[2*max]; huffcode htd[max],d; int i,k,f,l,r,n,c,m1,m2,j; printf("请输入一个字符串，以回车结束\n"); n=get_elem_weight(); for(i=1;i<=n;i++) { ht[i].data =elem[i-1]; ht[i].weight =weight[i-1]; } for(i=1;i<=2*n-1;i++) ht[i].parent =ht[i].left =ht[i].right =0; for(i=n+1;i<=2*n-1;i++) { m1=m2=32767; l=r=0; for(k=1;k<=i-1;k++)