数据结构第四次实验报告
天津理工大学数据结构实验报告4
附录（可包括源程序清单或其它说明）#include <stdio.h>#include <string>#define MAX_NAME 10#define MAX_INFO 80typedef char InfoType;typedef char V ertexType[MAX_NAME]; // 字符串类型#define MAX_VERTEX_NUM 20typedef enum{unvisited,visited}VisitIf;typedef struct EBox{VisitIf mark; // 访问标记int ivex,jvex; // 该边依附的两个顶点的位置struct EBox *ilink,*jlink; // 分别指向依附这两个顶点的下一条边InfoType *info; // 该边信息指针}EBox;typedef struct{V ertexType data;EBox *firstedge; // 指向第一条依附该顶点的边}V exBox;typedef struct{V exBox adjmulist[MAX_VERTEX_NUM];int vexnum,edgenum; // 无向图的当前顶点数和边数}AMLGraph;typedef int QElemType;typedef struct QNode{// 单链表的链式存储结构QElemType data; //数据域struct QNode *next; //指针域}QNode,*QueuePtr;typedef struct{QueuePtr front,//队头指针，指针域指向队头元素rear; //队尾指针，指向队尾元素}LinkQueue;// 若G中存在顶点u,则返回该顶点在无向图中位置;否则返回-1int LocateV ex(AMLGraph G,V ertexType u){int i;for(i=0;i<G.vexnum;++i)if(strcmp(u,G.adjmulist[i].data)==0)return i;return -1;}int CreateGraph(AMLGraph *G){ // 采用邻接表存储结构,构造无向图G int i,j,k,l,IncInfo;char s[MAX_INFO];V ertexType va,vb;EBox *p;printf("请输入无向图G的顶点数,边数: ");scanf("%d,%d",&(*G).vexnum,&(*G).edgenum);printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);for(i=0;i<(*G).vexnum;++i){ // 构造顶点向量scanf("%s",(*G).adjmulist[i].data);(*G).adjmulist[i].firstedge=NULL;}printf("请顺序输入每条边的两个端点(以空格作为间隔):\n");for(k=0;k<(*G).edgenum;++k){// 构造表结点链表scanf("%s%s%*c",va,vb); // %*c吃掉回车符i=LocateV ex(*G,va); // 一端j=LocateV ex(*G,vb); // 另一端p=(EBox*)malloc(sizeof(EBox));p->mark=unvisited; // 设初值p->ivex=i;p->jvex=j;p->info=NULL;p->ilink=(*G).adjmulist[i].firstedge; // 插在表头(*G).adjmulist[i].firstedge=p;p->jlink=(*G).adjmulist[j].firstedge; // 插在表头(*G).adjmulist[j].firstedge=p;}return 1;}V ertexType* GetVex(AMLGraph G,int v){ // 返回v的值if(v>=G.vexnum||v<0)exit(0);return &G.adjmulist[v].data;}// 返回v的第一个邻接顶点的序号。
山东大学数据结构第四次实验实验报告
实验4 排序的编程与实现实验目的：掌握常用的排序方法，并掌握C语言实现排序算法的方法；了解各种排序方法过程及依据原则，并掌握各种排序方法的时间复杂度和稳定性的分析方法。
实验原理：参照课本p.220页内容中的 Figure7.2；课本p.223页内容中的Figure7.4;p.228,Figure7.8;p.232-233, Figure7.9-7.10; p240-243, Figure 7.12-7.15.实验内容：统计成绩【问题描述】：给出n个学生的考试成绩表，每条信息由姓名和分数组成，利用排序算法完成以下任务：1)按照分数高低次序，打印出每个学生在考试中获得的名次，分数相同的为同一名次。
2)按照名次列出每个学生的姓名和分数【要求】学生的考试成绩需要从键盘输入数据建立，同时要设计输出格式。
实验要求：1)能够采用常用的排序算法中的一种实现以上两个任务；实验步骤：一、实验源程序#include<stdio.h>#include <string.h>#include<stdlib.h>#include <conio.h>void Input(int n); \\实现从键盘输入学生姓名和分数的功能void Ranking(int n); \\实现根据学生成绩进行排序的功能struct student \\结构体，存放学生姓名及分数{char name[8];int score;} R[101];int main ( ) \\主程序{int x;printf("请输入需要录入信息的学生个数(不超过100): ");scanf ("%d",&x);Input(x);printf("学生成绩排名如下:\n ");printf(" 排名学生姓名成绩\n ");Ranking(x);getch();return 0;}void Input(int n) \\从键盘输入学生姓名和分数{int i;printf("请输入学生的姓名和成绩: \n");for (i=0; i<n; i++){printf ("学生姓名:");scanf ("%s", R[i].name);printf ("此学生的成绩:");scanf ("%d", &R[i].score);}}void Ranking(int n) \\根据学生成绩进行排序{int num=1,number=0, i, j, max=0;for (i=0; i<n; i++) \\外循环，将学生成绩从高到低进行排序{max=i;for (j=i+1; j<n; j++){if (R[j].score>R[i].score) \\内循环，如果排在后面的分数高于前面的，则进行结构体内容互换{max=j;R[100]=R[max];R[max]=R[i];R[i]=R[100];}}number=number+1; \\记录学生排名名次if ((i>0)&&(R[i].score<R[i-1].score)){num=number;}if(num==1)printf(" %3d %s%6d\n", num, R[i].name, R[i].score);elseprintf(" %4d %s%6d\n", num, R[i].name, R[i].score);}}二、实验结果①从键盘上输入学生姓名和分数信息，这里选择输入5个学生信息（上限人数程序中已经设置为100）。
数据结构实验报告(四)
《数据结构》实验报告班级：学号：姓名：实验四二叉树的基本操作实验环境：Visual C++实验目的：1、掌握二叉树的二叉链式存储结构；2、掌握二叉树的建立，遍历等操作。
实验内容：通过完全前序序列创建一棵二叉树，完成如下功能：1)输出二叉树的前序遍历序列；2)输出二叉树的中序遍历序列；3)输出二叉树的后序遍历序列；4)统计二叉树的结点总数；5)统计二叉树中叶子结点的个数；实验提示：//二叉树的二叉链式存储表示typedef char TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;一、程序源代码#include <stdio.h>#include <stdlib.h>#define MAXSIZE 30typedef char ElemType;typedef struct TNode *BiTree;struct TNode {char data;BiTree lchild;BiTree rchild;};int IsEmpty_BiTree(BiTree *T) { if(*T == NULL)return 1;elsereturn 0;}void Create_BiTree(BiTree *T){char ch;ch = getchar();//当输入的是"#"时，认为该子树为空if(ch == '#')*T = NULL;//创建树结点else{*T = (BiTree)malloc(sizeof(struct TNode)); (*T)->data = ch; //生成树结点//生成左子树Create_BiTree(&(*T)->lchild);//生成右子树Create_BiTree(&(*T)->rchild);}}void TraverseBiTree(BiTree T) { //先序遍历if(T == NULL)return;else {printf("%c ",T->data);TraverseBiTree(T->lchild);TraverseBiTree(T->rchild);}}void InOrderBiTree(BiTree T) { //中序遍历if(NULL == T)return;else {InOrderBiTree(T->lchild);printf("%c ",T->data);InOrderBiTree(T->rchild);}}void PostOrderBiTree(BiTree T) {if(NULL == T)return;else {InOrderBiTree(T->lchild);InOrderBiTree(T->rchild);printf("%c ",T->data);}}int TreeDeep(BiTree T) {int deep = 0;if(T){int leftdeep = TreeDeep(T->lchild);int rightdeep = TreeDeep(T->rchild);deep = leftdeep+1 > rightdeep+1 ? leftdeep+1 : rightdeep+1;}return deep;}int Leafcount(BiTree T, int &num) {if(T){if(T->lchild ==NULL && T->rchild==NULL){num++;printf("%c ",T->data);}Leafcount(T->lchild,num);Leafcount(T->rchild,num);}return num;}void LevelOrder_BiTree(BiTree T){//用一个队列保存结点信息,这里的队列采用的是顺序队列中的数组实现 int front = 0;int rear = 0;BiTree BiQueue[MAXSIZE];BiTree tempNode;if(!IsEmpty_BiTree(&T)){BiQueue[rear++] = T;while(front != rear){//取出队头元素，并使队头指针向后移动一位tempNode = BiQueue[front++];//判断左右子树是否为空,若为空，则加入队列 if(!IsEmpty_BiTree(&(tempNode->lchild))) BiQueue[rear++] = tempNode->lchild;if(!IsEmpty_BiTree(&(tempNode->rchild))) BiQueue[rear++] = tempNode->rchild;printf("%c ",tempNode->data);}}}int main(void){BiTree T;BiTree *p = (BiTree*)malloc(sizeof(BiTree));int deepth,num=0 ;Create_BiTree(&T);printf("先序遍历二叉树:\n");TraverseBiTree(T);printf("\n");printf("中序遍历二叉树:\n");InOrderBiTree(T);printf("\n");printf("后序遍历二叉树:\n");PostOrderBiTree(T);printf("\n层次遍历结果：");LevelOrder_BiTree(T);printf("\n");deepth=TreeDeep(T);printf("树的深度为:%d",deepth);printf("\n");printf("树的叶子结点为:");Leafcount(T,num);printf("\\n树的叶子结点个数为:%d",num);return 0;}二、运行结果(截图)三、遇到的问题总结通过死循环的部分可以看出，在判断时是不能进入结点为空的语句中的，于是从树的构建中寻找问题，最终发现这一条语句存在着问题：这里给T赋值为空，也就是给整个结构体地址赋值为空，但是我们的目的是给该结构体中的内容，即左孩子的地址指向的内容赋为空。
数据结构实验报告4
数据结构实验报告——实验4学号：：得分：______________一、实验目的1、复习线性表的逻辑结构、存储结构及基本操作；2、掌握顺序表和（带头结点）单链表；3、了解有序表。
二、实验容1、（必做题）假设有序表中数据元素类型是整型，请采用顺序表或（带头结点）单链表实现：（1）OrderInsert(&L, e, int (*compare)(a, b))//根据有序判定函数compare，在有序表L的适当位置插入元素e；（2）OrderInput(&L, int (*compare)(a, b))//根据有序判定函数compare，并利用有序插入函数OrderInsert，构造有序表L；（3） OrderMerge(&La, &Lb, &Lc, int (*compare)())//根据有序判定函数compare，将两个有序表La和Lb归并为一个有序表Lc。
2、（必做题）请实现：（1）升幂多项式的构造，升幂多项式是指多项式的各项按指数升序有序，约定系数不能等于0，指数不能小于0；（2）两个升幂多项式的相加。
三、算法描述（采用自然语言描述）1.创建带头节点的链表，输入两个有序表数据La Lb归并两个有序表得有序表Lc输出三个有序表输入需插入数据e将e插入有序表Lc输出插入e后的Lc2.创建链表按指数升序输入多项式得序数和指数输出多项式按指数升序输入第二个多项式得序数和指数两个多项式相加输出第二个多项式和两个多项式得和四、详细设计（画出程序流程图）1.2.五、程序代码（给出必要注释）1.#include<stdio.h>#include<malloc.h>typedef struct LNode{int date;struct LNode *next;} LNode,*Link;typedef struct LinkList{Link head;//头结点int lenth;//链表中数据元素的个数} LinkList;int compare (LinkList *L,int e)//有序判定函数 compare {int Lc=0;Link p;p=L->head;p=p->next;while(p!=NULL){if(e>p->date){p=p->next;Lc++;}elsereturn Lc;}return Lc;}void OrderInsert (LinkList *L,int e,int (*compare)())//根据有序判定函数compare，在有序表L 的适当位置插入元素e；{Link temp,p,q;int Lc,i;temp=(Link)malloc(sizeof(LNode));temp->date=e;p=q=L->head;p=p->next;Lc=(*compare)(L,e);if(Lc==L->lenth){while(q->next!=NULL){q=q->next;}q->next=temp;temp->next=NULL;}else{for(i=0; i<Lc; i++){p=p->next;q=q->next;}q->next=temp;temp->next=p;}++L->lenth;}void OrderMerge (LinkList *La,LinkList *Lb,int (*compare)())//根据有序判定函数 compare ,将两个有序表 La 和 Lb 归并为一个有序表{int i,Lc=0;Link temp,p,q;q=La->head->next;while(q!=NULL){p=Lb->head;temp=(Link)malloc(sizeof(LNode));temp->date=q->date;Lc=(*compare)(Lb,q->date);if(Lc==Lb->lenth){while(p->next!=NULL){p=p->next;}p->next=temp;temp->next=NULL;}else{for(i=0; i<Lc; i++){p=p->next;}temp->next=p->next;p->next=temp;}q=q->next;++Lb->lenth;}}LinkList *Initialize (LinkList *NewList){int i;Link temp;NewList=(LinkList *)malloc((2+1)*sizeof(LinkList));for(i=0; i<2+1; i++){temp=(Link)malloc(sizeof(LNode));temp->date=0;temp->next=NULL;(NewList+i)->head=temp;(NewList+i)->lenth=0;}return NewList;}void Insert (LinkList *NewList){int a,i;char c;printf("在第1个表中插入数据,输入“ N ”再对下个表插入数据 \n");for(i=0; i<2; i++){while(1){scanf("%d",&a);c=getchar();if(c=='N'){if(i<2-2)printf("在第 %d个表中插入数据,输入“ N ”再对下个表插入数据 \n",i+2); else if(i==2-2)printf("在第 %d个表中插入数据,输入“ N ”结束。
数据结构实验报告_实验报告_
数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程，那么，下面是小编给大家整理收集的数据结构实验报告，供大家阅读参考。
数据结构实验报告1一、实验目的及要求1)掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们。
本实验训练的要点是“栈”和“队列”的观点;二、实验内容1) 利用栈，实现数制转换。
2) 利用栈，实现任一个表达式中的语法检查(选做)。
3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);三、实验流程、操作步骤或核心代码、算法片段顺序栈：Status InitStack(SqStack &S){S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status DestoryStack(SqStack &S){free(S.base);return OK;}Status ClearStack(SqStack &S){S.top=S.base;return OK;}Status StackEmpty(SqStack S){if(S.base==S.top)return OK;return ERROR;}int StackLength(SqStack S){return S.top-S.base;}Status GetTop(SqStack S,ElemType &e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;Status Push(SqStack &S,ElemType e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackTraverse(SqStack S){ElemType *p;p=(ElemType *)malloc(sizeof(ElemType));if(!p) return ERROR;p=S.top;while(p!=S.base)//S.top上面一个...p--;printf("%d ",*p);}return OK;}Status Compare(SqStack &S){int flag,TURE=OK,FALSE=ERROR; ElemType e,x;InitStack(S);flag=OK;printf("请输入要进栈或出栈的元素："); while((x= getchar)!='#'&&flag) {switch (x){case '(':case '[':case '{':if(Push(S,x)==OK)printf("括号匹配成功!\n\n"); break;case ')':if(Pop(S,e)==ERROR || e!='('){printf("没有满足条件\n");flag=FALSE;}break;case ']':if ( Pop(S,e)==ERROR || e!='[')flag=FALSE;break;case '}':if ( Pop(S,e)==ERROR || e!='{')flag=FALSE;break;}}if (flag && x=='#' && StackEmpty(S)) return OK;elsereturn ERROR;}链队列：Status InitQueue(LinkQueue &Q) {Q.front =Q.rear=(QueuePtr)malloc(sizeof(QNode));if (!Q.front) return ERROR;Q.front->next = NULL;return OK;}Status DestoryQueue(LinkQueue &Q) {while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}Status QueueEmpty(LinkQueue &Q){if(Q.front->next==NULL)return OK;return ERROR;}Status QueueLength(LinkQueue Q){int i=0;QueuePtr p,q;p=Q.front;while(p->next){i++;p=Q.front;q=p->next;p=q;}return i;}Status GetHead(LinkQueue Q,ElemType &e) {QueuePtr p;p=Q.front->next;if(!p)return ERROR;e=p->data;return e;}Status ClearQueue(LinkQueue &Q){QueuePtr p;while(Q.front->next ){p=Q.front->next;free(Q.front);Q.front=p;}Q.front->next=NULL;Q.rear->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e) {QueuePtr p;p=(QueuePtr)malloc(sizeof (QNode));if(!p)return ERROR;p->data=e;p->next=NULL;Q.rear->next = p;Q.rear=p; //p->next 为空return OK;}Status DeQueue(LinkQueue &Q,ElemType &e) {QueuePtr p;if (Q.front == Q.rear)return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p)Q.rear = Q.front; //只有一个元素时(不存在指向尾指针) free (p);return OK;}Status QueueTraverse(LinkQueue Q){QueuePtr p,q;if( QueueEmpty(Q)==OK){printf("这是一个空队列!\n");return ERROR;}p=Q.front->next;while(p){q=p;printf("%d<-\n",q->data);q=p->next;p=q;}return OK;}循环队列：Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base)exit(OWERFLOW);Q.front=Q.rear=0;return OK;}Status EnQueue(SqQueue &Q,QElemType e){if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}int QueueLength(SqQueue Q){return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status DestoryQueue(SqQueue &Q){free(Q.base);return OK;}Status QueueEmpty(SqQueue Q) //判空{if(Q.front ==Q.rear)return OK;return ERROR;}Status QueueTraverse(SqQueue Q){if(Q.front==Q.rear)printf("这是一个空队列!");while(Q.front%MAXQSIZE!=Q.rear){printf("%d<- ",Q.base[Q.front]);Q.front++;}return OK;}数据结构实验报告2一.实验内容：实现哈夫曼编码的生成算法。
数据结构实验报告
《数据结构》实验报告姓名：学号：班级：学院：实验一单链表实验(一)实验目的1.理解线性表的链式存储结构。
2.熟练掌握动态链表结构及有关算法的设计。
3.根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关算法。
(二)实验任务编写算法实现下列问题的求解1.求链表中第i个结点的指针（函数），若不存在，则返回NULL。
2.在第i个结点前插入值为x的结点。
3.删除链表中第i个元素结点。
4.在一个递增有序的链表L中插入一个值为x的元素，并保持其递增有序特性。
5.将单链表L中的奇数项和偶数项结点分解开，并分别连成一个带头结点的单链表，然后再将这两个新链表同时输出在屏幕上，并保留原链表的显示结果，以便对照求解结果。
6.求两个递增有序链表L1和L2中的公共元素，并以同样方式连接成链表L3。
(三)主要仪器设备PC机，Windows操作平台，Visual C++(四)实验分析顺序表操作：定义一个顺序表类，该类包括顺序表的存储空间、存储容量和长度，以及构造、插入、删除、遍历等操作的方法(五)源程序头文件文件名：linklist.h#include<iostream>using namespace std;struct node{int data;node *next;};class list{public:list();int length()const{return count; //求链表长度}~list();void create(); //链表构建，以0为结束标志void output(); //链表输出int get_element(const int i)const; //按序号取元素node *locate(const int x) const; //搜索对应元素int insert(const int i,const int x); //插入对应元素int delete_element(const int i); //删除对应元素node *get_head(){return head; //读取头指针}void insert2(const int x);friend void SplitList(list L1, list&L2, list &L3);friend void get_public(list L1, list L2, list &L3);private:int count;node *head;};list::list(){head=new node;head->next=NULL;count=0;}void list::create() //链表构建，以0为结束标志{int x;cout<<"请输入当前链表，以0为结束符。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程，通过本次实验，旨在加深对常见数据结构（如链表、栈、队列、树、图等）的理解和应用，提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
操作系统为 Windows 10。
三、实验内容1、链表的实现与操作创建一个单向链表，并实现插入、删除和遍历节点的功能。
对链表进行排序，如冒泡排序或插入排序。
2、栈和队列的应用用栈实现表达式求值，能够处理加、减、乘、除和括号。
利用队列实现银行排队系统的模拟，包括顾客的到达、服务和离开。
3、二叉树的遍历与操作构建一棵二叉树，并实现前序、中序和后序遍历。
进行二叉树的插入、删除节点操作。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历。
四、实验步骤及结果1、链表的实现与操作首先，定义了链表节点的结构体：｀｀｀cppstruct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；｀｀｀插入节点的函数：｀｀｀cppvoid insertNode(ListNode& head, int val) ｛ListNode newNode ＝ new ListNode(val)；head ＝ newNode;｝ else ｛ListNode curr ＝ head;while （curr>next!＝ NULL) ｛curr ＝ curr>next;｝curr>next ＝ newNode;｝｝｀｀｀删除节点的函数：｀｀｀cppvoid deleteNode(ListNode& head, int val) ｛if （head ＝＝ NULL) ｛return;｝ListNode temp ＝ head;head ＝ head>next;delete temp;return;｝ListNode curr ＝ head;while （curr>next!＝ NULL ＆＆ curr>next>data!＝ val) ｛curr ＝ curr>next;｝if （curr>next!＝ NULL) ｛ListNode temp ＝ curr>next;curr>next ＝ curr>next>next;delete temp;｝｝｀｀｀遍历链表的函数：｀｀｀cppvoid traverseList(ListNode head) ｛ListNode curr ＝ head;while （curr!＝ NULL) ｛std:：cout ＜＜ curr>data ＜＜＂＂；curr ＝ curr>next;｝std:：cout ＜＜ std:：endl;｝｀｀｀对链表进行冒泡排序的函数：｀｀｀cppvoid bubbleSortList(ListNode& head) ｛if （head ＝＝ NULL ｜｜ head>next ＝＝ NULL) ｛return;｝bool swapped;ListNode ptr1;ListNode lptr ＝ NULL;do ｛swapped ＝ false;ptr1 ＝ head;while （ptr1-＞next!＝ lptr) ｛if （ptr1-＞data ＞ ptr1-＞next>data) ｛int temp ＝ ptr1-＞data;ptr1-＞data ＝ ptr1-＞next>data;ptr1-＞next>data ＝ temp;swapped ＝ true;｝ptr1 ＝ ptr1-＞next;｝lptr ＝ ptr1;｝ while （swapped)；｝｀｀｀测试结果：创建了一个包含 5、3、8、1、4 的链表，经过排序后，输出为 1 3 4 5 8 。
数据结构实验报告4(电大)
实验报告四图的存储方式和应用（学科：数据结构）姓名单位班级学号实验日期成绩评定教师签名批改日期实验名称：实验四图的存储方式和应用4.1建立图的邻接矩阵【问题描述】根据图中顶点和边的信息编制程序建立图的邻接矩阵。
【基本要求】（1）程序要有一定的通用性。
（2）直接根据图中每个结点与其他结点的关联情况输入相关信息，程序能自动形成邻接矩阵【测试用例】【实现提示】（1）对图的顶点编号。
（2）在上图中，以顶点1为例，因为顶点2,3,4与顶点1关联，可以输入信息1 2 3 4，然后设法求出与顶点1关联的结点，从而求得邻接矩阵中相应与顶点1的矩阵元素。
实验图4-1【实验报告内容】设计程序代码如下:#include<stdio.h>#define MaxVertexNum 5#define MaxEdgeNum 20#define MaxValue 1000typedef int VertexType;typedef VertexType vexlist [MaxVertexNum];typedef int adjmatrix [MaxVertexNum] [MaxVertexNum];void Createl(vexlist Gv,adjmatrix GA,int n,int e){int i,j,k,w;printf("输入%d个顶点数据\n",n);for(i=0;i<n;i++) scanf("%d",&Gv[i]);for(i=0;i<n;i++)for(j=0;j<n;j++){if(i==j) GA[i][j]=0;else GA[i][j]=MaxValue;}Printf（“输入一条边的两端点序号i和j及边上的权w\n”）;printf("输入%d条无向带权边\n",e);for(k=1;k<=e;k++){scanf("%d%d%d",&i,&j,&w);GA[i][j]=GA[j][i]=w;}}void main(){vexlist vl;adjmatrix a;Createl(vl,a,5,8);}。
《数据结构》 实验报告4
xxx实验报告课程名称数据结构实验名称实验四排序操作系部班级姓名学号实验时间2012 年12月10日时分～时分地点机位评语指导教师：成绩一、实验目的1. 掌握常用的排序方法，并掌握用高级语言实现排序算法的方法；2. 深刻理解排序的定义和各种排序方法的特点，并能加以灵活应用；3. 了解各种方法的排序过程及其时间复杂度的分析方法。
二、实验内容统计成绩：给出n个学生的考试成绩表，每条信息由姓名和分数组成，试设计一个算法：（1）按分数高低次序，打印出每个学生在考试中获得的名次，分数相同的为同一名次；（2）按名次列出每个学生的姓名与分数。
三、实验步骤1. 定义结构体。
2. 定义结构体数组。
3. 定出主程序，对数据进行排序。
四、程序主要语句及作用1. 程序原代码如下：#include <string.h>#include "stdio.h"#include <malloc.h>#include <conio.h>typedef struct BSTNODE{int data;struct BSTNODE *lchild;struct BSTNODE *rchild;}BSTNODE;BSTNODE* initBST(int n, BSTNODE *p){if(p==NULL){p=(BSTNODE*)malloc(sizeof(BSTNODE));p->lchild=NULL;p->rchild=NULL;p->data=n;}else if(n>p->data)p->rchild=initBST(n,p->rchild);elsep->lchild=initBST(n,p->lchild);return p;}void inorder(BSTNODE *BT){if(BT!=NULL){inorder(BT->lchild);printf("%d ",BT->data);inorder(BT->rchild);}}BSTNODE *search_btree(BSTNODE *root,int key) { if (!root){printf("Emptu btree\n"); return root; }while(root->data!=key){ if(key<root->data)root=root->lchild;elseroot=root->rchild;if(root==0){ printf("Search Failure\n");break ;}} /* while(root->info!=key) */if (root !=0)printf("Successful search\n key=%d\n",root->data);return root ;} /* *search_btree(root,key) */int main(){BSTNODE *p=NULL;int i,n,sd;int a[100];printf("enter the number of nodes:");scanf("%d",&n);printf("enter the number of the tree:");for(i=0;i<n;i++){scanf("%d",&a[i]);p=initBST(a[i],p);}inorder(p);printf("\n please input search data:");scanf("%d",&sd);search_btree(p,sd);getch();return 1;}2. 运行结果截图：五、总结体会本次试验让我学习到了很多也认识到了自己的不足：1.大部分的时间都用在了编程上，主要是因为C语言掌握的问题，C语言基础不好特别是对于C语言中链表的一些定义和基本操作不够熟练，导致在编程过程中还要不断的拿着c语言的教材查找，所以今后还要对C语言多练习，多动手，多思考。
《数据结构》实验指导及实验报告栈和队列
《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的1、掌握栈的结构特性及其⼊栈，出栈操作；2、掌握队列的结构特性及其⼊队、出队的操作，掌握循环队列的特点及其操作。
⼆、实验预习说明以下概念1、顺序栈：2、链栈：3、循环队列：4、链队三、实验内容和要求1、阅读下⾯程序，将函数Push和函数Pop补充完整。
要求输⼊元素序列1 2 3 4 5 e，运⾏结果如下所⽰。
#include#include#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base; /*定义栈底部指针*/ElemType *top; /*定义栈顶部指针*/int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int push(SqStack *S,ElemType e); /*⼊栈操作*/int Pop(SqStack *S,ElemType *e); /*出栈操作*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;S->top=S->base;int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return 1}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top!=S->base){*e=*--S->top;return 1;}elsereturn 0;}/*Pop*/int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");PrintStack(&ss);return 0;}●算法分析：输⼊元素序列1 2 3 4 5，为什么输出序列为5 4 3 2 1？体现了栈的什么特性？2、在第1题的程序中，编写⼀个⼗进制转换为⼆进制的数制转换算法函数（要求利⽤栈来实现），并验证其正确性。
工作报告范文之数据结构查找实验报告范文
工作报告范文之数据结构查找实验报告范文【篇一：数据结构查找算法实验报告】数据结构实验报告实验第四章：实验:简单查找算法一．需求和规格说明：查找算法这里主要使用了顺序查找，折半查找，二叉排序树查找和哈希表查找四种方法。
由于自己能力有限，本想实现其他算法，但没有实现。
其中顺序查找相对比较简单，折半查找参考了书上的算法，二叉排序树查找由于有之前做二叉树的经验，因此实现的较为顺利，哈希表感觉做的并不成功，感觉还是应该可以进一步完善，应该说还有很大的改进余地。
二．设计思想：开始的时候提示输入一组数据。
并存入一维数组中，接下来调用一系列查找算法对其进行处理。
顺序查找只是从头到尾进行遍历。
二分查找则是先对数据进行排序，然后利用三个标志，分别指向最大，中间和最小数据，接下来根据待查找数据和中间数据的比较不断移动标志，直至找到。
二叉排序树则是先构造，构造部分花费最多的精力，比根节点数据大的结点放入根节点的右子树，比根节点数据小的放入根节点的左子树，其实完全可以利用递归实现，这里使用的循环来实现的，感觉这里可以尝试用递归。
当二叉树建好后，中序遍历序列即为由小到大的有序序列，查找次数不会超过二叉树的深度。
这里还使用了广义表输出二叉树，以使得更直观。
哈希表则是利用给定的函数式建立索引，方便查找。
三．设计表示：四．实现注释：查找后对查找数据进行了统计。
二叉排序树应该说由于有了之前二叉树的基础，并没有费太大力气，主要是在构造二叉树的时候，要对新加入的节点数据和跟数据进行比较，如果比根节点数据大则放在右子树里，如果比根节点数据小则放入左子树。
建立了二叉树后，遍历和查找就很简单了。
而哈希表，应该说自我感觉掌握的很不好，程序主要借鉴了书上和ppt上的代码，但感觉输出还是有问题，接下来应该进一步学习哈希表的相关知识。
其实原本还设计了其他几个查找和排序算法，但做到哈希表就感觉很困难了，因此没有继续往下做，而且程序还非常简陋，二叉树和哈希表的统计部分也比较薄弱，这也是接下来我要改进的地方。
武汉纺织大学《数据结构》实验报告4
武汉纺织大学《数据结构》实验报告班级：级管工类专业班姓名：序号： 1实验时间： 2014 年 5 月 30 日指导教师：实验四：查找基本操作与应用一、实验目的：1、掌握顺序查找、折半查找、哈希查找的基本方法和操作过程2、掌握查找效率的分析方法二、实验内容：1、编写程序，实现顺序查找操作，可参考书本P260示例程序。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长10），依次输入10个数据元素（对元素存放的先后顺序没有要求），并按照存储顺序输出所有元素；②、输入带查找关键字，在顺序表中进行顺序查找；③、输出查找结果。
2、编写程序，实现有序表折半查找操作，可参考书本P263示例程序。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长10），依次输入10个数据元素（要求所有元素按照递增顺序排列），并按照存储顺序输出所有元素；②、输入带查找关键字，在有序表中进行折半查找；③、输出查找结果。
3、编写程序，实现哈希表查找操作。
实验步骤：①、在Java语言编辑环境中新建程序，建立一个顺序表（表长12），依次输入10个数据元素，并按照存储顺序输出所有元素；②、输入带查找关键字，在哈希表中进行查找；③、输出查找结果。
已知：哈希函数为H(key)=key MOD 11，采用开放地址法、线性探测再散列解决冲突，输入元素为{ 55,19,31,23,68,20,27,9,10,79}。
三、操作步骤：Test1代码：T1.Javapackage First;import java.util.Scanner;public class T1 {public static void main(String[] args) {int i;int n;Scanner sc=new Scanner(System.in);SeqList<Integer> sl=new SeqList<Integer>(10);sl.insert(0, 3);sl.insert(6, 1);sl.insert(6, 0);sl.insert(8, 6);sl.insert(7, 2);sl.insert(2,9);sl.insert(4, 1);sl.insert(5, 4);sl.insert(6,8);sl.insert(1, 7);System.out.print("顺序表中各元素:");System.out.println(sl.toString());System.out.println("<查找元素>");System.out.print("输入元素:");i=sc.nextInt();n=sl.indexOf(i);if(n!=-1)System.out.println("元素" +i+"位于第"+n+"位");}}LList.javapackage First;public interface LList<T> {boolean isEmpty();int length();T get(int i);void set(int i, T x);void insert(int i, T x);T remove(int i);void removeAll();}SeqList .javapackage First;public class SeqList<T> implements LList<T> { private Object[] element;private int len;public SeqList(int size) {this.element = new Object[size];this.len = 0;}public SeqList() {this(64);}public boolean isEmpty() {return this.len == 0;}public int length() {return this.len;}public T get(int i) {if (i >= 0 && i < this.len)return (T) this.element[i];return null;}public void set(int i, T x) {if (x == null)return;if (i >= 0 && i < this.len)this.element[i] = x;elsethrow new IndexOutOfBoundsException(i + "");}public String toString() {String str = "(";if (this.len > 0)str += this.element[0].toString();for (int i = 1; i < this.len; i++)str += "," + this.element[i].toString();return str + ")";}public void insert(int i, T x){if(x==null)return;if(this.len==element.length){Object[]temp = this.element;this.element = new Object[temp.length*2];for(int j=0;j<temp.length;j++)this.element[j]=temp[j];}if(i<0)i=0;if(i>this.len)i=this.len;for(int j=this.len-1;j>=i;j--)this.element[j+1]=this.element[j];this.element[i]=x;this.len++;}public void append(T x){ insert(this.len,x); } public T remove(int i){if(this.len==0||i<0||i>=this.len)return null;T old = (T)this.element[i];for(int j=i;j<this.len-1;j++)this.element[j]=this.element[j+1];this.element[this.len-1]=null;this.len--;return old;}public void removeAll(){ this.len=0; } public int indexOf(T key){if(key!=null)for(int i=0;i<this.len;i++)if(this.element[i].equals(key))return i;return -1;}public T search(T key){int find=this.indexOf(key);return find==-1?null:(T)this.element[find]; }public boolean contain(T key){return this.indexOf(key)>=0;}}运行结果：Test2代码：T2.javapackage Second;public class T2 {public static void main(String[] args) {int a[]={5,11,23,15,17,38,90,121,132,164}; int search=38;int lower=0;int temp=a.length-1 ;int index=-1;while(lower<=temp){index = (lower+temp)/2;int currentValue=a[index];if(currentValue==search){break;}else if(currentValue<search){lower=index+1;}else{temp = index-1;}}for(int i = 0;i < 10; i++){System.out.print(a[i]);System.out.println(" ");}if(lower<=temp){System.out.println("查找元数"+search);System.out.println("位于数组中第"+(index+1)+"位");}else{System.out.println("里面没有这个元素"); }}}运行结果：Test3代码：T3.javapackage Three;import java.util.Scanner;public class T3 {static HashTable T=null;public static void createHashtable() throws Exception { T=new HashTable(20);Scanner sc=new Scanner(System.in);System.out.print("请输入待查找的关键字的个数:");int n=sc.nextInt();System.out.print("请输入查找表中的关键字序列:");for (int i = 0; i < n; i++) {T.hashInsert(sc.nextInt());}}public static void main(String[]args)throws Exception{System.out.println("<创建哈希表>");createHashtable();System.out.println("创建的哈希表为:");T.Hashdisplay();System.out.print("输入待查找的关键字:");Scanner sc=new Scanner(System.in);int key=sc.nextInt();RecordNode p=T.hashSearch(key);if ((p.getKey()).compareTo(key)==0)System.out.println(" 查找成功!");elseSystem.out.println(" 查找失败!");}}KeyType.javapackage Three;public class KeyType implements Comparable<KeyType> {private int key;public KeyType() {}public KeyType(int key) {this.key = key;}public int getKey() {return key;}public void setKey(int key) {this.key = key;}public String toString() {return key + "";}public int compareTo(KeyType another) {int thisVal = this.key;int anotherVal = another.key;return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));}}class HashTable {private RecordNode[] table;public HashTable(int size) {this.table = new RecordNode[size];for (int i = 0; i < table.length; i++) {table[i] = new RecordNode(0);}}public int hash(int key) {return key % 11;}public RecordNode hashSearch(int key) {int i = hash(key);int j = 0;while ((table[i].getKey().compareTo(0) != 0)&& (table[i].getKey().compareTo(key) != 0)&& (j < table.length)) {j++;i = (i + j) % 11;}if (j >= table.length) {System.out.println("哈希表已满");return null;} elsereturn table[i];}public void hashInsert(int key) {RecordNode p = hashSearch(key);if (p.getKey().compareTo(0) == 0)p.setKey(key);elseSystem.out.println(" 此关键字记录已存在或哈希表已满");}void Hashdisplay() {for (int i = 0; i < table.length; i++)System.out.print(table[i].getKey().toString() + " ");System.out.println();}}RecordNode.javapackage Three;public class RecordNode {private Comparable key;private Object element;public Object getElement() {return element;}public void setElement(Object element) {this.element = element;}public Comparable getKey() {return key;}public void setKey(Comparable key) {this.key = key;}public RecordNode() {this.key = null;}public RecordNode(Comparable key) {this.key = key;}}运行结果：四、实验收获和建议这次实验我掌握了顺序查找、折半查找、哈希查找的基本方法和操作过程，掌握查找效率的分析方法，对查找方法有了更进一步的认识。
数据结构实验—顺序栈的实现
实验四顺序栈的操作一.实验目的掌握顺序栈的基本操作：初始化栈、判栈空、入栈、出栈、取栈顶数据元素等运算及程序实现方法。
二.实验内容（1）定义栈的顺序存取结构。
（2）分别定义顺序栈的基本操作（初始化栈、判栈空、入栈、出栈等）。
（3）设计一个测试主函数进行测试。
三.实验要求（1）根据实验内容编写程序，上机调试并获得运行结果（2）撰写实验报告四.准备工作本次实验将会建立下图所示顺序栈，并会根据此顺序栈进行新增，删除等操作五.关键操作思路与算法(1)定义顺序栈利用顺序存储方式实现的栈称为顺序栈。
栈中的数据元素可用一个预设的足够长度的一维数组来实现:datatype data［MAXNUM］，栈底位置一般设置在数组的低端处，在整个进栈和出栈的过程中不改变，而栈顶位置将随着数据元素进栈和出栈而变化，为了指明当前栈顶在数组中的位置，一般用top作为栈顶指针，算法如下；1.#define MAXNUM 1002.typedef int datatype;3.4.typedef struct{5. datatype data[MAXNUM];6.int top;7.}SeqStack;(2)置空栈算法思路；(1)向系统申请栈空间(2)初始化栈顶指针top，置空栈标志top=-1算法如下；1.void StackSetNull(SeqStack *s)2.{3. s->top=-1;4.}（3）判断是否为空栈算法如下；1.//判断栈是否为空2.int StackIsEmpty(SeqStack *s)3.{4.if(s->top == -1)5.return TRUE;6.else7.return FALSE;8.}9.}（4）入栈算法思路；（1）判断当前栈空间是否已满，若已满，则返回0，未满则转第（2步）（2）栈顶指针top++（3）将元素赋值到top所指位置作为新的栈顶元素，成功返回值1.算法如下；1.//进栈2.int StackPush(SeqStack *s,datatype x)3.{4.if(s->top==MAXNUM-1)5. {6. printf("栈上溢出!\n");7.return FALSE;8. }9.else10. {11. s->top=s->top+1;12. s->data[s->top]=x;13.return TRUE;14. }15.}（五）出栈算法思路；（1）判断当前栈空间是否为空，若为空，则返回0，不为空则转第（2步）（2）将top指针所指位置元素值取出（3）栈顶指针top--指向新的栈顶元素，成功返回值1.算法如下；1.//出栈2.int StackPop(SeqStack *s,datatype *x)3.{4.if(s->top==-1)5. {6. printf("栈下溢出!\n");7.return FALSE;8. }9.else10. {11. * x=s->data[s->top];12.//s->top=s->top-1;13. s->top --;14.return TRUE;15. }16.}（六）读栈顶元素算法如下；1.//读栈顶2.datatype StackGetTop(SeqStack *s)3.{4.if(s->top==-1)5. {6. printf("栈下溢出!\n");7.return FALSE;8. }9.else10.return (s->data[s->top]);11.}六.注意事项（1）置空栈需要向系统申请空间后再设置空栈标志，而判断空栈则无须申请空间直接判断空栈标志是否成立。
山东大学数据结构实验报告四
山东大学软件工程学院数据结构课程实验报告学号：姓名：班级：软件工程2014级2班实验题目：矩阵和散列表实验学时：实验日期： 2015.11.11实验目的：掌握特殊矩阵和稀疏矩阵。
掌握散列表及其应用。
硬件环境：实验室软件环境：Vistual Studio 2013实验步骤与内容：实验内容：1、创建三对角矩阵类，采用按列映射方式，提供store和retrieve 方法。
2、创建下三角矩阵类，采用按列映射方式，提供store和retrieve 方法。
3、创建稀疏矩阵类，采用行主顺序把稀疏矩阵映射到一维数组中，实现稀疏矩阵的转置和两个稀疏矩阵的加法操作。
4、使用散列表设计实现一个字典，假设关键字为整数且D为961，在字典中插入随机产生的500个不同的整数，实现字典的建立和搜索操作。
分别使用线性开型寻址和链表散列解决溢出。
代码体：ChainHashTableNode.h#pragma once#include"ChainHashTableNode.h"using namespace std;class ChainHashTable{public:ChainHashTable(int divisor);~ChainHashTable();bool Insert(int k);bool Search(int k);void print();private:int d;ChainHashTableNode *ht;};ChainHashTableNode.cpp#include"ChainHashTable.h"#include<iostream>using namespace std;ChainHashTable::ChainHashTable(int divisor) {d = divisor;ht = new ChainHashTableNode[d];}bool ChainHashTable::Insert(int k){int j = k%d;if (ht[j].Insert(k)){return true;}else{return false;}}void ChainHashTable::print(){for (int i = 0; i < d; i++){ht[i].print();}}ChainHashTableNode.h#pragma once#include"Node.h"class ChainHashTableNode{public:ChainHashTableNode();bool Insert(int k);bool Search(int k);void print();private:Node *first;};ChainHashTableNode.cpp#include"ChainHashTableNode.h"#include<iostream>using namespace std; ChainHashTableNode::ChainHashTableNode() {first = 0;}bool ChainHashTableNode::Search(int k) {if (first == 0) return false;Node *current = first;while (current){if (current->value == k){return true;}current = current->link;if (current){if (current->value == k){return true;}}}return false;}bool ChainHashTableNode::Insert(int k) {if (Search(k)){cout << "已经存在此元素" << endl;return false;}else {Node *p = new Node();p->value = k;if (first == 0){first = p;return true;}else{p->link = first;first = p;return true;}}}void ChainHashTableNode::print(){Node *current = first;if (first){while (first){cout << first->value << " ";first = first->link;}cout << endl;first = current;}else {cout << -1 << endl;}}HashTable.h#pragma onceclass HashTable{public:HashTable(int divisor);~HashTable();int Search(int k);//搜索算法bool Insert(int e);void print();private:int hSearch(int k);int d;//除数int *ht;//桶，大小取决于d就是除数是多少bool *empty;//一维数组，用来存储第I个桶是否存入了元素};HashTable.cpp#include"HashTable.h"#include<iostream>using namespace std;HashTable::HashTable(int divisor){d = divisor;ht = new int[d];empty = new bool[d];for (int i = 0; i < d; i++){empty[i] = true;ht[i] = 0;}}HashTable::~HashTable(){delete[]ht;delete[]empty;}int HashTable::hSearch(int k)//搜索值为K的元素{int i = k%d;int j = i;do{if (ht[j] == k || empty[j]) return j;j = (j + 1) % d;} while (j != i);return j;}int HashTable::Search(int k)//搜索值为K的元素{int b = hSearch(k);if (ht[b] == k) return b;return -1;}bool HashTable::Insert(int e){int b = hSearch(e);if (empty[b]){ht[b] = e;empty[b] = false;return true;}else if (ht[b] == e){cout << "已经存在此元素" << endl;return false;}else{cout << "表已经满了" << endl;return false;}}void HashTable::print(){for (int i = 0; i < 961; i++){cout << ht[i] << " ";}cout << endl;return;}LowerTriangularMatrix.h#pragma onceclass LowerTriangularMatrix{public:LowerTriangularMatrix(int size);void Store(int x, int i, int j);//向矩阵里存储一个元素int Retrieve(int i, int j);//返回矩阵中的一个元素void print();private:int n;//矩阵维数int sum;//矩阵非零元素个数int *t;//用数组来存储矩阵};LowerTriangularMatrix.cpp#include"LowerTriangularMatrix.h"#include<iostream>using namespace std;LowerTriangularMatrix::LowerTriangularMatrix(int size){n = size;sum = n*(n + 1) / 2;t = new int[sum];}void LowerTriangularMatrix::Store(int x, int i, int j){if (i<0 || j<0 || i >= n || j >= n){cout << "下三角矩阵行列输入错误" << i << " " << j << endl;return;}else if (x == 0){cout << "下三角所添加的元素必须非零" << endl;return;}else if (i<j){cout << "下三角添加元素位置错误" << endl;return;}t[sum - ((n - j)*(n - j + 1) / 2) + (i - j)] = x;return;}int LowerTriangularMatrix::Retrieve(int i, int j){if (i<0 || j<0 || i >= (n - 1) || j >= (n - 1)){cout << "三对角矩阵行列输入错误" << endl;return -1;}else if (i >= j){return t[sum - ((n - j)*(n - j + 1) / 2) + (i - j)];}else{return 0;}}void LowerTriangularMatrix::print(){for (int i = 0; i < sum; i++){cout << t[i] << " ";}cout << endl;return;}Node.h#pragma onceclass Node{friend class ChainHashTableNode;private:int value;Node *link;};Node.cpp#include"Node.h"using namespace std;SparseMatrix.h#pragma once#include"Term.h"class SparseMatrix{public:SparseMatrix(int row, int col);void transpose();void Store(int x, int i, int j);//向矩阵里存储一个元素void Add(SparseMatrix &b);//两个稀疏矩阵相加void print();private:int row, col;//数组维数int sum;//元素个数int maxsum;//最多的元素个数Term *t;//存储的数组};SparseMatrix.cpp#include"SparseMatrix.h"#include<iostream>using namespace std;SparseMatrix::SparseMatrix(int r, int c){row = r;col = c;sum = 0;maxsum = r*c;t = new Term[maxsum];}void SparseMatrix::transpose(){Term *cur = new Term[maxsum];int *ColSize = new int[col];int *RowNext = new int[row];for (int i = 0; i < col; i++) ColSize[i] = 0;for (int i = 0; i < row; i++) RowNext[i] = 0;for (int i = 0; i < sum; i++) ColSize[t[i].col]++;//表示每一列的非零元素个数RowNext[0] = 0;for (int i = 1; i < col; i++) RowNext[i] = RowNext[i - 1] + ColSize[i - 1];//表示新矩阵中每一行的矩阵的前面的矩阵的个数//进入转置操作for (int i = 0; i < sum; i++){int j = RowNext[t[i].col]++;cur[j].value = t[i].value;cur[j].col = t[i].row;cur[j].row = t[i].col;}delete t;t = cur;}void SparseMatrix::Store(int x, int i, int j){t[sum].value = x;t[sum].row = i;t[sum].col = j;sum++;return;}void SparseMatrix::print(){for (int i = 0; i < sum; i++){cout << t[i].value << " ";}cout << endl;return;}void SparseMatrix::Add(SparseMatrix &b)//两个稀疏矩阵相加{if (col != b.col || row != b.row){cout << "两个矩阵行列不同无法相加" << endl;return;}int sa = 0;int sb = 0;Term *cur = new Term[maxsum];int k = 0;while (sa < sum || sb < b.sum){if (t[sa].col == b.t[sb].col&&t[sa].row == b.t[sb].row){cur[k].col = t[sa].col;cur[k].row = t[sa].row;cur[k].value = t[sa].value + b.t[sb].value;k++;sa++;sb++;}else if (t[sa].row < b.t[sb].row){cur[k].value = t[sa].value;cur[k].row = t[sa].row;cur[k].col = t[sa].col;k++;sa++;}else if (t[sa].row > b.t[sb].row){cur[k].value = b.t[sb].value;cur[k].row = b.t[sb].row;cur[k].col = b.t[sb].col;k++;sb++;}else if (t[sa].col < t[sb].col){cur[k].col = t[sa].col;cur[k].row = t[sa].row;cur[k].value = t[sa].value;k++;sa++;}else{cur[k].value = b.t[sb].value;cur[k].row = b.t[sb].row;cur[k].col = b.t[sb].col;k++;sb++;}}sum = k;delete t;t = cur;return;}Term.h#pragma onceclass Term{friend class SparseMatrix;private:int col, row;int value;};Term.cpp#include"Term.h"TridiagonalMatrix.h#pragma onceclass TridiagonalMatrix{public:TridiagonalMatrix(int size);void Store(int x, int i, int j);//向矩阵里存储一个元素int Retrieve(int i, int j);//返回矩阵中的一个元素void print();private:int n;//矩阵非0元素个数int *t;//用数组来存储矩阵};TridiagonalMatrix.cpp#include"TridiagonalMatrix.h"#include<iostream>using namespace std;TridiagonalMatrix::TridiagonalMatrix(int size){n = size;t = new int[3 * n - 2];}void TridiagonalMatrix::Store(int x, int i, int j){if (i<0 || j<0 || i >= n || j >= n){cout << "三对角矩阵行列输入错误" << i << " " << j << endl;return;}else if (x == 0){cout << "三对角矩阵所添加的元素必须非零" << endl;return;}else if (abs(i - j)>1){cout << "三对角矩阵添加元素位置错误" << endl;return;}switch (i - j){case -1:t[3 * j - 1] = x;break;case 0:t[3 * j] = x;break;case 1:t[3 * j + 1] = x;break;}return;int TridiagonalMatrix::Retrieve(int i, int j){if (i<0 || j<0 || i >= (n - 1) || j >= (n - 1)) {cout << "三对角矩阵行列输入错误" << endl;return -1;}else if (abs(i - j) <= 1){return t[3 * j + (i - j)];}else{return 0;}}void TridiagonalMatrix::print(){for (int i = 0; i < 3 * n - 2; i++){cout << t[i] << " ";}cout << endl;return;}Test.cpp#include<iostream>#include<cstring>#include<cstdlib>#include"TridiagonalMatrix.h"#include"LowerTriangularMatrix.h"#include"SparseMatrix.h"#include"HashTable.h"#include"ChainHashTable.h"using namespace std;int wei, num[100][100];void c(){for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)cin >> num[i][j];}int main(){int k = 0, l = 0;/*三对角矩阵实验开始测试数据4~10~3n-241 2 0 03 4 5 00 7 8 90 0 8 7*/cout << "请输入三对焦矩阵维数及内容：" << endl;cin >> wei;c();TridiagonalMatrix *TM = new TridiagonalMatrix(wei);for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)if (num[j][i] != 0)TM->Store(num[j][i], j, i);TM->print();cout << "请输入要查询的元素的位置" << endl;cin >> k >> l;l = TM->Retrieve(k, l);cout << "查询结果：" << l << endl;cout << "***********************************************" << endl;/*下三角矩阵实验开始测试数据4~10~n*(n+1)/241 0 0 02 3 0 04 5 6 07 8 9 -1*/cout << "请输入下三角矩阵维数及内容：" << endl;k = 0, l = 0;cin >> wei;c();LowerTriangularMatrix *LTM = new LowerTriangularMatrix(wei);for (int i = 0; i < wei; i++)for (int j = 0; j < wei; j++)if (num[j][i] != 0)LTM->Store(num[j][i], j, i);cout << "请输入要查询的元素的位置" << endl;cin >> k >> l;l = LTM->Retrieve(k, l);cout << "查询结果：" << l << endl;cout << "***********************************************" << endl;/*稀疏角矩阵实验开始测试数据4 54 51 0 0 0 20 3 0 0 04 0 05 00 6 7 0 84 58 0 7 6 00 5 0 0 40 0 0 3 02 0 0 0 19 0 7 6 20 8 0 0 44 0 0 8 02 6 7 0 9*/cout << "请输入稀疏矩阵的维数及内容：" << endl;cin >> k >> l;SparseMatrix *SM = new SparseMatrix(k, l);for (int i = 0; i < k; i++)for (int j = 0; j < l; j++){cin >> num[i][j];if (num[i][j])SM->Store(num[i][j], i, j);}cout << "稀疏矩阵为： ";SM->print();SM->transpose();cout << "转置后稀疏矩阵为： ";SM->print();SM->transpose();cout << "重新转置后稀疏矩阵为： ";cout << "矩阵相加开始，请输入要使用的矩阵维数及内容:" << endl;cin >> k >> l;SparseMatrix *SM2 = new SparseMatrix(k, l);for (int i = 0; i < k; i++)for (int j = 0; j < l; j++){cin >> num[i][j];if (num[i][j])SM2->Store(num[i][j], i, j);}cout << "新矩阵为： ";SM2->print();SM->Add(*SM2);cout << "矩阵相加后为： ";SM->print();cout << "***********************************************" << endl;cin.get();system("pause");/*使用散列表设计实现一个字典，假设关键字为整数且D为961，在字典中插入随机产生的500个不同的整数，实现字典的建立和搜索操作。
西北工业大学数据结构试验报告DS04
·实验题目：给定电文进行哈夫曼编码，给定编码进行哈夫曼译码。
要求电文存储在文件1中，编码后的结果存储在文件2中，给定编码存储在文件3中，译码后的结果存储在文件4中。
·实验目的：练习二叉树的使用，练习文件的操作。
一、需求分析1、输入的形式和输入值的范围：给定电文输入为字符型，可以输入30种不同的字符，可以输入空格，但空格不能转为二进制前缀码。
给定编码进行赫夫曼译码时，输入为无符号整型0和1。
2、输出的形式：编译后赫夫曼编码（对应字符和编码）输出分别为字符型和无符号整型。
给定电文进行赫夫曼编码输出为无符号整型0和1，电文保存在文件1中，编译所得的二进制前缀码保存在文件2中。
给定编码进行赫夫曼译码输出为字符型，给定的编码保存在文件3中，译码保存在文件4中。
3、程序所能达到的功能：可以电文不同字符数目小于等于30的电文进行赫夫曼编码，可以对给定编码(已经获得的赫夫曼编码对应的编码)进行译码4、测试数据：1）、加法：（输出：）请输入电文内容:（输入：）HELLO WORLD（程序输出：）H 101E 100L 01O 000W 111R 110D 001赫夫曼编码:101100010100011100011001001（文件1：）HELLO WORLD（文件2：）101100010100011100011001001（输出：）请输入需转换的编码:（输入：）101100010100011100011001001（程序输出：）转换后的电文:HELLOWORLD（文件3：）101100010100011100011001001（文件4：）HELLOWORLD二概要设计1、抽象数据类型的定义：树的定义：ADT Tree{数据对象D：D是具有相同特性的数据元素的集合。
数据关系R：若D为空集，则称为空树；若D仅含一个数据元素，则R为空集，否则R={H}，H是如下二元关系；（1）在D中存在唯一的称为根的数据元素root,它在关系H下无前驱；（2）若D-{root}≠Φ,则存在D-{root}的一个划分D1,D2…Dm(m>0),对任意j≠k(1<=j,k<=m有Dj∩Dk=Φ,且对任意的i(1<=i<=m),唯一存在数据元素xi∈Di,有<root,xi>∈H; （3）对应于D-{root}的划分，H-{<root,xi>,…,<root,xm>}有唯一的一个划分H1，H2,…,Hm(m>0)，对任意j≠k(1≤j,k≤m)有Hj∩Hk=NULL，且对任意i(1≤i≤m),Hi是Di上的二元关系，(Di,{Hi})是一棵符合本定义的树，称为根root的子树。
北理工数据结构实验报告4
《数据结构与算法统计》实验报告——实验四学院：班级：学号：姓名：一、实验目的1、熟悉VC 环境，学会使用C 语言利用顺序表解决实际问题。
2、通过上机、编程调试，加强对线性表的理解和运用的能力。
3、锻炼动手编程，独立思考的能力。
二、实验内容从键盘输入10个数，编程实现分别用插入排序、交换排序、选择排序算法进行排序，输出排序后的序列。
三、程序设计1、概要设计为了实现排序的功能，需要将输入的数字放入线性表中，进行进一步的排序操作。
(1)抽象数据类型：ADT SqList{数据对象：D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥数据关系：R1=11{,|,,1,2,,}i i i i a a a a D i n --<>∈= 基本操作：Input(Sqlist & L)操作结果：构造一个线性表L 。
output(SqList L)初始条件：线性表L 已存在。
操作结果：按顺序在屏幕上输出L 的数据元素。
BiInsertionsort (Sqlist L)初始条件：线性表L 已存在。
操作结果：对L 的数据元素进行折半插入排序。
QuickSort (Sqlist L)初始条件：线性表L 已存在。
操作结果：对L 的数据元素进行交换排序。
SelectSort(SqList &L)初始条件：线性表L 已存在。
操作结果：对L 的数据元素进行选择排序。
}ADT SqList⑵ 宏定义#define KeyType int#define MAXSIZE 10#define ok 1#define error 0⑶主程序流程由主程序首先调用Input(L)函数创建顺序表，先调用BiInsertionsort (L)函数进行折半插入排序，调用output(L)函数显示排序结果。
再调用QuickSort (L)函数进行交换排序，调用output (L)函数显示排序结果。
数据结构第4次实验报告
中国矿业大学计算机学院实验报告课程名称数据结构实验名称搜索班级计科11-3 姓名冯剑飞学号08113405 仪器组号_21-22机房_____ 实验日期2012年12月28号实验报告要求：1.实验目的 2.实验内容 3.实验步骤4.运行结果5.流程图6.实验体会一、实验目的1 熟练掌握顺序搜索、折半搜索和索引搜索等基本搜索算法，熟悉这些算法适合在何种存储结构下实现2 熟练掌握二叉排序树的特性、建立方法以及动态搜索算法3 熟练掌握散列表的特点及构造方法二、实验要求1 实验之前认真准备，编写好源程序。
2 实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。
3 不断积累程序的调试方法。
三、实验步骤1、阅读教材相关章节，了解程序架构。
2、根据伪代码编写实现可执行程序。
3、调试程序，提高程序健壮性。
4、输入多组数据，测试程序，寻找漏洞。
5、在关键部位写下注释，提高程序可读性。
四、实验内容基本题1、实现基于有序顺序表的折半搜索。
#include <iostream>using namespace std;struct nodeList{int number;char name[15];int CETgrade;};int main (){int search(nodeList nodeList[], int n, int v);nodeList nodeList[10]={{0,"zhangwei",545},\{1,"zengxiaoxian",456},\{2,"guangu",525},\{3,"lvziqiao",421},\{4,"zhangfei",343},\{5,"liubei",555},\{6,"caocao",546},\{7,"lvbu",400},\{8,"sunquan",567},\{9,"zhugeliang",654}};cout<<"-----编号---"<<"姓名--------"<<"成绩------"<<endl;for(int i=0;i<10;i++){cout<<" "<<nodeList[i].number<<" "<<nodeList[i].name<<" "<<nodeList[i].CETgrade<<endl;}cout<<"请输入要查找的编号（0到9）"<<endl;int v;cin>>v;int find=search(nodeList,10,v);cout<<"该编号学生的情况为"<<nodeList[find].number<<" "<<nodeList[find].name<<" "<<nodeList[find].CETgrade<<endl;return 0;}int search(nodeList nodeList[], int n, int v){int left, right, middle;left = 0, right = n - 1;while (left <= right){middle = (left + right) / 2;if (nodeList[middle].number > v){right = middle - 1;}else if (nodeList[middle].number < v){left = middle + 1;}else{return middle;}}return -1;}2、设单链表的结点是按关键字的值从小到大排列的，试写出对此表的搜索程序并调试。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构
姓名：詹盼
学号：V201441106
日期: 2015.11.14
成绩:_____
迷宫问题：
一：问题描述；
以一个m*m 的方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。
设计一个程序，对任意设定的迷宫，求出一条从入口的通道，或得出没有通路的结论。
二：概要设计；
存储结构采用了数组以及结构体来存储数据，在探索迷宫的过程中用到的栈，属于顺序存储结构。
/*八个方向的数组表示形式*/
int move[8][2]={{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1, 0},{-1, 1}};
/*用结构体表示位置*/
struct position
{
int x,y;
};
position stack[m*m+1];
源程序：
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<time.h>
int main(void)
{
int m=1;
while (m!=0)
{
#if 0
/* 数组不支持动态的定义*/
printf("输入m,使得为m*m的方阵迷宫(m>0 输入0 时退出:）\n");
scanf ("%d",&m);
#endif
m = 8;
printf("迷宫矩阵的大小为:%d * %d\n", m, m);
/*设定n*n的方阵迷宫*/
/*数组的形式表示八个方向*/
int move[8][2]={{0,1},{1,1},{1,0},
{1,-1},{0,-1},{-1,-1},{-1, 0},{-1, 1}};
/*用结构体表示位置*/
struct position
{
int x;
int y;
};
/*用于记录和输出迷宫探路中相关符号，包括1 .*/ char maze[10][10];
/*用栈来存储探路过程中的数据*/
position stack[64+1];
int top;/*栈顶*/
int i,x,y,ok;
position p;
srand(time(0)); /* 产生一个随机种子*/
for(x=1;x<=m;x++)
for(y=1;y<=m;y++)
maze[x][y]=48+rand()%2;
maze[1][1]='0';maze[m][m]='0'; /* 入口*/
for(x=0;x<=m+1;x++)
{
maze[x][0]='1';maze[x][m+1]='1'; /* 边界*/ }
for(y=0;y<=m+1;y++)
{
maze[0][y]='1';maze[m+1][y]='1'; /* 边界*/ }
p.x=1;p.y=1;
top=1;stack[top]=p;
maze[1][1]='.';
do{
p=stack[top];
ok=0;i=0;
while((ok==0)&&(i<8))
{
x=p.x+move[i][0];
y=p.y+move[i][1];
if(maze[x][y]=='0')
{
p.x=x;p.y=y;
stack[++top]=p;
maze[x][y]='.';
ok=1;
}
i++;
}
if(i==8)
{
maze[p.x][p.y]='*';
top--;
}
} while((top>0)&&((p.x!=m)||(p.y!=m)));
/*输出探路结果*/
if(top==0)
{
printf("没有路径\n");
}
else
{
printf("有路径\n");
}
/*输出探路迷宫留下的踪迹*/ #if 0
for(x=1;x<=m;x++)
{
printf("\n");
for(y=1;y<=m;y++)
printf("%c ",maze[x][y]);
}
#else
/*输出整个迷宫*/
for(x=0; x <= m + 1; x++)
{
printf("\n");
for(y=0;y<=m+1;y++)
printf("%c ",maze[x][y]);
}
#endif
printf("\n");
system("pause");
}
return 0;
}
运行结果：
总结：通过此次编译程序我懂得了编译程序的多种方法。