数据结构大作业(含源代码)
数据结构经典题目及c语言代码
数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。
以下是一个顺序表的经典题目及C语言代码实现:```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满,无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。
数据结构大作业-哈夫曼编码实验报告
一.构造过程①统计可知,字符串全长共59个字符,其中字符‘A’-‘F’的出现频数及对应概率(保留两位小数)如图所示:②将每个字符出现概率作为权重,则对于上述给定的6个权值{25,15,14,20,17,9},依次构造6棵只有根节点的二叉树,共同构成森林F;③在森林F中,选取权重最小和次小的两颗树,分别作为新二叉树的左子树、右子树,且该树根节点权值赋左右子树权值之和;④从森林F中删除已选中的两棵子树,把新得到的二叉树加入F 中;⑤重复③④,直到森林F中仅留下一棵树时,得到最终的哈夫曼树HF如图所示:⑥对上述哈夫曼树,将其树中的每个左分支赋0、右分支赋1,则从根结点开始到叶子结点,各分支路径分别得到对应的二进制串,即为给定的每个字符的哈夫曼编码。
二、代码实现源代码如下:#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <stdlib.h>#include <string.h>#define N 6 //指定的编码字符数#define M (2 * N - 1) //HT结点数#define MAXWEIGHT 100typedef struct { //哈夫曼树的存储表示int weight;int parent, lchild, rchild;}HTNode;typedef HTNode HuffmanTree[M + 1];typedef char* HuffmanCode[N + 1]; //哈夫曼编码表void Select(HuffmanTree HT, int n, int& s1, int& s2);void CreateHuffmanTree(HuffmanTree& HT, int* w, int n); void CreateHuffmanCode(HuffmanTree HT, HuffmanCode& HC); void PrintHC(HuffmanCode HC, char ch[]);int main() {HuffmanTree HT;HuffmanCode HC;int w[N + 1];char ch[N + 1];printf("Please input %d characters & its weight(e.g. A 25):\n", N);for (int i = 1; i <= N; i++) {scanf("%c %d", &ch[i], &w[i]);getchar();}CreateHuffmanTree(HT, w, N);CreateHuffmanCode(HT, HC);PrintHC(HC, ch);return 0;}void Select(HuffmanTree HT, int n, int& s1, int& s2) { int i, min = 0, temp = MAXWEIGHT;for (i = 1; i <= n; i++) {if (!HT[i].parent) {if (temp > HT[i].weight) {temp = HT[i].weight;min = i; //最小值作为新树左子树}}}s1 = min;for (i = 1, min = 0, temp = MAXWEIGHT; i <= n; i++) { if ((!HT[i].parent) && i != s1) {if (temp > HT[i].weight) {temp = HT[i].weight;min = i; //次小值作为新树右子树}}}s2 = min;}void CreateHuffmanTree(HuffmanTree& HT, int* w, int n) { //创建哈夫曼树HTint i, s1, s2;if (n <= 1) return; //树为空或仅有根节点for (i = 1; i <= M; ++i) { //初始化HT[i].weight = w[i];HT[i].parent = 0;HT[i].lchild = 0;HT[i].rchild = 0;}for (i = n + 1; i <= M; ++i) { //创建新二叉树Select(HT, i - 1, 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;}}void CreateHuffmanCode(HuffmanTree HT, HuffmanCode& HC) {int i, start, c, f;char cd[N];cd[N - 1] = '\0'; //编码结束符for (i = 1; i <= N; i++) { //对于第i个待编码字符即第i个带权值的叶子节点start = N - 1; //开始start指向结束符位置c = i;f = HT[i].parent; //f指向当前结点的双亲while (f) { //从叶上溯,到根节点跳出if (HT[f].lchild == c)cd[--start] = '0'; //左孩子elsecd[--start] = '1'; //右孩子c = f;f = HT[f].parent;}HC[i] = new char[N - start];strcpy(HC[i], &cd[start]); //复制结果到编码表,用于输出}}void PrintHC(HuffmanCode HC, char ch[]) { //打印哈夫曼编码表for (int i = 1; i <= N; i++)printf("\n%c: %s\n", ch[i], HC[i]);}三,输出各个字母的哈夫曼编码:四、算法分析1、哈夫曼编码是最优前缀编码:对包括N个字符的数据文件,分别以它们的出现概率构造哈夫曼树,利用该树对应的哈夫曼编码对报文进行编码,得到压缩后的最短二进制编码;2、算法自底而上地构造出对应最优编码的二叉树HT,它从n个叶子结点开始,识别出最低权重的两个对象,并将其合并;当合并时,新对象的权重设置为原两个对象权值之和,一共执行了|n| - 1次合并操作;3、是贪心算法:每次选择均为当下的最优选择,通过合并来构造最优树得到对应的哈夫曼编码;4、复杂度:①时间复杂度:有n个终端节点,构成的哈夫曼树总共有2n-1个节点,Select函数的时间复杂度为O(n),嵌套for循环,因此建立哈夫曼树的时间复杂度为O(n^2),创建哈弗曼编码表的时间复杂度为O(n^2);②空间复杂度:算法中临时占用存储空间大小为数组第0号空间,其耗费的空间复杂度为O(1)。
数据结构上机实验源代码
数据结构上机实验源代码栈的应用十进制数转换为八进制数,逆序输出所输入的数实验代码://stack.h,头文件class stack{public:stack();bool empty()const;bool full()const;error_code gettop(elementtype &x)const;error_code push(const elementtype x);error_code pop();private:int count;elementtype data[maxlen];};stack::stack(){count=0;}bool stack::empty()const{return count==0;}bool stack::full()const{return count==maxlen;}error_code stack::gettop(elementtype &x)const{if(empty())return underflow;else{x=data[count-1];return success;}}error_code stack::push(const elementtype x){if(full())return overflow;data[count]=x;count++;return success;}error_code stack::pop(){if(empty())return underflow;count--;return success;}//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"stack.h"void read_write() //逆序输出所输入的数{stack s;int i;int n,x;cout<<"please input num int n:";cin>>n;for(i=1;i<=n;i++){cout<<"please input a num:";cin>>x;s.push(x);}while(!s.empty()){s.gettop(x);cout<<x<<" ";s.pop();}cout<<endl;}void Dec_to_Ocx(int n) //十进制转换为八进制{stack s1;int mod,x;while(n!=0){mod=n%8;s1.push(mod);n=n/8;}cout<<"the ocx of the dec is:";while(!s1.empty()){s1.gettop(x);cout<<x;s1.pop();}cout<<endl;}void main(){int n;// read_write();cout<<"please input a dec:";cin>>n;Dec_to_Ocx(n);}队列的应用打印n行杨辉三角实验代码://queue.hclass queue{public:queue(){count=0;front=rear=0;}bool empty(){return count==0;}bool full(){return count==maxlen-1;}error_code get_front(elementtype &x){if(empty())return underflow;x=data[(front+1)%maxlen];return success;}error_code append(const elementtype x){if(full())return overflow;rear=(rear+1)%maxlen;data[rear]=x;count++;return success;}error_code serve(){if(empty())return underflow;front=(front+1)%maxlen;count--;return success;}private:int count;int front;int rear;int data[maxlen];};//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"queue.h"void out_number(int n) //打印前n行的杨辉三角{int s1,s2;int i;int j;int k;queue q;for(i=1;i<=(n-1)*2;i++)cout<<" ";cout<<"1 "<<endl;q.append(1);for(i=2;i<=n;i++){s1=0;for(k=1;k<=(n-i)*2;k++)cout<<" ";for(j=1;j<=i-1;j++){q.get_front(s2);q.serve();cout<<s1+s2<<" ";q.append(s1+s2);s1=s2;}cout<<"1 "<<endl;q.append(1);}}void main(){int n;cout<<"please input n:";cin>>n;out_number(n);}单链表实验实验目的:实验目的(1)理解线性表的链式存储结构。
数据结构试题大题编程及参考答案
数据结构考试题参考答案1、设顺序表L中的数据元素递增有序。
试写一算法,将数据元素x插入到顺序表L的适当位置,以保持该表的有序性。
解:存储结构为:typedef struct SeqList{ DataType *data;int MaxLen;int len;}SeqList;算法如下:void insertLx(SeqList &L, DataType x){ if(L.len==L.maxlen) return;int i=L.len-1;while(i>=0 && x<L.data[i]){ L.data[i+1]=L.data[i]; i=i-1;}L.data[i+1]=x; L.len++;}2、试写一个算法,在带头结点的单链表L的元素x前插入一个结点y。
解:存储结构如下:typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode, *LinkList;算法如下:void insert_y_before_x(LinkList L, ElemType x, ElemType y){ Lnode *q, *p=L;while(p->next && p->next->data!=x) p=p->next; //找x的前驱结点p;if(!p->next) return; // 若不存在结点x,则返回;q=new Lnode;q->data=y; q->next=p->next; p->next=q;}3、试写一个算法,统计带头指针的单链表L的元素个数。
解:存储结构如下:typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode, *LinkList;算法如下:int length(LinkList L){ int len=0;Lnode *p=L;while(p) { len++; p=p->next; }return len;}注:如果单链表是带头结点的,则算法如下:int length(LinkList L){ int len=0;Lnode *p=L->next;;while(p) { len++; p=p->next; }return len;}4、试写一个算法,在带头结点的单链表L的第k个结点后插入一个结点x。
数据结构大作业含源代码
数据结构大作业作业题目:职工信息管理系统姓名:学号:班级:指导教师:日期:一、主要功能:这个职工信息管理系统是由C语言编写的程序,它用起来很方便又很灵活。
它由输入职工信息,输出职工信息,按职工号,部门号,工资排序,按职工号,部门号,工资来输出职工的所有信息。
删除有关职工的所有信息,保存职工的所有信息并退出等11个模块儿组成。
二、实验环境:C语言、C++、C# 等等。
三、功能说明:下面按步骤来介绍一下,职工信息管理系统的基本操作。
这是运行程序以后出现的主界面。
如图(1)所示:图(1)主界面1.输入职工的信息该模块儿的功能是分别输入职工的姓名,职工号,部门号,工资等信息。
每次输入职工的所有信息以后,界面上会显示出《输入完成!》的命令。
如图(2)所示:图(2)输入职工信息该模块儿的功能是显示出有关职工的所有信息。
操作如图(3)所示:图(3)输出所有的职工信息3.按职工号排序该模块儿的功能是按职工号排序所有的职工。
我们按3的时候,界面上会显示出《排序完成!》的命令。
如图(4)所示:图(4)按职工号排序该模块儿的功能是显示出已排序好的所有职工的号码。
操作如图(5)所示:图(5)输出所有的职工号5.按部门号排序该模块儿的功能是按部门号排序所有职工的部门号。
我们按5的时候,界面上会显示出《排序完成!》的命令。
如图(6)所示:图(6)按部门号排序该模块儿的功能是显示出已排序好的所有部门号。
操作如图(7)所示:图(7)输出所有的部门号7.按职工的工资排序该模块儿的功能是按工资排序所有职工的工资。
我们按7的时候,界面上会显示出《排序完成!》的命令。
如图(8)所示:图(8)按职工的工资排序该模块儿的功能是显示出已排序好的所有职工的工资。
操作如图(9)所示:图(9)输出所有职工的工资9.删除职工的所有信息该模块儿的功能是删除有关职工的所有信息。
我们按9的时候界面上会显示出《删除成功!》的命令。
如图(10)所示:图(10)删除职工的所有信息10.保存该模块儿的功能是保存有关职工的所有信息。
数据结构试验完整代码
数据结构实验完整代码目录一、顺序存储的线性表 (2)二、单链存储的线性表 (4)三、栈 (7)四、队列 (8)五、二叉树的建立和遍历 (10)六、霍夫曼树 (11)七、图的建立和遍历 (17)图的邻接矩阵表示 (17)图的邻接表表示 (20)八、图的最小生成树 (23)九、图的最短路径 (28)十、顺序查找表 (31)十一、二叉排序树的查找 (34)十二、哈希表 (36)十三、插入排序 (41)十四、交换排序-冒泡排序 (44)十五、交换排序-快速排序 (45)十六、简单选择排序 (45)十七、堆排序 (46)一、顺序存储的线性表typedef struct{char name[10];char no[10];double grade;}Student;typedef struct{Student *elem;int length;int listsize;}SqList;void Display(SqList *L){int i;for (i=0;i<L->length ;i++){cout<<i+1<<":姓名"<<L->elem[i].name<<",学号:"<<L->elem[i].no<<",成绩:"<<L->elem[i].grade <<endl;}cout<<"请选择菜单项:";}SqList *CreateList(){SqList *L;L=(SqList*)malloc(sizeof(SqList));if(!L) cout<<"建立线性表失败!";else cout<<"建立线性表成功!";return(L);}int InitList(SqList *L){int i;char name[10],no[10];double grade;L->elem=(Student *)malloc(ListInitSize * sizeof(Student));if (!(L->elem)) cout<<"初始化表失败!";L->length = 0;L->listsize = ListInitSize;cout<<"请输入要录入信息的学生个数:"<<endl;cin>>i;if (i>(L->listsize)){L->elem =(Student *)realloc(L->elem ,i*sizeof(Student));}for (int j=0;j<i;j++){cout<<"请输入第"<<j+1<<"个学生的信息:"<<endl;cin>>name>>no>>grade;strcpy((L->elem+L->length)->name,name);strcpy((L->elem+L->length)->no,no);(L->elem+L->length)->grade =grade;L->length ++;}cout<<"信息录入完成!";return 0;}int Insert(SqList *l){Student e;int i,j;Student *newbase;cout<<"请输入要插入的位置:";cin>>j;j--;cout<<"请输入学生信息:";cin>>>>e.no>>e.grade;if(l->length==l->listsize){newbase=(Student*)realloc(l->elem,(l->listsize+ListIncreasement)*sizeof(Studen t));if(!newbase){cout<<"出错!";return 0;}l->elem=newbase;l->listsize+=ListIncreasement;}for(i=l->length;i>=j;i--){l->elem[i+1] = l->elem[i];}l->elem[j]=e;l->length++;cout<<"插入成功!";return 0;}int Delect(SqList *L){int i,j;cout<<"输入删除信息的位置:";cin>>j;j--;cout<<"删除的信息为:姓名:"<<L->elem[j].name<<",学号:"<<L->elem[j].no<<"成绩:"<<L->elem[j].grade<<endl;for(i=j+1;i<=L->length;i++){L->elem[i-1]=L->elem[i];}L->length--;cout<<"请按回车继续"<<endl;getchar();getchar();cout<<"删除成功!";return 0;}二、单链存储的线性表typedef struct Student{char name[10];char no[10];double grade;}Student;typedef struct LNode{Student data;LNode *next;}LNode,*LinkList;void CreateList(LinkList &l){l=(LinkList)malloc(sizeof(LNode));if (!l) cout<<"建立失败。
数据结构实验系统源代码(期末作业)
/* 树子系统*/#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.实验环境配置在实验开始之前,必须确保计算机上已安装好以下环境:●编译器(可以是C++、Java等)●数据结构与算法实验源代码文件4.实验内容及步骤4.1 实验一:线性表4.1.1 实验目的通过实现线性表的相关操作,加深对线性表及其操作的理解,并能够灵活应用。
4.1.2 实验步骤1.实现线性表的初始化函数2.实现线性表的插入操作3.实现线性表的删除操作4.实现线性表的查找操作5.实现线性表的排序操作6.实现线性表的输出操作7.编写测试代码,对线性表进行测试4.1.3 实验结果与分析进行若干测试用例,验证线性表的正确性,并分析算法的时间复杂度与空间复杂度。
4.2 实验二:栈与队列4.2.1 实验目的通过实现栈与队列的相关操作,加深对栈与队列的理解,并掌握栈与队列的应用场景。
4.2.2 实验步骤1.实现栈的初始化函数2.实现栈的入栈操作3.实现栈的出栈操作4.实现栈的查看栈顶元素操作5.实现队列的初始化函数6.实现队列的入队操作7.实现队列的出队操作8.实现队列的查看队首元素操作4.2.3 实验结果与分析进行若干测试用例,验证栈与队列的正确性,并分析算法的时间复杂度与空间复杂度。
(继续添加实验内容及步骤,具体根据实验项目和教学要求进行详细分析)5.实验附件本文档所涉及的实验源代码文件作为附件随文档提供。
6.法律名词及注释6.1 版权:著作权法所规定的权利,保护作品的完整性和原创性。
6.2 开源:指软件可以被任何人免费使用、分发和修改的一种软件授权模式。
(继续添加法律名词及注释)。
数据结构与算法实验源代码
数据结构与算法实验源代码数据结构与算法实验源代码一、实验目的本实验旨在通过编写数据结构与算法的实验源代码,加深对数据结构与算法的理解,并提高编程能力。
二、实验环境本实验使用以下环境进行开发和测试:- 操作系统:Windows 10- 开发工具:IDEA(集成开发环境)- 编程语言:Java三、实验内容本实验包括以下章节:3.1 链表在本章节中,我们将实现链表数据结构,并实现基本的链表操作,包括插入节点、删除节点、查找节点等。
3.2 栈和队列在本章节中,我们将实现栈和队列数据结构,并实现栈和队列的基本操作,包括入栈、出栈、入队、出队等。
3.3 树在本章节中,我们将实现二叉树数据结构,并实现二叉树的基本操作,包括遍历树、搜索节点等。
3.4 图在本章节中,我们将实现图数据结构,并实现图的基本操作,包括广度优先搜索、深度优先搜索等。
3.5 排序算法在本章节中,我们将实现各种排序算法,包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。
3.6 搜索算法在本章节中,我们将实现各种搜索算法,包括线性搜索、二分搜索、广度优先搜索、深度优先搜索等。
四、附件本文档附带实验源代码,包括实现数据结构和算法的Java源文件。
五、法律名词及注释5.1 数据结构(Data Structure):是指数据对象中数据元素之间的关系。
包括线性结构、树形结构、图形结构等。
5.2 算法(Algorithm):是指解决问题的一系列步骤或操作。
算法应满足正确性、可读性、健壮性、高效性等特点。
5.3 链表(Linked List):是一种常见的数据结构,由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
5.4 栈(Stack):是一种遵循后进先出(LIFO)原则的有序集合,用于存储和获取数据。
5.5 队列(Queue):是一种遵循先进先出(FIFO)原则的有序集合,用于存储和获取数据。
5.6 树(Tree):是由节点组成的层级结构,其中一种节点作为根节点,其他节点按照父子关系连接。
《C++》《数据结构》大作业
10级第二阶段课程设计报告《数据结构》和《面向对象程序设计》第二阶段课程设计题目:全国交通咨询模拟学院信息管理学院组长姓名 SWL 0103387 组员姓名 YY 0103393 YJ 0103394 LY 0103396 专业信息管理与信息系统指导教师易彤职称副教授指导教师杨勇职称副教授二0一二年一月目录1 引言 (3)2 概要设计 (3)2.1设计目标 (3)2.2实施方案 (4)2.3面向对象方法应用 (6)2.4数据结构技术应用 (9)3 详细设计与实现 (10)3.1 main (10)3.2 Administer (11)3.3 UserDemand (17)3.4 PrintGraph (21)4调试分析 (21)5结论与体会 (25)参考文献 (27)附录一:源程序代码 (28)1 引言21世纪的今天,城市交通已然成为城市品味和文明程度的直接反映,是城市精神文明建设的重要内容之一。
现代交通便利发达,四通八达,错综复杂,人们对交通方式和服务形式也提出了更高的要求,特别是主要交通方式:飞机和火车,人们都是出于不同的目的而选择这些交通方式。
例如,因公出差的旅客希望在旅途中的时间尽可能的短,出门旅游的游客则期望旅费尽可能省,而老年旅客则要求中转次数最少。
所以现如今,对交通的规范化管理也就显得非常重要了。
据此,在本次的小学期实践任务中,我们就选取了题目:全国交通咨询模拟系统。
鉴于本学期我们同时学习了以C语言为基础的《数据结构》和《C++程序设计语言》,所以我们在此次的设计中将会把这两门课程的知识紧密的结合起来,从而达到把知识应用于现实的目的,同时在现实中体验自身的不足继而帮助我们更进一步地去学习这两门课程,提升我们的编程基础。
2 概要设计2.1 设计目标出于不同目的的旅客对交通工具有不同的要求。
例如,因公出差的旅客希望在旅途中的时间尽可能短,出门旅游的游客则期望旅费尽可能的少,而老年旅客则要求中转次数最少。
数据结构实验总结及源代码
实验1 线性表1 问题描述:使用线性表实现一个通讯录,通讯录内容有:学号、姓名、电话号码。
使其完成以下功能。
(1)建立一个通讯录(2)插入一个数据元素(3)删除一个元素,返回其值(4)结束程序请写出基本的算法思想,以及源程序代码。
实验2 括号匹配问题描述编写一程序判断从键盘输入的子符串括号是否匹配。
假设需判断的括号只有“(”,“)”,“[”,“]”四种。
实验4 病人看病模拟程序【问题描述】编写一个程序,反映病人到医院看病,排队看医生的情况。
在病人排队的过程中,主要重复两件事:(1)病人到达诊室,将病历本交给护士,排到等待队列中候诊。
(2)护士从等待队列中取出下一位病人的病历,该病人进入诊室就诊。
要求模拟病人等待就诊这一过程。
程序采用菜单方式,其选项及功能说明如下:(1)排队――输入排队病人的病历号,加入病人排队队列中。
(2)就诊――病人排队队列中最前面的病人就诊,并将其从队列中删除;(3)查看排队――从对首到队尾列出所有的排队病人的病历号;(4)不再排队,余下一次就诊――从对首到队尾列出所有的排队病人的病历号,并退出运行;(5)下班――退出运行;线性表实验源代码#include <iostream.h>#include <conio.h>#include <iomanip.h>#include <string.h>//--------------------------------------------------------------------struct ElemType // 数据元素的类型{ int numb;char name[20];long tel;};const int MAXSIZE=100; // 数组的容量class Sqlist{ private:ElemType elem[MAXSIZE]; //结构体的数组int length;public:Sqlist( void);~Sqlist(){ };void SetData(); //建立通讯录;void Insert( int i, ElemType e); //在位置i,插入一条记录ElemType Delet(int i); //删除位置i 的记录void PrintOut(); //打印结果};//-------------------------------------------------------------//Sqlist::Sqlist( ) { length=0;}//Sqlist::Sqlist( ) { length=0;}Sqlist::Sqlist(){length=0;}void Sqlist::SetData( ) //初步建立一个通讯录{ cout<<"\n 输入人数length="; cin>>length;for(int i=0;i<length;i++){ cout<<"\n 输入学号:"; cin>>elem[i].numb;cout<<"\n 输入姓名:"; cin>> elem[i].name;cout<<"\n 输入电话号:="; cin>>elem[i].tel;}}void Sqlist::Insert( int i, ElemType e){ int j; i--;if(i<0||i>length) cout<< " i Error!"<<endl;else { for(j=length+1; j>i; j--) elem[j]=elem[j-1];// for(j=length; j>i; j--) elem[j]=elem[j-1];elem[i]=e; length++;}}ElemType Sqlist::Delet(int i){ElemType x; int j; i--;if(i<0||i>length-1){ cout<< " i Error!"<<endl; x.numb=-1;} else { x=elem[i];for(j=i; j<length-1; j++) elem[j]=elem[j+1];//for(j=i; j<length; j++) elem[j]=elem[j+1];length--;}return x;}void Sqlist::PrintOut() //输出{ cout<<"\n 通讯录总人数:"<<length;cout<<"\n PrintOut Data:\n";cout<<setw(16)<<"学号"<<setw(20)<<"姓名"<<setw(20)<<"电话号"<<endl; ;for(int k=0; k<length;k++){ cout<<setw(16)<<elem[k].numb<<setw(20)<<elem[k].name<<setw(20)<<elem[k].tel<<cou t<<endl;}}//--------------------------------------------------int main( ){ int i,k; ElemType e,x;Sqlist as;cout<<"\n 通讯录演示";do{cout<<"\n\n";cout<<"\n\n 1. 初步建立一个通讯录(线性表)";cout<<"\n\n 2. 插入一个数据元素";cout<<"\n\n 3. 删除一个元素,返回其值";cout<<"\n\n 4. 结束程序";cout<<"\n********************************";cout<<"\n 请输入你的选择(1,2,3,4)"; cin>>k;switch(k){ case 1:{ as.SetData(); as.PrintOut(); }break;case 2:{ cout<<"\n 插入的位置,i=?"; cin>>i;cout<<"\n 插入的数据编号=?"; cin>>e.numb;cout<<"\n 插入的数据姓名=?"; cin>>;cout<<"\n 插入的数据电话号=?"; cin>>e.tel;as.Insert(i,e); as.PrintOut();}break;case 3:{ cout<<"\n 删除第几个元i=?"; cin>>i;x=as.Delet(i);cout<<"\n 被删除的元素数值= "<<setw(10)<<x.numb<<setw(10)<<<<setw(10)<<x.tel;as.PrintOut();}break;default:break;} //switch}while(k>=1&&k<4);cout<<"\n 再见!"; cout<<"\n 按任意键,返回。
大学《数据结构》(C语言版)课程实验题目及参考代码鲁东大学byZYC
数据结构实验实验一线性表的基本操作实验二栈和队列实验三二叉树的操作实验四图的遍历实验五查找实验六排序实验一线性表的基本操作(1)实验要求:分别采用线性表的两种存储结构(顺序存储结构、链式存储结构)来实现以上基本操作。
(2)实验目的:了解线性表的基本概念,掌握线性表的两种存储结构——顺序存储和链式存储,掌握在两种存储结构上实现线性表的基本操作,掌握用C上机调试线性表操作的基本方法。
(3)实验内容:a.输入一组整型元素序列,建立线性表。
b.实现该线性表的遍历。
c.在该线性表中查找某一元素,查找成功显示查找元素,否则显示查找失败。
d.在该线性表中删除或插入指定元素。
(4)参考代码:#include<stdio.h>#include<stdlib.h>#define SIZE 20#define MORE 10typedef struct{int *base; //存储空间基址int length; //当前长度int listsize; //当前存储容量}SqList;void InitList(SqList &L){//构造线性表L.base=(int *)malloc(SIZE*sizeof(int));if(!L.base)exit(0);L.listsize=SIZE;scanf("%d",&L.length);printf("输入表中元素:\n"); for(int i=0;i<L.length;i++) scanf("%d",&L.base[i]);}void Output(SqList L){//遍历for(int i=0;i<L.length;i++) printf("%5d",L.base[i]); printf("\n");}void Locate(SqList L,int &e){ //查找int i;for(i=0;i<=L.length;i++){if(L.base[i]==e){printf("查找成功\n");break;}}if(i>L.length)printf("查找失败\n");}void Delete(SqList &L,int i,int &e){ //删除第i个元素int j;if(i<1||i>L.length) exit(0);e=L.base[i-1];for(j=i-1;j<L.length;j++){L.base[j]=L.base[j+1];}L.length--;}void Insert(SqList &L,int i,int e){//插入SqList q,p;int j;if(i<1||i>L.length+1)exit(0);if(L.length>=L.listsize){int *newbase=(int *)realloc(L.base,(L.listsize+MORE)*sizeof(int)); if(!newbase) exit(0);L.base=newbase;L.listsize+=MORE;}for(j=L.length-1;j>=i-1;j--){L.base[j+1]=L.base[j];}L.base[i-1]=e;L.length++;}void main(){SqList La,Lb,Lc;int d,k,e;printf("输入表的长度:\n"); InitList(La);printf("输入要查找的数:\n"); scanf("%d",&d) ;Locate(La,d);printf("要删除第几个数?\n"); scanf("%d",&k);Delete(La,k,e);printf("删除的数为:%d\n",e); printf("删除后的表为:\n"); Output(La);int a,b;printf("输入要插入的位置和数:\n");scanf("%d%d",&a,&b);Insert(La,a,b);printf("插入后的表为:\n");Output(La);}实验二栈和队列(1)实验要求:掌握栈和队列的类型定义方法;掌握栈在两种不同的存储结构上实现的五种基本操作;掌握在循环队列上实现队列的基本操作,并能灵活运用以上栈和队列知识对现实生活中的实际问题提出解决方案。
数据结构代码题万能模板
数据结构代码题万能模板在编写数据结构的代码时,通常会使用一些常见的模板来简化开发过程。
下面是一个万能的数据结构代码模板,可以用于多种数据结构的实现:python.# 定义数据结构的类。
class DataStructure:def __init__(self):# 初始化数据结构的属性。
pass.def method1(self, args):# 方法1的实现。
pass.def method2(self, args): # 方法2的实现。
pass.# 示例使用。
if __name__ == "__main__": # 创建数据结构对象。
ds = DataStructure()。
# 调用方法1。
ds.method1(args)。
# 调用方法2。
ds.method2(args)。
在这个模板中,你可以根据具体的数据结构需求来定义类的属性和方法。
例如,如果你要实现一个栈,可以在`__init__`方法中初始化一个空列表作为栈的内部存储结构,然后在`method1`和`method2`中实现栈的入栈和出栈操作。
如果你要实现一个队列,可以使用列表或者链表作为内部存储结构,并在`method1`和`method2`中实现队列的入队和出队操作。
这个模板的好处是可以根据具体的需求进行灵活的扩展和修改。
你可以根据实际情况添加更多的方法和属性,以满足你的数据结构设计。
需要注意的是,在示例使用部分,我们使用了`if __name__ == "__main__":`来判断是否是直接运行该脚本,这样可以避免在其他模块中导入该模块时执行示例代码。
希望这个万能的数据结构代码模板能对你有所帮助!如果你有任何进一步的问题,请随时提问。
(完整word版)哈工大数据结构大作业——哈夫曼树生成、编码、遍历
一、问题描述1.用户输入字母及其对应的权值,生成哈夫曼树;2.通过最优编码的算法实现,生成字母对应的最优0、1编码;3.先序、中序、后序遍历哈夫曼树,并打印其权值。
二、方法思路1。
哈夫曼树算法的实现§存储结构定义#define n 100 /*叶子树*/#define m 2*(n) –1 /* 结点总数*/typedef struct {/*结点型*/double weight ; /* 权值*/int lchild ;/* 左孩子链*/int rchild ;/* 右孩子链*/int parent; /*双亲链*/ 优点?}HTNODE ;typedef HTNODE HuffmanT[ m ];/*huffman树的静态三叉链表表示*/算法要点1)初始化:将T[0],…T[m—1]共2n-1个结点的三个链域均置空(—1 ),权值为0;2)输入权值:读入n 个叶子的权值存于T的前n 个单元T[0],…T[n],它们是n 个独立的根结点上的权值;3)合并:对森林中的二元树进行n—1次合并,所产生的新结点依次存放在T[i](n〈=i<=m—1)。
每次合并分两步:(1) 在当前森林中的二元树T [0],…T[i—1]所有结点中选取权值最小和次最小的两个根结点T[p1]和T[p2]作为合并对象,这里0<= p1,p2<= i –1;(2) 将根为T[p1]和T[p2]的两株二元树作为左、右子树合并为一株新二元树,新二元树的根结点为T[i]。
即T[p1].parent =T[p2].parent = i ,T[i].lchild= p1, T[i]。
rchild=p2, T[i].weight =T[p1]。
weight + T[p2].weight.2。
用huffman算法求字符集最优编码的算法:1) 使字符集中的每个字符对应一株只有叶结点的二叉树,叶的权值为对应字符的使用频率;2)利用huffman算法来构造一株huffman树;3) 对huffman树上的每个结点,左支附以0,右支附以1(或者相反),则从根到叶的路上的0、1序列就是相应字符的编码Huffman编码实现:存储结构typedef struct{char ch;//存储字符char bits[n+1];//字符编码位串}CodeNode;typedef CodeNode HuffmanCode[n];HuffmanCode H;3。
数据结构实验源代码
数据结构实验源代码【附】数据结构实验源代码范本一、实验背景与目的1.1 实验背景在计算机科学中,数据结构是指数据元素之间的关系,以及为操作这些数据元素所提供的方法。
数据结构对于程序的设计和性能优化具有重要影响。
1.2 实验目的本实验旨在通过编写和实现不同的数据结构,加深学生对数据结构的理解,掌握基本的数据结构操作方法。
二、实验内容2.1 线性表2.1.1 顺序表2.1.1.1 初始化顺序表2.1.1.2 插入元素到顺序表2.1.1.3 删除顺序表中的元素2.1.1.4 遍历顺序表2.1.1.5 查找指定元素在顺序表中的位置2.1.2 链表2.1.2.1 初始化链表2.1.2.2 插入元素到链表2.1.2.3 删除链表中的元素2.1.2.4 遍历链表2.1.2.5 查找指定元素在链表中的位置2.2 栈2.2.1 初始化栈2.2.2 进栈操作2.2.3 出栈操作2.2.4 获取栈顶元素2.2.5 判断栈是否为空2.3 队列2.3.1 初始化队列2.3.2 入队操作2.3.3 出队操作2.3.4 获取队首元素2.3.5 判断队列是否为空三、实验步骤3.1 线性表实现在实现顺序表和链表时,首先需要定义数据结构和所需的操作函数。
然后进行初始化、添加元素、删除元素等操作。
最后进行遍历和查找操作,并检验实验结果是否符合预期。
3.2 栈实现栈的实现过程与线性表类似,需要定义栈的数据结构和所需的函数,然后进行初始化、进栈、出栈等操作。
3.3 队列实现队列的实现也与线性表类似,需要定义队列的数据结构和函数,进行初始化、入队、出队等操作。
四、数据结构实验源代码以下是实验代码的源代码范本,包括线性表、栈和队列的实现。
(代码略,如需获取,请查看附件)五、附件本文档附带的附件为数据结构实验源代码。
六、法律名词及注释6.1 数据结构:计算机科学中,数据结构是指数据元素之间的关系,以及为操作这些数据元素所提供的方法。
6.2 顺序表:一种物理上相邻的存储结构,元素按照顺序依次存放。
数据结构大型实验大整数运算系统附源代码
数据构造大型实验实验报告〔附源代码〕工业大学朱镇洋耀明华族目录第一局部要求与概述一、实验目的以及准备1.1.1 问题描述. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1.1.2 根本要求. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1.1.3 设计思路. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .第二局部具体实现一、代码局部2.1.1 链表类及大数类的局部说明以及局部源码. . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.2 局部简单函数功能. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.3 加法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.4 减法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.5 乘法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.6 除法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.7 幂运算. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.1.8 二进制和十进制的相互转化. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .二、程序流程及函数间关系2.2.1 程序流程图. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.2.2 函数调用关系分析. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .三、实验验证分析2.3.1 输入的形式和输入值的围. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.3.2 输出的形式. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.3.3 程序所能到达的功能. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2.3.4 测试数据. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .四、调试分析2.4.1 调试过程中的主要技术问题以及具体的解决方法. . . . . . . . . . . . . . . . . . . . . . . .2.4.2 印象最深刻的3个调试错误,及修正方法. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .五、附录2.5.1 源代码及其所属文件. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .第一局部要求与概述1.1.1 问题描述•密码学分为两类密码:对称密码和非对称密码。
数据结构课程设计报告 (附有完整可运行出来的代码)
课程设计报告设计题目:公园导游图一、流程图二、程序代码#include<iostream>using namespace std;#include<stdio.h>typedef struct //定义图结构{int n; /* 图的顶点个数*/char v[100]; /* 顶点信息*/int e[100][100]; /* 边信息*/int shor; /* 最短路径信息*/}park;park *luru(park *x){int j,k;cout<<"请输入公园景点个数"<<endl;cin>>x->n;if(x->n<=0){cout<<"个数输入错误,请重新输入"<<endl;cin>>x->n;}cout<<"请输入景点名称,每个名称只允许一个字符代替"<<endl;for(j=0;j<x->n;j++)cin>>x->v[j];cout<<"请输入景点之间的路径长度,只允许整数型数值,无路径长度的输入0"<<endl;for(j=0;j<x->n;j++)for(k=0;k<x->n;k++){cout<<"请输入第"<<j+1<<"行"<<"第"<<k+1<<"列的路径长度"<<endl;cin>>x->e[j][k];}return x;}int search(park *x){char start,end,temp;int i=0,j=0,temp_1,temp1=10000;cout<<"请输入要查找的起始景点名称"<<endl;cin>>start;while(i<x->n && start!=x->v[i])i++;if(i==x->n){cout<<"没有找到该景点,按任意键返回"<<endl;return 0;}}cout<<"请输入要查找的终点景点名称"<<endl;cin>>end;while(j<x->n && end!=x->v[j]){j++;if(j==x->n){cout<<"没有找到该景点,按任意键返回"<<endl;return 0;}}x->shor=x->e[i][j];temp_1=x->e[i][j];for (int k=0;k<x->n;k++)//两个顶点最小权值判断{if (x->e[i][k]==0||x->e[k][j]==0 )continue;if(x->shor > x->e[i][k] + x->e[k][j]){x->shor = x->e[i][k] + x->e[k][j];temp=x->v[k];}}if(x->shor==0){cout<<"这两个节点中没有连通路,按任意键返回"<<endl;return 0;}if(x->shor==temp_1){cout<<"最短路径信息: "<<start<<"->"<<end<<endl<<"最小路径长度:"<<x->shor<<endl;x->shor=10000;getchar();return 1;if(x->shor<temp_1 && x->shor<=temp1){cout<<"最短路径信息: "<<start<<"->"<<temp<<"->"<<end<<endl<<"最小路径长度:"<<x->shor<<endl;x->shor=10000;getchar();return 1;}cout<<"查找失败,按任意键返回"<<endl;getchar();return 0;}int main(){park x;int i=1;luru(&x);do{search(&x);cout<<"是否继续?"<<endl<<"1.继续"<<endl<<"0.退出"<<endl;cin>>i;}while(i!=0);return 0;}三、运行结果。
数据结构 图实验 实验代码
1.邻接矩阵作为存储结构:#include <stdio.h>#include <stdlib.h>#define MaxVertexNum 100typedef struct{char verxs[MaxVertexNum];int edges[MaxV ertexNum][MaxVertexNum];int n,e;}MGraph;void creatMGraph(MGraph *G){int i,j,k;char a;printf("Input VertexNum(n)andEdgesNum(e):");scanf("%d,%d",&G->n,&G->e);scanf("%c",&a);printf("Input Vertex string");for(i=0;i<G->n;i++){scanf("%c",&a);G->verxs[i]=a;}for(i=0;i<G->n;i++)for(j=0;j<G->n;j++)G->edges[i][j]=0;printf("Input edges,Creat Adjacency Matrix\n");for(k=0;k<G->e;k++){scanf("%d%d",&i,&j);G->edges[i][j]=1;G->edges[j][i]=1;}}typedef enum{FALSE,TRUE}Boolean;Boolean visited[MaxVertexNum];void DFSM(MGraph*G,int i){int j;printf("%c",G->verxs[i]);visited[i]=TRUE;for(j=0;j<G->n;j++)if(G->edges[i][j]==1&&!visited[j])DFSM(G,j);}void DFS(MGraph*G){int i;for(i=0;i<G->n;i++)visited[i]=FALSE;for(i=0;i<G->n;i++)if(!visited[i])DFSM(G,i);}void BFS(MGraph*G,int k){int i,j,f=0,r=0;int cq[MaxVertexNum];for(i=0;i<G->n;i++)visited[i]=FALSE;for(i=0;i<G->n;i++)cq[i]=-1;printf("%c",G->verxs[k]);visited[k]=TRUE;cq[r]=k;while(cq[f]!=-1){ i=cq[f];f=f+1;for(j=0;j<G->n;j++)if(G->edges[i][j]==1&&!visited[j]){printf("%c",G->verxs[j]);visited[j]=TRUE;r=r+1;cq[r]=j;}}}void main(){int i;MGraph*G;G=(MGraph*)malloc(sizeof(MGraph));creatMGraph(G);printf("Print Graph DFS:");DFS(G);printf("\n");printf("Print Graph BFS:");BFS(G,3);printf("\n");}2.邻接链表作为存储结构:#include"stdio.h"#include"stdlib.h"#define MaxVertexNum 50 /*定义最大顶点数*/typedef struct node{ /*边表结点*/int adjvex; /*邻接点域*/struct node *next; /*链域*/}EdgeNode;typedef struct vnode{ /*顶点表结点*/char vertex; /*顶点域*/EdgeNode *firstedge; /*边表头指针*/}VertexNode;typedef VertexNode AdjList[MaxVertexNum]; /*AdjList是邻接表类型*/ typedef struct {AdjList adjlist; /*邻接表*/int n,e; /*图中当前顶点数和边数*/} ALGraph; /*图类型*//* 建立图的邻接表*/void CreatALGraph(ALGraph *G){int i,j,k;char a;EdgeNode *s; /*定义边表结点*/printf("Input VertexNum(n)andEdgesNum(e): ");scanf("%d,%d",&G->n,&G->e); /*读入顶点数和边数*/scanf("%c",&a);printf("Input Vertex string:");for(i=0;i<G->n;i++) /*建立边表*/{scanf("%c",&a);G->adjlist[i].vertex=a; /*读入顶点信息*/G->adjlist[i].firstedge=NULL; /*边表置为空表*/}printf("Input edges,Creat Adjacency Matrix\n");for(k=0;k<G->e;k++) { /*建立边表*/scanf("%d%d",&i,&j); /*读入边(Vi,Vj)的顶点对序号*/s=(EdgeNode *)malloc(sizeof(EdgeNode)); /*/生成边表结点*/s->adjvex=j; /*邻接点序号为j*/s->next=G->adjlist[i].firstedge;G->adjlist[i].firstedge=s; /*将新结点*S插入顶点Vi的边表头部*/s=(EdgeNode *)malloc(sizeof(EdgeNode));s->adjvex=i; /*邻接点序号为i*/s->next=G->adjlist[j].firstedge;G->adjlist[j].firstedge=s; /*将新结点*S插入顶点Vj的边表头部*/}}/* 定义标志向量,为全局变量*/typedef enum{FALSE,TRUE} Boolean;Boolean visited[MaxVertexNum];/* DFS:深度优先遍历的递归算法*/void DFSM(ALGraph *G,int i){ /*以Vi为出发点对邻接链表表示的图G进行DFS搜索*/ EdgeNode *p;printf("%c ",G->adjlist[i].vertex); /*访问顶点Vi*/visited[i]=TRUE; /*标记Vi已访问*/p=G->adjlist[i].firstedge; /*取Vi边表的头指针*/while(p) { /*依次搜索Vi的邻接点Vj,这里j=p->adjvex*/if(! visited[p->adjvex]) /*若Vj尚未被访问*/DFSM(G,p->adjvex); /*则以Vj为出发点向纵深搜索*/ p=p->next; /*找Vi的下一个邻接点*/}}void DFS(ALGraph *G){int i;for(i=0;i<G->n;i++)visited[i]=FALSE; /*标志向量初始化*/for(i=0;i<G->n;i++)if(!visited[i]) /*Vi未访问过*/DFSM(G,i); /*以Vi为源点开始DFS搜索*/}/* BFS:广度优先遍历*/void BFS(ALGraph *G,int k){ /*以Vk为源点对用邻接链表表示的图G进行广度优先搜索*/int i,f=0,r=0;EdgeNode *p;int cq[MaxVertexNum]; /*定义FIFO队列*/for(i=0;i<G->n;i++)visited[i]=FALSE; /*标志向量初始化*/for(i=0;i<=G->n;i++)cq[i]=-1; /*初始化标志向量*/printf("%c ",G->adjlist[k].vertex); /*访问源点Vk*/visited[k]=TRUE;cq[r]=k; /*Vk已访问,将其入队。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
}
clrscr();
printf("all done!\n");
getch();
return(h);
数据结构大作业
} employee *SortByWages(employee *head) {
employee *p,*q,*s,*h,*temp; temp=malloc(sizeof(employee)); h=head; for(s=head->next; s!=NULL; s=s->next) {
数据结构大作业
else
{
p=head->next;
if(p!=NULL)
{
clrscr();
printf("all information of employee\n\n");
printf("employee's name
employee's number
number employee's wages\n");
/*no 为职工号,depno 为部门号,salary 为工资数*/
char name[maxsize];
/*职工姓名*/
struct node *pno,*pdepno,*psalary,*next; /*pno 为职工号指针,pdepno 为部门号
指针,psalary 为工资数指针*/
}employee;
数据结构大作业
p=s; for(q=s->next; q!=NULL; q=q->next) {
if((p->no)>(q->no)) p=q;
} if(p!=s) {
temp->no=s->no; temp->depno=s->depno; temp->salary=s->salary; strcpy(temp->name,s->name); s->no=p->no; s->depno=p->depno; s->salary=p->salary; strcpy(s->name,p->name); p->no=temp->no; p->depno=temp->depno; p->salary=temp->salary; strcpy(p->name,temp->name); } } clrscr(); printf("all done!\n"); getch(); return(h); }
{
p=s;
for(q=s->next; q!=NULL; q=q->next)
{
if((p->depno)>(q->depno))
p=q;
}
if(p!=s)
{
temp->no=s->no;
temp->depno=s->depno;
temp->salary=s->salary;
strcpy(temp->name,s->name);
显然, 结构体中的成员包括职工姓名、职工号、部门号、职工工资、以及一些指向
其它该类型结点的指针变量.
下面介绍实现第一个功能的代码:
employee *insert(employee *head) {
employee *h;
if(head==NULL) {
employee *s,*h1; h1=malloc(sizeof(employee));
s=malloc(sizeof(employee)); clrscr();
数据结构大作业
printf("please input employee's name:"); scanf("%s",s->name); printf("please input employee's number:"); scanf("%d",&s->no); printf("please input department's number:"); scanf("%d",&s->depno); printf("please input employee's wages:"); scanf("%d",&s->salary); s->pno=NULL; s->pdepno=NULL; s->psalary=NULL; s->next=NULL; h1->pno=NULL; h1->pdepno=NULL; h1->psalary=NULL; h1->next=s; h=h1; printf("all done!\n"); getch(); } if(head!=NULL) {
3 实验仪器
每人 1 台安装有 Turbo C 的普通学生电脑。
数据结构大作业
4 实验内容
利用静态链表来实现这一综合算法。
5 实验重点
掌握链表的常用操作。
6 程序功能及其实现详解
下面将详细介绍本程序的所有功能的实现方式即代码的含义, 在设计本程序时, 本人尽可能地用了质量好一点的算法, 因为本程序有以上 10 个功能, 显然应有实现相
s->no=p->no;
s->depno=p->depno;
s->salary=p->salary;
strcpy(s->name,p->name);
p->no=temp->no;
p->depno=temp->depno;
p->salary=temp->salary;
strcpy(p->name,temp->name);
p=s; for(q=s->next; q!=NULL; q=q->next) {
if((p->salary)>(q->salary)) p=q;
while(p!=NULL)
{
department's
printf("\t%s\t\t%d\t\t\t%d\t\t %d\n",p->name,p->no,p->depno,p->salary); p->next;
} } } getch(); } 本函数的功能是实现职工记录表中的所有记录,若没有任何一个记录, 则输出一个 提示语句来提醒使用者职工表为空, 若不为空则从第一号结点开始输出一直到最后一 个结点(以表格形式输出). 下面分别介绍根据职工号、部门号以及职工工资来排序的函数: employee *SortByEmployeeNumber(employee *head) { employee *p,*q,*s,*h,*temp; temp=malloc(sizeof(employee)); h=head; for(s=head->next; s!=NULL; s=s->next) {
2 程序简介
该程序的功能可以从以下十个方面来说明: 1.输入:添加一个职工记录 2.输出:输出全部职工记录 3.按职工号排序:通过职工号指针将职工记录按职工号从小到大连接起来 4.按职工号输出:沿职工号指针输出全部职工记录 5.按部门号排序:通过部门号指针将职工记录按部门号从小到大连接起来 6.按部门号输出:沿部门号指针输出全部职工记录 7.按职工工资排序:通过职工工资指针将职工记录按职工工资从小到大连接起来 8.按职工工资输出:沿职工号指针输出全部职工记录 9.全清:删除职工文件中有的全部记录 10.存储退出:将单链表中的全部结点存储到职工文件中,然后退出程序运行过程
employee *SortByDepartmentNumber(employee *head) {
数据结构大作业
employee *p,*q,*s,*h,*temp;
temp=malloc(sizeof(employee));
h=head;
for(s=head->next; s!=NULL; s=s->next)
employee *s,*p,*h1; h1=head; p=h1->next; s=malloc(sizeof(employee)); if(p->next!=NULL) {
while(p->next!=NULL) p=p->next;
数据结构大作业
clrscr(); printf("please input employee's name:"); scanf("%s",s->name); printf("please input employee's number:"); scanf("%d",&s->no); printf("please input department's number:"); scanf("%d",&s->depno); printf("please input employee's wages:"); scanf("%d",&s->salary); s->pno=NULL; s->pdepno=NULL; s->psalary=NULL; s->next=NULL; p->next=s; h=h1; printf("all done!\n"); getch(); } if(p->next==NULL) { clrscr(); printf("please input employee's name:"); scanf("%s",s->name); printf("please input employee's number:"); scanf("%d",&s->no); printf("please input department's number:"); scanf("%d",&s->depno);