数据结构实验报告
数据结构课程设计实验报告完整版
数据结构课程设计实验报告完整版【正文】一、实验目的本实验主要目的是通过实践，掌握数据结构的基本概念、常见数据结构的实现方式以及在实际应用中的应用场景和效果。
二、实验背景数据结构是计算机科学与技术领域中的一个重要概念，是研究数据的组织方式、存储方式、访问方式以及操作等方面的方法论。
在计算机科学领域，数据结构是实现算法和解决问题的基础，因此对数据结构的理解和应用具有重要意义。
三、实验内容本次数据结构课程设计实验主要分为以下几个部分：1. 实验环境的准备：包括选择合适的开发平台、安装必要的软件和工具。
2. 实验数据的收集和处理：通过合适的方式收集实验所需的数据，并对数据进行处理和整理。
3. 数据结构的选择和实现：根据实验需求，选择合适的数据结构，并进行相应的数据结构实现。
4. 数据结构的测试和优化：对所实现的数据结构进行测试，包括性能测试和功能测试，并根据测试结果对数据结构进行优化和改进。
5. 实验报告的撰写：根据实验过程和结果，撰写完整的实验报告，包括实验目的、实验背景、实验内容、实验结果和结论等。
四、实验过程1. 实验环境的准备本实验选择了Visual Studio作为开发平台，安装了相应版本的Visual Studio，并根据官方指引进行了相应的配置和设置。
2. 实验数据的收集和处理本实验选取了一份包含学生信息的数据集，包括学生姓名、学号、性别、年龄等信息。
通过编写Python脚本，成功提取了所需信息，并对数据进行了清洗和整理。
3. 数据结构的选择和实现根据实验需求，我们选择了链表作为数据结构的实现方式。
链表是一种常见的动态数据结构，能够高效地插入和删除元素，适用于频繁插入和删除的场景。
在实现链表时，我们定义了一个节点结构，包含数据域和指针域。
通过指针的方式将节点连接起来，形成一个链式结构。
同时，我们还实现了相关的操作函数，包括插入、删除、查找等操作。
4. 数据结构的测试和优化在完成链表的实现后，我们对其进行了性能测试和功能测试。
数据结构实验报告_实验报告_
数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程，那么，下面是小编给大家整理收集的数据结构实验报告，供大家阅读参考。
数据结构实验报告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. 学会使用C语言实现线性表、栈、队列、树和图等基本数据结构。
3. 培养动手实践能力，提高编程水平。
二、实验内容1. 线性表（1）顺序表（2）链表2. 栈（1）顺序栈（2）链栈3. 队列（1）顺序队列（2）链队列4. 树（1）二叉树（2）二叉搜索树5. 图（1）邻接矩阵表示法（2）邻接表表示法三、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 编译器：Visual Studio 20194. 实验软件：C语言开发环境四、实验步骤1. 线性表（1）顺序表1）定义顺序表结构体2）实现顺序表的初始化、插入、删除、查找等基本操作3）编写测试程序，验证顺序表的基本操作（2）链表1）定义链表结构体2）实现链表的创建、插入、删除、查找等基本操作3）编写测试程序，验证链表的基本操作2. 栈（1）顺序栈1）定义顺序栈结构体2）实现顺序栈的初始化、入栈、出栈、判空等基本操作3）编写测试程序，验证顺序栈的基本操作（2）链栈1）定义链栈结构体2）实现链栈的初始化、入栈、出栈、判空等基本操作3）编写测试程序，验证链栈的基本操作3. 队列（1）顺序队列1）定义顺序队列结构体2）实现顺序队列的初始化、入队、出队、判空等基本操作3）编写测试程序，验证顺序队列的基本操作（2）链队列1）定义链队列结构体2）实现链队列的初始化、入队、出队、判空等基本操作3）编写测试程序，验证链队列的基本操作4. 树（1）二叉树1）定义二叉树结构体2）实现二叉树的创建、遍历、查找等基本操作3）编写测试程序，验证二叉树的基本操作（2）二叉搜索树1）定义二叉搜索树结构体2）实现二叉搜索树的创建、遍历、查找等基本操作3）编写测试程序，验证二叉搜索树的基本操作5. 图（1）邻接矩阵表示法1）定义邻接矩阵结构体2）实现图的创建、添加边、删除边、遍历等基本操作3）编写测试程序，验证邻接矩阵表示法的基本操作（2）邻接表表示法1）定义邻接表结构体2）实现图的创建、添加边、删除边、遍历等基本操作3）编写测试程序，验证邻接表表示法的基本操作五、实验结果与分析1. 线性表（1）顺序表实验结果表明，顺序表的基本操作实现正确，测试程序运行稳定。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说，我们需要实现一个树的数据结构，并对其进行插入、删除、查找等操作，同时还需要实现树的遍历算法，包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构，由结点和边组成。
树的每个结点都可以有多个子结点，但是每个结点只有一个父结点，除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中，我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树，每个结点最多只有两个子结点。
根据二叉树的特点，我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先，我们需要定义树的结点类，包括结点值、左子结点和右子结点。
然后，我们可以定义树的类，包括根结点和相应的操作方法，如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说，如果要插入的值小于当前结点的值，则将其插入到左子树中；如果要插入的值大于当前结点的值，则将其插入到右子树中。
如果当前结点为空，则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说，如果要删除的值小于当前结点的值，则在左子树中继续查找；如果要删除的值大于当前结点的值，则在右子树中继续查找。
如果要删除的值等于当前结点的值，则有三种情况：- 当前结点没有子结点：直接将当前结点置为空。
- 当前结点只有一个子结点：将当前结点的子结点替代当前结点。
- 当前结点有两个子结点：找到当前结点右子树中的最小值，将其替代当前结点，并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说，如果要查找的值小于当前结点的值，则在左子树中继续查找；如果要查找的值大于当前结点的值，则在右子树中继续查找。
数据结构实验报告2篇
数据结构实验报告数据结构实验报告精选2篇（一）实验目的：1. 熟悉数据结构的基本概念和基本操作；2. 掌握线性表、栈、队列、链表等经典数据结构的实现方法；3. 掌握数据结构在实际问题中的应用。
实验内容：本次实验主要包括以下几个部分：1. 线性表的实现方法，包括顺序表和链表，分别使用数组和链表来实现线性表的基本操作；2. 栈的实现方法，包括顺序栈和链式栈，分别使用数组和链表来实现栈的基本操作；3. 队列的实现方法，包括顺序队列和链式队列，分别使用数组和链表来实现队列的基本操作；4. 链表的实现方法，包括单链表、双链表和循环链表，分别使用指针链、双向链和循环链来实现链表的基本操作；5. 综合应用，使用各种数据结构来解决实际问题，例如使用栈来实现括号匹配、使用队列来实现马铃薯游戏等。
实验步骤及结果：1. 线性表的实现方法：a) 顺序表的基本操作：创建表、插入元素、删除元素、查找元素等；b) 链表的基本操作：插入节点、删除节点、查找节点等；c) 比较顺序表和链表的优缺点，分析适用场景。
结果：通过实验，确认了顺序表适用于频繁查找元素的情况，而链表适用于频繁插入和删除节点的情况。
2. 栈的实现方法：a) 顺序栈的基本操作：进栈、出栈、判空、判满等；b) 链式栈的基本操作：进栈、出栈、判空、判满等。
结果：通过实验，掌握了栈的基本操作，并了解了栈的特性和应用场景，例如括号匹配。
3. 队列的实现方法：a) 顺序队列的基本操作：入队、出队、判空、判满等；b) 链式队列的基本操作：入队、出队、判空、判满等。
结果：通过实验，掌握了队列的基本操作，并了解了队列的特性和应用场景，例如马铃薯游戏。
4. 链表的实现方法：a) 单链表的基本操作：插入节点、删除节点、查找节点等；b) 双链表的基本操作：插入节点、删除节点、查找节点等；c) 循环链表的基本操作：插入节点、删除节点、查找节点等。
结果：通过实验，掌握了链表的基本操作，并了解了链表的特性和应用场景。
数据结构课程实验报告
数据结构课程实验报告一、实验目的数据结构是计算机科学中一门重要的基础课程，通过本次实验，旨在加深对数据结构基本概念和算法的理解，提高编程能力和解决实际问题的能力。
具体目标包括：1、掌握常见数据结构（如数组、链表、栈、队列、树、图等）的基本操作和实现方法。
2、学会运用数据结构解决实际问题，培养算法设计和分析的能力。
3、提高程序设计的规范性和可读性，培养良好的编程习惯。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
三、实验内容本次实验共包括以下几个部分：（一）线性表的实现与操作1、顺序表的实现定义一个顺序表结构体，包含数据元素数组和表的长度。
实现顺序表的初始化、插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体，包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
（二）栈和队列的实现与应用1、栈的实现采用顺序存储或链式存储实现栈。
实现栈的入栈、出栈、栈顶元素获取等操作，并应用于表达式求值。
2、队列的实现用循环队列或链式队列实现队列。
实现队列的入队、出队、队头元素获取等操作，应用于模拟排队系统。
（三）树的基本操作与遍历1、二叉树的实现定义二叉树节点结构体，包含数据域、左子树指针和右子树指针。
实现二叉树的创建、插入、删除节点等操作。
2、二叉树的遍历分别实现前序遍历、中序遍历和后序遍历，并输出遍历结果。
（四）图的表示与遍历1、邻接矩阵和邻接表表示图定义图的结构体，使用邻接矩阵和邻接表两种方式存储图的信息。
实现图的创建、添加边等操作。
2、图的遍历分别用深度优先搜索（DFS）和广度优先搜索（BFS）遍历图，并输出遍历序列。
四、实验步骤（一）线性表的实现与操作1、顺序表的实现首先，定义了一个结构体｀SeqList` 来表示顺序表，其中包含一个整数数组｀data` 用于存储数据元素，以及一个整数｀length` 表示表的当前长度。
在初始化函数｀InitSeqList` 中，将表的长度初始化为 0，并分配一定的存储空间给数组。
数据结构实训实验报告
一、实验背景数据结构是计算机科学中一个重要的基础学科，它研究如何有效地组织和存储数据，并实现对数据的检索、插入、删除等操作。
为了更好地理解数据结构的概念和原理，我们进行了一次数据结构实训实验，通过实际操作来加深对数据结构的认识。
二、实验目的1. 掌握常见数据结构（如线性表、栈、队列、树、图等）的定义、特点及操作方法。
2. 熟练运用数据结构解决实际问题，提高算法设计能力。
3. 培养团队合作精神，提高实验报告撰写能力。
三、实验内容本次实验主要包括以下内容：1. 线性表（1）实现线性表的顺序存储和链式存储。
（2）实现线性表的插入、删除、查找等操作。
2. 栈与队列（1）实现栈的顺序存储和链式存储。
（2）实现栈的入栈、出栈、判断栈空等操作。
（3）实现队列的顺序存储和链式存储。
（4）实现队列的入队、出队、判断队空等操作。
3. 树与图（1）实现二叉树的顺序存储和链式存储。
（2）实现二叉树的遍历、查找、插入、删除等操作。
（3）实现图的邻接矩阵和邻接表存储。
（4）实现图的深度优先遍历和广度优先遍历。
4. 算法设计与应用（1）实现冒泡排序、选择排序、插入排序等基本排序算法。
（2）实现二分查找算法。
（3）设计并实现一个简单的学生成绩管理系统。
四、实验步骤1. 熟悉实验要求，明确实验目的和内容。
2. 编写代码实现实验内容，对每个数据结构进行测试。
3. 对实验结果进行分析，总结实验过程中的问题和经验。
4. 撰写实验报告，包括实验目的、内容、步骤、结果分析等。
五、实验结果与分析1. 线性表（1）顺序存储的线性表实现简单，但插入和删除操作效率较低。
（2）链式存储的线性表插入和删除操作效率较高，但存储空间占用较大。
2. 栈与队列（1）栈和队列的顺序存储和链式存储实现简单，但顺序存储空间利用率较低。
（2）栈和队列的入栈、出队、判断空等操作实现简单，但需要考虑数据结构的边界条件。
3. 树与图（1）二叉树和图的存储结构实现复杂，但能够有效地表示和处理数据。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程，通过本次实验，旨在加深对常见数据结构（如链表、栈、队列、树、图等）的理解和应用，提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为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 。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告姓名:wangqiang学号：*********1线性表的应用#include<stdio.h>#include<stdlib.h>typedef struct node{int value;struct node *next;}NODE;NODE *createlink(int n){NODE *head=NULL,*p=NULL,*q=NULL;int i=1;head=p=(struct node*)malloc(sizeof(struct node));p->value=i;for(i=2;i<=n;i++){q=(struct node*)malloc(sizeof(struct node));if(q==0) return 0;p->next=q;p=q;p->value=i;}p->next=head;return head;}void jose(NODE *p,int n,int m){int i,j,g=0;NODE *q=NULL;for(i=1;i<=n;i++){for(j=1;j<m;j++){p=p->next;}q=p->next;p->next=q->next;if(g%5==0){g++;printf("\n");}else g++;printf("%3d:%3dout ",i,q->value-1);free(q);}printf("\n");p->next=NULL;}int main( ){int m=0;int n=0;scanf("%d",&m);scanf("%d",&n);NODE *head=NULL;head=createlink(n);jose(head,n,m);return0;2栈和队列的应用#include"stdio.h"#include"string.h"#include"stdlib.h"#define StackSize 100 //假定预分配的栈空间最多为100个元素#define MaxLength 100 //最大的字符串长度typedef int DataType; //假定栈元素的数据类型为整数typedef struct{DataType data[StackSize];int top;}SeqStack;void Initial(SeqStack*S);int IsEmpty(SeqStack*S);int IsFull(SeqStack*S);void Push(SeqStack*S, DataType x);DataType Pop(SeqStack*S);DataType Top(SeqStack*S);void PrintMatchedPairs(char *expr);void main(void){char expr[MaxLength];printf("请输入符号个数小于%d的表达式：\n",MaxLength); gets(expr);printf("括号对是：\n");PrintMatchedPairs(expr);return;}//置栈空void Initial(SeqStack*S){S-> top= -1;}//判断栈是否空int IsEmpty(SeqStack*S){return S-> top== -1;}//判断栈是否满int IsFull(SeqStack*S){return S-> top== StackSize-1;}//进栈void Push(SeqStack*S, DataType x){if(IsFull(S)){printf("栈上溢!");exit(1);}S-> data[++ S-> top]= x;return;}//出栈DataType Pop(SeqStack*S){if(IsEmpty(S)){printf("栈为空！");return -1;}return S-> data[S-> top--];//栈顶指针加1后将x入栈 }//取栈顶元素DataType Top(SeqStack*S){if(IsEmpty(S)){printf("栈为空！");exit(1);}return S-> data[S-> top];}//括号匹配void PrintMatchedPairs(char *expr){SeqStack S;int i , j , length= strlen(expr);Initial(&S);for(i= 1 ; i<= length ; i++){if(expr[i- 1]== '('){Push(&S,i);}else if(expr[i- 1]== ')'){j= Pop(&S);if(j== -1){printf("没有对应第%d个右括号的左括号\n", i); }else{printf("%d %d\n",i,j);}}}while(!IsEmpty(&S)){j= Pop(&S);printf("没有对应第%d个左括号的右括号\n", j);}}3数组的应用#include<stdio.h>#include<stdlib.h>Sturct tuple3tp /*稀疏矩阵的建立和转置*/{Int i,j;Int v;}Sturct sparmattp{Int mu, nu,tu;Sturct tuple3tp data[31];}Struct sparmattp a,b;V oid crt_sparmat(){Int i;Printf("输入稀疏矩阵行值，列值，最大非零元个数："); Scanf("%d%d%d",&a.mu,&a.nu,&a.tu);For("i=1;i<=a.tu;i++){Printf("输入行坐标，列坐标，非零元"）;Scanf("%d%d%d",&a.data[i].i,&a.data[i].j,&a.data[i].v); }}V oid trans_sparmat(){Int col,p,q;B.mu=a.nu;B.nu=a.mu;B.tu=a.tu;If(b.tu！=0）{Q=1;For(col=1;col<=a.nu;col++)For(p=1;p<=a.tu;p++) if(a.data[p].j==col){B.data[q].i=a.data[p].j;B.data[q].j=a.data[p].i;B.data[q].v=a.data[p].v;Q++;}}}Out(struct sparmattp x){Int i,j,k,flag;For(i=1;i<=x.mu;i++){For(j=1;j<=x.nu;j++){Flag=0;For(k=1;k<=x.tu;k++){If(((x.data[k].i)==i)&&((x.data[k].j)==j)){Flag=1;Printf("%5d",x.data[k].v);}}If(flag==0)printf(" 0");}Printf("\n");}}Main( ){Printf("稀疏矩阵的建立与转置\n");Crt_sparmat();Trans_sparmat();Printf("原矩阵为:\n");Out(a);Printf("转置矩阵为:\n"); Out(b);}4数和二叉树的应用#include <stdio.h>#include <stdlib.h>#define maxsize 100typedef char datatype;typedef struct node /*二叉树结点类型*/{datatype data;struct node *lchild,*rchild;} bitree;bitree *Q[maxsize]; /*用于创建二叉树*/bitree *CREATREE(); /*函数声明*/int depth(bitree *);void print(bitree *);void print1(bitree *);void print3(bitree *);int main() /*主函数*/{bitree *Bitree;char ch;while(1){printf(" @@@@@@@@@@@@@@@@本程序的功能是输出普通二叉树的深度@@@@@@@@@@@@@@@\n");printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @@@@@@@02-12-07 23:01@@@@@@\n");Bitree = CREATREE(Bitree); /*生成一棵二叉树*/printf("前序打印：");print(Bitree); /*打印二叉树*/printf("\n中序打印：");print2(Bitree);printf("\n后序打印：");print3(Bitree);printf("\n此二叉树的深度为：");printf("%d\n",depth(Bitree));printf("Input 'q' to quit and 'c' run again:");do{if((ch = getchar()) == 'q' || ch == 'Q')exit(0);}while((ch!='C') && (ch!='c'));system("cls");}return 1;}bitree *CREATREE()/*建立二叉树*/{char ch;int front,rear;bitree *root,*s;root = NULL;front = 1;rear = 0;printf("请按完全二叉树的层次（不是完全二叉树的空结点用'@'补全）从左到右的顺序输入，\n详细请参考help.doc.最后用'#'结束：\n");ch = getchar(); /*按完全二叉树的层次输入，不是完全二叉树的空节点用’@‘补全，最后用’#‘结束*/while(ch != '#'){s = NULL;if(ch !='@') /*节点不为空*/{s = malloc(sizeof(bitree));if(!s){printf("内存分配失败!\n");exit(0);}s->data = ch;s->lchild = NULL;s->rchild = NULL;}rear++;Q[rear] = s; /*Q[rear]指向新分配的节点，Q[front]指向上一个的节点*/ if(rear == 1)root = s; /*S为根*/else{if(s && Q[front]) /*若S为孩子*/if(rear%2 == 0)Q[front]->lchild = s; /*S为左孩子*/elseQ[front]->rchild = s; /*S为右孩子*/if(rear%2 == 1)front++;}ch = getchar();}return root;}void print(bitree *t) /*先序形式输出二叉树*/{if (t){printf(" %c", t->data);print(t->lchild);print(t->rchild);}elsereturn;}print2(bitree *t)/*中序递归遍历二叉树*/{if(t){print2(t->lchild);printf(" %c",t->data);print2(t->rchild);}elsereturn;}void print3(bitree *t) /*后序形式输出二叉树*/ {if (t){print3(t->lchild);print3(t->rchild);printf(" %c", t->data);}elsereturn;}int depth(bitree *t) /*求二叉树深度的算法*/{int dep1, dep2;if (t == NULL) return 0;/*空树*/else{dep1 = depth(t->lchild); /*遍历左子树*/dep2 = depth(t->rchild); /*遍历右子树*/if (dep1 > dep2) /*取深度大者*/return (dep1 + 1);elsereturn (dep2 + 1);}}5图的应用#include <stdio.h>#include <stdlib.h>#include <string.h>struct road{ int st; int ed; int w;}; road all[900];int A[30];int cmp(const void *a,const void *b){ return (*(road *)a).w - (*(road *)b).w;} int find(int x){ if (x != A[x])A[x] = find(A[x]);return A[x];}int main(){ int i,j,k,q,p,m,n,sum;char s,e;while (scanf("%d",&n) != EOF){if (n == 0)break;memset(A,0,sizeof(int));for (i = 1;i <= n;i++)A[i] = i;m = 0;for (i = 1;i < n;i++){ scanf(" %c%d",&s,&p); while (p--){scanf(" %c%d",&e,&q);all[m].st = s - 'A';all[m].ed = e - 'A';all[m].w = q;m++;}}qsort(all,m,sizeof(all[0]),cmp);k = 0;sum = 0;while (k < m){all[k].st = find(all[k].st);all[k].ed = find(all[k].ed);if (all[k].st != all[k].ed){sum += all[k].w;A[all[k].st] = all[k].ed;}k++;}printf("%d\n",sum);}system("pause");return 0;}6查找表的应用struct Stu{char name[MAX_NAME_SIZE];//学生名字char sex; //学生性别char stu_id[STU_ID_SIZE]; //学生证号id};class MyList{public:MyList();bool AppendKey(char *name,int sex,char *stuid); //往链表中添加元素void DeleteKey(char *stuid); //删除表中key的元素bool FindKey(char *stuid); //判断表中是否含key的元素void ShowList(); //显示表中的所有元素~MyList();private:struct LNode{struct Stu stu;struct LNode *next;} *m_Head; //表头};//构造函数MyList::MyList(){//初始化表头m_Head = NULL;}//析构函数MyList::~MyList(){//释放申请的内存空间struct LNode *pNode = m_Head;while(pNode){m_Head = m_Head->next;delete pNode;pNode = m_Head;}}bool MyList::AppendKey(char *name,int sex,char *stuid){struct LNode *pNode;pNode = m_Head;while(pNode)//遍历链表{if(!strcmp(pNode->stu.stu_id,stuid))//先查找表中有无相同的值，如果有相同的就返回falsereturn false;pNode = pNode->next;}//把新的节点插入表头pNode = new struct LNode;pNode->next = m_Head;strcpy(pNode->,name);pNode->stu.sex = sex;strcpy(pNode->stu.stu_id,stuid);m_Head = pNode;return true;}void MyList::DeleteKey(char *stuid){struct LNode *pNode,*pPrev;pNode = m_Head;pPrev = NULL;while(pNode)//遍历整个表{if(!strcmp(pNode->stu.stu_id,stuid)){if(pPrev == NULL){//要删除的是头节点m_Head = m_Head->next;delete pNode;}else{//非头节点pPrev->next = pNode->next;delete pNode;}break;}pPrev = pNode;pNode = pNode->next;}}bool MyList::FindKey(char *stuid){struct LNode *pNode;pNode = m_Head;while(pNode)//遍历整个表{if(!strcmp(pNode->stu.stu_id,stuid))//找到值相同的元素，返回true return true;pNode = pNode->next;}return false;//}void MyList::ShowList(){struct LNode *pNode;pNode = m_Head;while(pNode){printf("%s\t",pNode->stu.stu_id);pNode = pNode->next;}printf("\n\n");}void main(){MyList list;list.AppendKey("aaa",0,"3106001771");list.DeleteKey("3106001771");}7排序算法的应用#include<stdio.h>#include<stdlib.h>#include<time.h>void shell_sort(int arr[],int size) {int i,j,k,temp;for(i=size/2;i>0;i/=2){ for(j=i;j<size;j++){ temp=arr[j];for(k=j-i;k>=0&&temp<arr[k];k-=i){ arr[k+i]=arr[k]; }arr[k+i]=temp;}}/* for(i=0;i<size;i++) { printf("%d ",arr[i]); }*/ }void bubble_sort(int arr[],int size){int i,j,k;for(i=size-1;i>0;i=k){ for(j=0,k=0;j<i;j++){ if(arr[j]>arr[j+1]){ arr[j]^=arr[j+1]^=arr[j]^=arr[j+1];k=j;}}} /* for(i=0;i<size;i++) { printf("%d ",arr[i]); }*/ }void insert_sort(int arr[],int size){int i,j,temp;for(i=1;i<size;i++){temp=arr[i];for(j=i-1;j>=0&&temp<arr[j];j--){ arr[j+1]=arr[j]; }arr[j+1]=temp; }/* for(i=0;i<size;i++) { printf("%d ",arr[i]); }*/}void select_sort(int arr[],int size){int i,j,min;for(i=0;i<size-1;i++){ min=i; for(j=i+1;j<size;j++){ if(arr[j]<arr[min]){ min=j;}}if(min!=i){ arr[min]^=arr[i]^=arr[min]^=arr[i];}} /*for(i=0;i<size;i++){ printf("%d ",arr[i]);}*/}void main(){longstart_select,end_select,start_insert,end_insert,start_bubble,end_bubble,start_shell,end_sh ell;int select[15000],insert[15000],bubble[15000],shell[15000];int i,j;srand((int)time(0));select[0]=rand()%25000+1;for(i=1;i<15000;i++){ select[i]=rand()%25000+1; for(j=0;j<i;j++){ if(select[i]==select[j]){ i--;} } } //printf("随机数组：");for(i=0;i<15000;i++){ shell[i]=bubble[i]=insert[i]=select[i];}//printf("%d ",shell[i]); } printf("\n");printf("下面是选择排序：");start_select=clock();select_sort(select,15000);end_select=clock();printf("\n所用的时间是%ld毫秒\n",(long)(end_select-start_select));printf("\n下面是插入排序：");start_insert=clock();insert_sort(insert,15000);end_insert=clock();printf("\n所用的时间是%ld毫秒\n",(long)(end_insert-start_insert));printf("\n下面是冒泡排序：");start_bubble=clock();bubble_sort(bubble,15000);end_bubble=clock();printf("\n所用的时间是%ld毫秒\n",(long)(end_bubble-start_bubble));printf("\n下面是希尔排序：");start_shell=clock();shell_sort(shell,15000);end_shell=clock();printf("\n所用的时间是%ld毫秒\n",(long)(end_shell-start_shell));。