排序算法、链表、二叉树报告
数据结构二叉树实验报告
一 、实验目的和要求(1)掌握树的相关概念,包括树、节点的度、树的度、分支节点、叶子节点、孩子节点、双亲节 点、树的深度、森林等定义。
(2)掌握树的表示,包括树形表示法、文氏图表示法、凹入表示法和括号表示法等。
(3)掌握二叉树的概念,包括二叉树、满二叉树和完全二叉树的定义。
(4)掌握二叉树的性质。
(5)重点掌握二叉树的存储结构,包括二叉树顺序存储结构和链式存储结构。
(6)重点掌握二叉树的基本运算和各种遍历算法的实现。
(7)掌握线索二叉树的概念和相关算法的实现。
(8)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码的产生方法。
(9)掌握并查集的相关概念和算法。
(10)灵活运用二叉树这种数据结构解决一些综合应用问题。
二、实验内容注:二叉树b 为如图7-123所示的一棵二叉树图7-123+实验7.1 编写一个程序algo7-1.cpp,实现二叉树的各种运算,并在此基础上设计一个程序exp7-1.cpp 完成如下功能:(1)输出二叉树b ;(2)输出H 节点的左、右孩子节点值; (3)输出二叉树b 的深度; (4)输出二叉树b 的宽度; (5)输出二叉树b 的节点个数;(6)输出二叉树b 的叶子节点个数。
实验7.2设计一个程序exp7-2.cpp,实现二叉树的先序遍历、中序遍历和后序遍历和非递归算法, 以及层次变量里的算法。
并对图7-123所示的二叉树b 给出求解结果。
b+ACF GIKL+NM+E+HdJD₄B臣1607-1.CPPif(b?-HULL)re3P4+;Qu[rear]-p-b;Qu[rear].1no=1;while(reart=front){Front++;b=Qu[front]-P;lnum-Qu[front].1no;if(b->Ichildt=NULL)rpar+t;Qu[rear]-p=b->1child;Qu[rear].Ino-lnun+1;if(D->rch11d?=NULL)1/根结点指针入队//根结点的层次编号为1 1/队列不为空1/队头出队1/左孩子入队1/右孩子入队redr+t;qu[rear]-p=b->rchild;Qu[rear].1no-lnun*1;}}nax-0;lnun-1;i-1;uhile(i<=rear){n=0;whdle(i<=rear ge Qu[1].1no==1num)n+t;it+;Inun-Qu[i].1n0;if(n>max)nax=n;}return max;田1607-1.CPPreturn max;}elsereturn o;口×int Modes(BTNode *D) //求二叉树D的结点个数int nun1,nun2;if(b==NULL)returng,else if(b->ichild==NULL&D->rchild==NULL)return 1;else{num1-Hodes(b->Ichild);num2=Nodes(b->rchild);return(num1+nun2+1);LeafNodes(BINode *D) //求二叉树p的叶子结点个数int num1,num2;1f(D==NULL)return 0;else if(b->1chi1d==NULLc& b->rch11d==NULL)return 1;else{num1-LeafModes(b->lchild);num2=LeafNodes(b->rchild);return(nun1+nun2);int程序执行结果如下:xCProrn FlslirosfViu l SudiollyPrjecslro7 LJebuglFoj7 ex<1)输出二叉树:A<B<D,E<H<J,K<L,M<,N>>>>),C<F,G<,I>>)<2)'H’结点:左孩子为J石孩子为K(3)二叉树b的深度:7<4)二叉树b的宽度:4(5)二叉树b的结点个数:14(6)二叉树b的叶子结点个数:6<?>释放二叉树bPress any key to continue实验7 . 2程序exp7-2.cpp设计如下:坠eTPT-2.EPP#include<stdio.h》winclude<malloc.h>deFn Masie 00typde chr ElemTyetypede sruct nde{ElemType data;stuc node *lclldstruct node rchild;》BTHode;extern vod reaeBNodeBTNode extrn void DispBTHode(BTNodeuoid ProrderBTNode *b)if(b?-NULL)- 回1 / 数据元素1 / 指向左孩子1 / 指向右孩子*eb car *str)xb1 / 先序遍历的递归算法1 / 访问根结点/ / 递归访问左子树1 7 递归访问右子树/ / 根结点入栈//栈不为空时循环/ / 退栈并访问该结点/ / 右孩子入栈{》v oidprintf(*c“,b->data); Preorder(b->lchild); Pre0rder(b->rchild);Preorder1(BTNode *b)BTNode xSt[Maxsize],*p;int top=-1;if(b!-HULL)top++;St[top]-b;uhle (op>-)p-St[top];top--;printf("%c“,p->data);if(p->rchild?-HULL)A约e程p7-2.CPPprintF(”后序逅历序列:\n");printf(" 递归算法=");Postorder(b);printf("\n");printf(“非递归算法:“);Postorder1(b);printf("\n");序执行结果如下:xCAPrograFleicsoftVisal SudlyrjecsProj 2Debuzlroj72ex"二叉树b:A(B(D,ECH<J,K(L,M<,N)>))),C(F,GC.I>))层次遍历序列:A B C D E F G H I J K L M N先序遍历序列:递归算法:A B D E H J K L M N C F G I非归算法:A B D E H J K L M N C F G I中序遍历序列:递归算法: D B J H L K M N E A F C G I非递归算法:D B J H L K M N E A F C G I后序遍历序列:递归算法: D J L N M K H E B F I G C A非递归算法:D J L N H K H E B F I G C APress any key to continue臼p7-3.CPP15Pp a t h[p a t h l e n]-b->d a t a;//将当前结点放入路径中p a t h l e n t+;/7路任长度培1Al1Path1(b->ichild,patn,pathlen);1/递归扫描左子树Al1Path1(b->rchild,path,pathlen); //递归扫描右子树pathlen-- ; //恢复环境uoid Longpath(BTNode *b,Elemtype path[1,int pathlen,Elemtype longpath[],int elongpatnien) int i;1f(b==NULL){if(pathlen>longpatnlen) //若当前路径更长,将路径保存在1ongpatn中for(i-pathlen-1;i>-8;i--)longpath[i]=path[1];longpathlen-pathlen;elsepath[pathlen]=b->data; pathlen4; //将当前结点放入路径中//路径长度增1iongPath(b->lchild,path₇pathlen,langpath,longpathien);//递归扫描左子树LongPath(b->rchiid,path,pathien,longpath,longpathien);//递归扫描石子树pathlen--; /7饮其环境oid DispLeaf(BTNode xb)- 口凶uoid DispLeaf(BTNode xb)iE(D!=NULL){ if(b->1child--HULL B& b->rchild--HULL)printf("3c“,b->data);elsepispLeaf(b->ichild);DispLeaf(b->rchild);oid nain()8TNodexb;ElenType patn[Maxsize],longpath[Maxsize];int i.longpathien-U;CreateBTNode(b,"A(B(D,E(H(J,K(L,H(,N))))),C(F,G(,I)))");printf("\n二灾树b:");DispBTNode(b);printf("\n\n*);printf(”b的叶子结点:");DispLeaf(b);printf("\n\n");printf("A11Path:");A11Path(b);printf("m");printf("AiiPath1:n");AliPath1(b.path.);printf("");LongPath(b,path,8,longpath,longpathlen);printf(”第一条量长路径长度=d\n”,longpathlen);printf(”"第一茶最长路径:");for(i=longpathlen;i>=0;i--)printf("c",longpatn[1]);printf("\n\n");。
二叉排序树的实验报告
二叉排序树的实验报告二叉排序树的实验报告引言:二叉排序树(Binary Search Tree,简称BST)是一种常用的数据结构,它将数据按照一定的规则组织起来,便于快速的查找、插入和删除操作。
本次实验旨在深入了解二叉排序树的原理和实现,并通过实验验证其性能和效果。
一、实验背景二叉排序树是一种二叉树,其中每个节点的值大于其左子树的所有节点的值,小于其右子树的所有节点的值。
这种特性使得在二叉排序树中进行查找操作时,可以通过比较节点的值来确定查找的方向,从而提高查找效率。
二、实验目的1. 理解二叉排序树的基本原理和性质;2. 掌握二叉排序树的构建、插入和删除操作;3. 验证二叉排序树在查找、插入和删除等操作中的性能和效果。
三、实验过程1. 构建二叉排序树首先,我们需要构建一个空的二叉排序树。
在构建过程中,我们可以选择一个节点作为根节点,并将其他节点插入到树中。
插入节点时,根据节点的值与当前节点的值进行比较,如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。
重复这个过程,直到所有节点都被插入到树中。
2. 插入节点在已有的二叉排序树中插入新的节点时,我们需要遵循一定的规则。
首先,从根节点开始,将新节点的值与当前节点的值进行比较。
如果小于当前节点的值,则将其插入到当前节点的左子树中;如果大于当前节点的值,则将其插入到当前节点的右子树中。
如果新节点的值与当前节点的值相等,则不进行插入操作。
3. 删除节点在二叉排序树中删除节点时,我们需要考虑不同的情况。
如果要删除的节点是叶子节点,即没有左右子树,我们可以直接删除该节点。
如果要删除的节点只有一个子树,我们可以将子树连接到要删除节点的父节点上。
如果要删除的节点有两个子树,我们可以选择将其右子树中的最小节点或左子树中的最大节点替代该节点,并删除相应的替代节点。
四、实验结果通过对二叉排序树的构建、插入和删除操作的实验,我们得到了以下结果:1. 二叉排序树可以高效地进行查找操作。
数据结构实验报告总结反思
数据结构实验报告总结反思引言在本学期的数据结构实验课程中,我们学习了各种常用的数据结构和算法,并进行了相应的实验操作。
通过实验,我们巩固了理论知识,并锻炼了自己的编程能力和问题解决能力。
在本次实验报告中,我将对我所学到的内容进行总结和反思,并讨论未来的学习计划和改进方法。
总结学习内容在实验课程中,我学习了以下数据结构和算法:1. 线性表:包括顺序表和链表,学会了它们的插入、删除和查找操作。
2. 栈和队列:熟悉了它们的特性和基本操作,并应用到实际问题中。
3. 二叉树:了解了树的定义和遍历方法,熟悉了二叉搜索树的操作。
4. 图:学习了图的基本概念和表示方法,实现了图的遍历和最短路径算法。
5. 排序算法:掌握了冒泡排序、选择排序、插入排序、快速排序等排序算法的原理和实现。
实验操作在每次实验中,我都认真阅读了实验指导书,并按照指导书上的要求进行了实验操作。
通过自己的努力,我成功地实现了实验要求,并得到了正确的结果。
实验操作中,我尽量养成了规范的编程习惯,包括良好的命名、合理的代码结构和注释等。
这有助于提高代码的可读性和可维护性。
实验收获通过实验,我对数据结构和算法有了更深入的理解,巩固了相关知识。
在实验过程中,我遇到了一些问题,并学会了解决它们。
同时,实验也锻炼了我的编程能力和解决问题的能力。
通过不断地思考和实践,我提高了自己的代码质量和效率,并学会了如何写出更优雅的代码。
反思遇到的问题在实验过程中,我遇到了一些问题,其中包括以下几点:1. 对于一些复杂的数据结构和算法,理解起来较为困难。
我需要花费更多的时间来学习和掌握这些内容。
2. 在某些情况下,实验指导书的说明不够清晰。
我需要仔细阅读并进行补充学习,以理解实验的要求和实现思路。
3. 在编写代码时,我有时会犯一些低级错误,比如数组越界、指针错误等。
我需要更加细心和谨慎地编写代码,以避免这些错误的发生。
改进方法为了提升自己的学习效果和编程能力,我计划采取以下改进方法:1. 增加学习时间。
算法与及数据结构实验报告
算法与及数据结构实验报告算法与数据结构实验报告一、实验目的本次算法与数据结构实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见算法和数据结构的基本原理、特性和应用,提高我们解决实际问题的能力和编程技巧。
二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。
同时,为了进行算法性能的分析和比较,使用了 Python 的 time 模块来计算程序的运行时间。
三、实验内容1、线性表的实现与操作顺序表的实现:使用数组来实现顺序表,并实现了插入、删除、查找等基本操作。
链表的实现:通过创建节点类来实现链表,包括单向链表和双向链表,并完成了相应的操作。
2、栈和队列的应用栈的实现与应用:用数组或链表实现栈结构,解决了表达式求值、括号匹配等问题。
队列的实现与应用:实现了顺序队列和循环队列,用于模拟排队系统等场景。
3、树结构的探索二叉树的创建与遍历:实现了二叉树的先序、中序和后序遍历算法,并对其时间复杂度进行了分析。
二叉搜索树的操作:构建二叉搜索树,实现了插入、删除、查找等操作。
4、图的表示与遍历邻接矩阵和邻接表表示图:分别用邻接矩阵和邻接表来存储图的结构,并对两种表示方法的优缺点进行了比较。
图的深度优先遍历和广度优先遍历:实现了两种遍历算法,并应用于解决路径查找等问题。
5、排序算法的比较插入排序、冒泡排序、选择排序:实现了这三种简单排序算法,并对不同规模的数据进行排序,比较它们的性能。
快速排序、归并排序:深入理解并实现了这两种高效的排序算法,通过实验分析其在不同情况下的表现。
6、查找算法的实践顺序查找、二分查找:实现了这两种基本的查找算法,并比较它们在有序和无序数据中的查找效率。
四、实验步骤及结果分析1、线性表的实现与操作顺序表:在实现顺序表的插入操作时,如果插入位置在表的末尾或中间,需要移动后续元素以腾出空间。
删除操作同理,需要移动被删除元素后面的元素。
在查找操作中,通过遍历数组即可完成。
C语言算法与数据结构常用算法和数据结构
C语言算法与数据结构常用算法和数据结构C语言作为一门广泛应用于软件开发领域的编程语言,对于掌握算法和数据结构的知识非常重要。
掌握常用的算法和数据结构,不仅可以帮助我们解决实际问题,还能提高代码的效率和质量。
本文将介绍C语言中常见的算法和数据结构。
一、算法1. 排序算法(1)冒泡排序:通过不断比较相邻元素并交换位置,将最大(或最小)元素逐步冒泡到最后的位置。
(2)插入排序:将一个元素插入到已排序部分的正确位置,逐步构建有序序列。
(3)快速排序:通过选择一个基准元素,将数据分为两部分,一部分小于基准,一部分大于基准,然后递归地对两部分进行排序。
(4)归并排序:将待排序序列递归地分成两个子序列,然后将两个有序子序列合并成一个有序序列。
2. 查找算法(1)线性查找:逐个比较每个元素,直到找到目标元素或搜索结束。
(2)二分查找:在有序序列中,通过比较目标值与中间元素的大小关系,将查找范围缩小一半,直到找到目标元素或搜索结束。
(3)哈希查找:通过哈希函数计算目标元素在数组中的位置,快速定位目标元素。
二、数据结构1. 数组数组是一种线性数据结构,可以存储多个相同类型的元素。
通过索引可以快速访问数组中的元素,但插入和删除元素的操作较为复杂。
2. 链表链表是一种动态数据结构,可以在运行时分配内存。
每个节点存储数据和指向下一个节点的指针,可以方便地进行插入和删除节点的操作,但访问节点需要遍历链表。
3. 栈栈是一种先进后出(LIFO)的数据结构,只能在栈顶进行插入和删除操作。
常用于表达式求值、递归函数调用等场景。
4. 队列队列是一种先进先出(FIFO)的数据结构,可以在队尾插入元素,在队头删除元素。
常用于任务调度、缓冲区管理等场景。
5. 树树是一种非线性数据结构,由节点和边组成。
常见的树结构包括二叉树、二叉搜索树、平衡二叉树等。
6. 图图是一种包含节点和边的非线性数据结构,用于表示多对多的关系。
常见的图结构包括有向图、无向图、加权图等。
数据结构的实验报告
一、实验目的本次实验旨在让学生掌握数据结构的基本概念、逻辑结构、存储结构以及各种基本操作,并通过实际编程操作,加深对数据结构理论知识的理解,提高编程能力和算法设计能力。
二、实验内容1. 线性表(1)顺序表1)初始化顺序表2)向顺序表插入元素3)从顺序表删除元素4)查找顺序表中的元素5)顺序表的逆序操作(2)链表1)创建链表2)在链表中插入元素3)在链表中删除元素4)查找链表中的元素5)链表的逆序操作2. 栈与队列(1)栈1)栈的初始化2)入栈操作3)出栈操作4)获取栈顶元素5)判断栈是否为空(2)队列1)队列的初始化2)入队操作3)出队操作4)获取队首元素5)判断队列是否为空3. 树与图(1)二叉树1)创建二叉树2)遍历二叉树(前序、中序、后序)3)求二叉树的深度4)求二叉树的宽度5)二叉树的镜像(2)图1)创建图2)图的深度优先遍历3)图的广度优先遍历4)最小生成树5)最短路径三、实验过程1. 线性表(1)顺序表1)初始化顺序表:创建一个长度为10的顺序表,初始化为空。
2)向顺序表插入元素:在顺序表的第i个位置插入元素x。
3)从顺序表删除元素:从顺序表中删除第i个位置的元素。
4)查找顺序表中的元素:在顺序表中查找元素x。
5)顺序表的逆序操作:将顺序表中的元素逆序排列。
(2)链表1)创建链表:创建一个带头结点的循环链表。
2)在链表中插入元素:在链表的第i个位置插入元素x。
3)在链表中删除元素:从链表中删除第i个位置的元素。
4)查找链表中的元素:在链表中查找元素x。
5)链表的逆序操作:将链表中的元素逆序排列。
2. 栈与队列(1)栈1)栈的初始化:创建一个栈,初始化为空。
2)入栈操作:将元素x压入栈中。
3)出栈操作:从栈中弹出元素。
4)获取栈顶元素:获取栈顶元素。
5)判断栈是否为空:判断栈是否为空。
(2)队列1)队列的初始化:创建一个队列,初始化为空。
2)入队操作:将元素x入队。
3)出队操作:从队列中出队元素。
排序算法设计实验报告总结
排序算法设计实验报告总结1. 引言排序算法是计算机科学中最基础的算法之一,它的作用是将一组数据按照特定的顺序进行排列。
在现实生活中,我们经常需要对一些数据进行排序,比如学生成绩的排名、图书按照标题首字母进行排序等等。
因此,了解不同的排序算法的性能特点以及如何选择合适的排序算法对于解决实际问题非常重要。
本次实验旨在设计和实现几种经典的排序算法,并对其进行比较和总结。
2. 实验方法本次实验设计了四种排序算法,分别为冒泡排序、插入排序、选择排序和快速排序。
实验采用Python语言进行实现,并通过编写测试函数对算法进行验证。
测试函数会生成一定数量的随机数,并对这些随机数进行排序,统计算法的执行时间和比较次数,最后将结果进行记录和分析。
3. 测试结果及分析3.1 冒泡排序冒泡排序是一种简单且常用的排序算法,其基本思想是从待排序的数据中依次比较相邻的两个元素,如果它们的顺序不符合要求,则交换它们的位置。
经过多轮的比较和交换,最小值会逐渐冒泡到前面。
测试结果显示,冒泡排序在排序1000个随机数时,平均执行时间为0.981秒,比较次数为499500次。
从执行时间和比较次数来看,冒泡排序的性能较差,对于大规模数据的排序不适用。
3.2 插入排序插入排序是一种简单但有效的排序算法,其基本思想是将一个待排序的元素插入到已排序的子数组中的正确位置。
通过不断将元素插入到正确的位置,最终得到排序好的数组。
测试结果显示,插入排序在排序1000个随机数时,平均执行时间为0.892秒,比较次数为249500次。
插入排序的性能较好,因为其内层循环的比较次数与待排序数组的有序程度相关,对于近乎有序的数组排序效果更好。
3.3 选择排序选择排序是一种简单但低效的排序算法,其基本思想是在待排序的数组中选择最小的元素,将其放到已排序数组的末尾。
通过多次选择和交换操作,最终得到排序好的数组。
测试结果显示,选择排序在排序1000个随机数时,平均执行时间为4.512秒,比较次数为499500次。
数据结构实验三——二叉树基本操作及运算实验报告
《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目,以及二叉树常用运算。
问题分析:二叉树树型结构是一类重要的非线性数据结构,对它的熟练掌握是学习数据结构的基本要求。
由于二叉树的定义本身就是一种递归定义,所以二叉树的一些基本操作也可采用递归调用的方法。
处理本问题,我觉得应该:1、建立二叉树;2、通过递归方法来遍历(先序、中序和后序)二叉树;3、通过队列应用来实现对二叉树的层次遍历;4、借用递归方法对二叉树进行一些基本操作,如:求叶子数、树的深度宽度等;5、运用广义表对二叉树进行广义表形式的打印。
算法规定:输入形式:为了方便操作,规定二叉树的元素类型都为字符型,允许各种字符类型的输入,没有元素的结点以空格输入表示,并且本实验是以先序顺序输入的。
输出形式:通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印,再以广义表形式进行打印。
对二叉树的一些运算结果以整型输出。
程序功能:实现对二叉树的先序、中序和后序遍历,层次遍历。
计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。
对二叉树的某个元素进行查找,对二叉树的某个结点进行删除。
测试数据:输入一:ABC□□DE□G□□F□□□(以□表示空格),查找5,删除E预测结果:先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A(B(C,D(E(,G),F)))叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5,成功,查找的元素为E删除E后,以广义表形式打印A(B(C,D(,F)))输入二:ABD□□EH□□□CF□G□□□(以□表示空格),查找10,删除B预测结果:先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A(B(D,E(H)),C(F(,G)))叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10,失败。
排序算法实验报告
数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的C语言程序,要求包含直接插入排序、希尔排序、简单项选择择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。
二、实验步骤各种内部排序算法的比较:1.八种排序算法的复杂度分析〔时间与空间〕。
2.八种排序算法的C语言编程实现。
3.八种排序算法的比较,包括比较次数、移动次数。
三、稳定性,时间复杂度和空间复杂度分析比较时间复杂度函数的情况:时间复杂度函数O(n)的增长情况所以对n较大的排序记录。
一般的选择都是时间复杂度为O(nlog2n)的排序方法。
时间复杂度来说:(1)平方阶(O(n2))排序各类简单排序:直接插入、直接选择和冒泡排序;(2)线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序;(3)O(n1+§))排序,§是介于0和1之间的常数。
希尔排序(4)线性阶(O(n))排序基数排序,此外还有桶、箱排序。
说明:当原表有序或基本有序时,直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数,时间复杂度可降至O〔n〕;而快速排序则相反,当原表基本有序时,将蜕化为冒泡排序,时间复杂度提高为O〔n2〕;原表是否有序,对简单项选择择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性:排序算法的稳定性:假设待排序的序列中,存在多个具有相同关键字的记录,经过排序,这些记录的相对次序保持不变,则称该算法是稳定的;假设经排序后,记录的相对次序发生了改变,则称该算法是不稳定的。
稳定性的好处:排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。
另外,如果排序算法稳定,可以防止多余的比较;稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。
数据结构与算法实验内容
数据结构与算法实验内容数据结构与算法是计算机科学的重要基础学科,它涵盖了许多相关的知识和技能。
实验作为教学的一种重要形式,可以帮助学生更好地理解和掌握数据结构与算法的概念、原理和应用。
下面将介绍一些常见的数据结构与算法实验内容。
一、线性表实验线性表是最基本也是最常用的数据结构之一,在实验中通常会涉及到顺序存储和链式存储两种实现方式。
实验内容包括:1.顺序存储线性表的实现与应用:包括插入、删除、查找等操作的实现,并应用到具体问题中,比如统计学生的成绩排名等。
2.链式存储线性表的实现与应用:使用指针构建链表,实现插入、删除、查找等操作,并将其应用到具体问题中,比如实现一个简单的个人通讯录。
二、栈和队列实验栈和队列是常用的数据结构,它们的实现和应用在算法中有着广泛的应用。
实验内容包括:1.栈的实现与应用:使用数组或链表实现栈,实现入栈、出栈等操作,并应用到具体问题中,比如计算中缀表达式的值。
2.队列的实现与应用:使用数组或链表实现队列,实现入队、出队等操作,并将其应用到具体问题中,比如模拟排队等待。
3.实现简单的计算器:使用栈实现一个简单的计算器,可以进行加减乘除等基本运算。
三、树和图实验树和图是一种重要的非线性数据结构,其实现和应用在许多算法中扮演了重要的角色。
实验内容包括:1.二叉树的实现与应用:使用数组或链表实现二叉树,并实现遍历、查找等操作,比如实现一个简单的二叉树。
2.图的实现与应用:使用邻接矩阵或邻接表实现图,并实现深度优先、广度优先等操作,比如求解迷宫问题。
3.哈夫曼树的构造与应用:使用优先队列和贪心算法构造哈夫曼树,并将其应用于数据压缩等问题中。
四、排序和查找实验排序和查找是算法中的经典问题,涵盖的算法十分丰富,并有许多经典的算法可以进行实现和比较。
1.基本排序算法的实现与比较:包括冒泡排序、插入排序、选择排序等算法的实现和性能比较。
2.高级排序算法的实现与比较:包括快速排序、归并排序、堆排序等算法的实现和性能比较。
数据结构课程实验报告
数据结构课程实验报告一、实验目的本次数据结构课程实验的主要目的是通过实践掌握常见数据结构的基本操作,包括线性结构、树形结构和图形结构。
同时,也要求学生能够熟练运用C++语言编写程序,并且能够正确地使用各种算法和数据结构解决具体问题。
二、实验内容本次实验涉及到以下几个方面:1. 线性表:设计一个线性表类,并且实现线性表中元素的插入、删除、查找等基本操作。
2. 栈和队列:设计一个栈类和队列类,并且分别利用这两种数据结构解决具体问题。
3. 二叉树:设计一个二叉树类,并且实现二叉树的遍历(前序遍历、中序遍历和后序遍历)。
4. 图论:设计一个图类,并且利用图论算法解决具体问题(如最短路径问题)。
三、实验过程1. 线性表首先,我们需要设计一个线性表类。
在这个类中,我们需要定义一些成员变量(如线性表大小、元素类型等),并且定义一些成员函数(如插入元素函数、删除元素函数等)。
在编写代码时,我们需要注意一些细节问题,如边界条件、异常处理等。
2. 栈和队列接下来,我们需要设计一个栈类和队列类。
在这两个类中,我们需要定义一些成员变量(如栈顶指针、队头指针等),并且定义一些成员函数(如入栈函数、出栈函数、入队函数、出队函数等)。
在编写代码时,我们需要注意一些细节问题,如空间不足的情况、空栈或空队列的情况等。
3. 二叉树然后,我们需要设计一个二叉树类,并且实现二叉树的遍历。
在这个类中,我们需要定义一个节点结构体,并且定义一些成员变量(如根节点指针、节点数量等),并且定义一些成员函数(如插入节点函数、删除节点函数、遍历函数等)。
在编写代码时,我们需要注意一些细节问题,如递归调用的情况、空节点的情况等。
4. 图论最后,我们需要设计一个图类,并且利用图论算法解决具体问题。
在这个类中,我们需要定义一个邻接矩阵或邻接表来表示图形结构,并且定义一些成员变量(如顶点数量、边的数量等),并且定义一些成员函数(如添加边函数、删除边函数、最短路径算法等)。
数据结构实验报告-树(二叉树)
实验5:树(二叉树)(采用二叉链表存储)一、实验项目名称二叉树及其应用二、实验目的熟悉二叉树的存储结构的特性以及二叉树的基本操作。
三、实验基本原理之前我们都是学习的线性结构,这次我们就开始学习非线性结构——树。
线性结构中结点间具有唯一前驱、唯一后继关系,而非线性结构中结点的前驱、后继的关系并不具有唯一性。
在树结构中,节点间关系是前驱唯一而后继不唯一,即结点之间是一对多的关系。
直观地看,树结构是具有分支关系的结构(其分叉、分层的特征类似于自然界中的树)。
四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和预定义2.创建二叉树3.前序遍历4.中序遍历5.后序遍历6.总结点数7.叶子节点数8.树的深度9.树根到叶子的最长路径10.交换所有节点的左右子女11.顺序存储12.显示顺序存储13.测试函数和主函数对二叉树的每一个操作写测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define MAX_TREE_SIZE 100typedef char ElemType;ElemType SqBiTree[MAX_TREE_SIZE];struct BiTNode{ElemType data;BiTNode *l,*r;}*T;void createBiTree(BiTNode *&T){ElemType e;e = getchar();if(e == '\n')return;else if(e == ' ')T = NULL;else{if(!(T = (BiTNode *)malloc(sizeof (BiTNode)))){cout << "内存分配错误!" << endl;exit(0);}T->data = e;createBiTree(T->l);createBiTree(T->r);}}void createBiTree2(BiTNode *T,int u) {if(T){SqBiTree[u] = T->data;createBiTree2(T->l,2 * u + 1);createBiTree2(T->r,2 * u + 2); }}void outputBiTree2(int n){int cnt = 0;for(int i = 0;cnt <= n;i++){cout << SqBiTree[i];if(SqBiTree[i] != ' ')cnt ++;}cout << endl;}void preOrderTraverse(BiTNode *T) {if(T){cout << T->data;preOrderTraverse(T->l);preOrderTraverse(T->r);}}void inOrderTraverse(BiTNode *T) {if(T){inOrderTraverse(T->l);cout << T->data;inOrderTraverse(T->r);}}void beOrderTraverse(BiTNode *T){if(T){beOrderTraverse(T->l);beOrderTraverse(T->r);cout << T->data;}}int sumOfVer(BiTNode *T){if(!T)return 0;return sumOfVer(T->l) + sumOfVer(T->r) + 1;}int sumOfLeaf(BiTNode *T){if(!T)return 0;if(T->l == NULL && T->r == NULL)return 1;return sumOfLeaf(T->l) + sumOfLeaf(T->r);}int depth(BiTNode *T){if(!T)return 0;return max(depth(T->l),depth(T->r)) + 1;}bool LongestPath(int dist,int dist2,vector<ElemType> &ne,BiTNode *T) {if(!T)return false;if(dist2 == dist)return true;if(LongestPath(dist,dist2 + 1,ne,T->l)){ne.push_back(T->l->data);return true;}else if(LongestPath(dist,dist2 + 1,ne,T->r)){ne.push_back(T->r->data);return true;}return false;}void swapVer(BiTNode *&T){if(T){swapVer(T->l);swapVer(T->r);BiTNode *tmp = T->l;T->l = T->r;T->r = tmp;}}//以下是测试程序void test1(){getchar();cout << "请以先序次序输入二叉树结点的值,空结点用空格表示:" << endl; createBiTree(T);cout << "二叉树创建成功!" << endl;}void test2(){cout << "二叉树的前序遍历为:" << endl;preOrderTraverse(T);cout << endl;}void test3(){cout << "二叉树的中序遍历为:" << endl;inOrderTraverse(T);cout << endl;}void test4(){cout << "二叉树的后序遍历为:" << endl;beOrderTraverse(T);cout << endl;}void test5(){cout << "二叉树的总结点数为:" << sumOfVer(T) << endl;}void test6(){cout << "二叉树的叶子结点数为:" << sumOfLeaf(T) << endl; }void test7(){cout << "二叉树的深度为:" << depth(T) << endl;}void test8(){int dist = depth(T);vector<ElemType> ne;cout << "树根到叶子的最长路径:" << endl;LongestPath(dist,1,ne,T);ne.push_back(T->data);reverse(ne.begin(),ne.end());cout << ne[0];for(int i = 1;i < ne.size();i++)cout << "->" << ne[i];cout << endl;}void test9(){swapVer(T);cout << "操作成功!" << endl;}void test10(){memset(SqBiTree,' ',sizeof SqBiTree);createBiTree2(T,0);cout << "操作成功!" << endl;}void test11(){int n = sumOfVer(T);outputBiTree2(n);}int main(){int op = 0;while(op != 12){cout << "-----------------menu--------------------" << endl;cout << "--------------1:创建二叉树--------------" << endl;cout << "--------------2:前序遍历----------------" << endl;cout << "--------------3:中序遍历----------------" << endl;cout << "--------------4:后序遍历----------------" << endl;cout << "--------------5:总结点数----------------" << endl;cout << "--------------6:叶子节点数--------------" << endl;cout << "--------------7:树的深度----------------" << endl;cout << "--------------8:树根到叶子的最长路径----" << endl;cout << "--------------9:交换所有节点左右子女----" << endl;cout << "--------------10:顺序存储---------------" << endl;cout << "--------------11:显示顺序存储-----------" << endl;cout << "--------------12:退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl;if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1();break;case 2:test2();break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:cout << "测试结束!" << endl;break;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果测试用例:1.创建二叉树(二叉链表形式)2.前序遍历3.中序遍历4.后序遍历5.总结点数6.叶子结点数7.树的深度8.树根到叶子的最长路径9.交换所有左右子女10.顺序存储七、思考讨论题或体会或对改进实验的建议通过这次实验,我掌握了二叉树的顺序存储和链式存储,体会了二叉树的存储结构的特性,掌握了二叉树的树上相关操作。
二叉排序树(二叉链表结构存储)数据结构课程设计报告
二叉排序树(二叉链表结构存储)数据结构课程设计报告目录1需求分析 (1)1.1课程设计题目、任务及要求 (1)1.2课程设计思想 (1)2概要设计 (2)2.1 二叉排序树的定义 (2)2.2二叉链表的存储结构 (2)2.3建立二叉排序树 (2)2.4二叉排序树的生成过程 (3)2.5中序遍历二叉树 (3)2.6二叉排序树的查找 (3)2.7二叉排序树的插入 (4)2.8平均查找长度 (4)3详细设计和实现 (4)3.1主要功能模块设计 (4)3.2主程序设计 (5)4调试与操作说明 (12)4.1程序调试 (12)4.2程序操作说明 (13)总结 (16)致谢 (17)参考文献 (19)1需求分析1.1课程设计题目、任务及要求二叉排序树。
用二叉链表作存储结构(1)以(0)为输入结束标志,输入数列L,生成一棵二叉排序树T;(2)对二叉排序树T作中序遍历,输出结果;(3)计算二叉排序树T查找成功的平均查找长度,输出结果;(4)输入元素x,查找二叉排序树T:若存在含x的结点,则删除该结点,并作中序遍历(执行操作2);否则输出信息“无x”;1.2课程设计思想建立二叉排序树采用边查找边插入的方式。
查找函数采用递归的方式进行查找。
如果查找成功则不应再插入原树,否则返回当前结点的上一个结点。
然后利用插入函数将该元素插入原树。
对二叉排序树进行中序遍历采用递归函数的方式。
在根结点不为空的情况下,先访问左子树,再访问根结点,最后访问右子树。
由于二叉排序树自身的性质,左子树小于根结点,而根结点小于右子树,所以中序遍历的结果是递增的。
计算二插排序树的平均查找长度时,仍采用类似中序遍历的递归方式,用s记录总查找长度,j记录每个结点的查找长度,s置初值为0,采用累加的方式最终得到总查找长度s。
平均查找长度就等于s/i(i为树中结点的总个数)。
删除结点函数,采用边查找边删除的方式。
如果没有查找到,则不对树做任何的修改;如果查找到结点,则分四种情况分别进行讨论:1、该结点左右子树均为空;2、该结点仅左子树为空;3、该结点仅右子树为空;4、该结点左右子树均不为空。
实验报告 实验三 二叉排序树的建立和查找
实验三二叉排序树的建立和查找一、实验目的1.掌握二叉排序树的建立算法2.掌握二叉排序树查找算法。
二、实验环境操作系统和C语言系统三、预习要求复习二叉排序树的生成及查找算法,编写完整的程序。
四、实验内容实现二叉排序树上的查找算法。
具体实现要求:用二叉链表做存储结构,输入键值序列,建立一棵二叉排序树并在二叉排序树上实现查找算法。
五、参考算法#include <stdio.h>#include <stdlib.h>typedef int InfoType;typedef int KeyType; /*假定关键字类型为整数*/typedef struct node /*结点类型*/{KeyType key; /*关键字项*/InfoType otherinfo; /*其它数据域,InfoType视应用情况而定,下面不处理它*/struct node *lchild,*rchild; /*左右孩子指针*/}BSTNode;typedef BSTNode *BSTree; /*BSTree是二叉排序树的类型*/BSTNode *SearchBST(BSTree T,KeyType key){ /*在二叉排序树T上查找关键字为key的结点,成功时返回该结点位置,否则返回NULL*/if(T==NULL||key==T->key) /*递归的终结条件*/return T; /*若T为空,查找失败;否则成功,返回找到的结点位置*/if(key<T->key)return SearchBST(T->lchild,key);elsereturn SearchBST(T->rchild,key); /*继续在右子树中查找*/}void InsertBST(BSTree *T,int key){ /*插入一个值为key的节点到二叉排序树中*/BSTNode *p,*q;if((*T)==NULL){ /*树为空树*/(*T)=(BSTree)malloc(sizeof(BSTNode));(*T)->key=key;(*T)->lchild=(*T)->rchild=NULL;}else{p=(*T);while(p){q=p;if(p->key>key)p=q->lchild;else if(p->key<key)p=q->rchild;else{printf("\n 该二叉排序树中含有关键字为%d的节点!\n",key);return;}}p=(BSTree)malloc(sizeof(BSTNode));p->key=key;p->lchild=p->rchild=NULL;if(q->key>key)q->lchild=p;elseq->rchild=p;}}BSTree CreateBST(void){ /*输入一个结点序列,建立一棵二叉排序树,将根结点指针返回*/BSTree T=NULL; /*初始时T为空树*/KeyType key;scanf("%d",&key); /*读入一个关键字*/while(key){ /*假设key=0是输入结束标志*/ InsertBST(&T,key); /*将key插入二叉排序树T*/scanf("%d",&key); /*读入下一关键字*/}return T; /*返回建立的二叉排序树的根指针*/ }void ListBinTree(BSTree T) /*用广义表示二叉树*/{if(T!=NULL){printf("%d",T->key);if(T->lchild!=NULL||T->rchild!=NULL){printf("(");ListBinTree(T->lchild);if(T->rchild!=NULL)printf(",");ListBinTree(T->rchild);printf(")");}}}void main(){BSTNode *SearchBST(BSTree T,KeyType key);void InsertBST(BSTree *Tptr,KeyType key);BSTree CreateBST();void ListBinTree(BSTree T);BSTree T;BSTNode *p;int key;printf("请输入关键字(输入0为结束标志):\n");T=CreateBST();ListBinTree(T);printf("\n");printf("请输入欲查找关键字:");scanf("%d",&key);p=SearchBST(T,key);if(p==NULL)printf("没有找到%d!\n",key);elseprintf("找到%d!\n",key);ListBinTree(p);printf("\n");}实验中出现的问题及对问题的解决方案输入数据时,总是不能得到结果,原因是在建立二叉树函数定义中,是对指针的值进行了修改。
c常用的数据结构与算法
c常用的数据结构与算法C常用的数据结构与算法数据结构和算法是计算机科学的基础,对于编程和问题解决至关重要。
在C语言中,有许多常用的数据结构和算法,本文将介绍其中一些。
一、数据结构1. 数组(Array)数组是最简单的数据结构之一,它是一组相同类型的元素的集合。
在C语言中,数组的元素可以是任何类型,如整数、字符或自定义结构体。
数组具有随机访问的特点,可以通过索引值快速访问或修改元素。
2. 链表(Linked List)链表是由一系列节点组成的数据结构,每个节点包含一个数据元素和一个指向下一个节点的指针。
链表可以分为单向链表和双向链表两种形式。
链表的插入和删除操作比较高效,但访问元素需要遍历链表。
3. 栈(Stack)栈是一种后进先出(LIFO)的数据结构,只允许在栈顶进行插入和删除操作。
栈可以使用数组或链表实现,常用于实现函数调用的过程、括号匹配等场景。
4. 队列(Queue)队列是一种先进先出(FIFO)的数据结构,允许在队尾进行插入操作,在队头进行删除操作。
队列也可以使用数组或链表实现,常用于实现广度优先搜索、缓冲区等场景。
5. 树(Tree)树是一种非线性的数据结构,由节点和边组成。
树的每个节点可以有多个子节点,其中一个节点称为根节点。
树的应用非常广泛,如二叉搜索树、平衡二叉树、堆等。
6. 图(Graph)图是由节点和边组成的数据结构,节点之间的连接关系称为边。
图可以分为有向图和无向图两种形式,常用于表示网络、社交关系等复杂结构。
二、算法1. 排序算法排序算法是将一组元素按照特定顺序排列的算法。
常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等。
排序算法的选择取决于数据规模和性能要求。
2. 查找算法查找算法是在一组元素中查找特定元素的算法。
常见的查找算法有线性查找、二分查找、哈希查找等。
查找算法的效率取决于数据的有序性和数据规模。
3. 图算法图算法是处理图数据结构的算法,常见的有深度优先搜索(DFS)、广度优先搜索(BFS)、最短路径算法(Dijkstra算法、Floyd-Warshall算法)、最小生成树算法(Prim算法、Kruskal算法)等。
数据结构实践报告文库版
数据结构实践报告文库版一、实践背景数据结构是计算机科学中的基础课程,通过学习和实践数据结构,可以增强学生对计算机系统底层原理的理解,培养学生的编程能力和问题解决能力。
本实践报告主要介绍了我在学习数据结构课程过程中的实践经验和学习成果。
二、实践内容本次实践主要包括以下几个方面:1.线性表:学习并实现了线性表的顺序存储结构和链式存储结构,并比较两种结构的优缺点。
通过实践,我深入理解了线性表的基本概念和操作,对于线性表的插入、删除和查找等操作也有了较为熟练的掌握。
2.栈与队列:学习并实现了栈和队列的基本操作,并通过实践中的应用场景,如括号匹配、迷宫求解等,加深了对栈和队列的理解。
通过实践,我发现栈和队列的应用非常广泛,对于问题的解决具有很强的实用性。
3.树与二叉树:学习并实现了树和二叉树的基本操作,如创建、遍历等,并通过实践中的应用场景,如表达式树、赫夫曼树等,进一步了解了树和二叉树的特点和应用。
通过实践,我发现树和二叉树在算法设计和数据处理中发挥着重要的作用,对于复杂问题的解决具有很大的帮助。
4.图:学习并实现了图的基本操作,如创建、遍历等,并通过实践中的应用场景,如最短路径问题、图的连通性等,加深了对图的理解。
通过实践,我认识到图是一种重要的数据结构,广泛应用于网络、社交等领域,对于解决复杂的关系问题具有重要作用。
三、实践成果通过对数据结构的学习和实践,我取得了如下成果:1.编程能力的提升:通过实践,我进一步熟悉了C/C++语言的基本语法和程序设计思想,提高了编程能力。
在实践过程中,我学会了如何分析问题、设计算法,并用代码实现,提高了自己的解决问题的能力。
2.问题解决能力的增强:通过实践过程,我掌握了一些常见问题的解决方法,如括号匹配、迷宫求解等。
在实践过程中,我学会了如何分析问题的特点和要求,选用合适的数据结构和算法进行解决,提高了解决问题的效率和质量。
3.学习能力的提高:通过实践,我更加深入地理解了数据结构的基本概念、操作和应用。
常用数据结构和算法
常用数据结构和算法在计算机科学领域,数据结构和算法是构建高效程序的基石。
无论是开发软件应用,还是进行系统优化,都离不开对数据结构和算法的研究和应用。
本文将介绍一些常用的数据结构和算法,并讨论它们的特点和应用场景。
一、数组(Array)数组是最基本的数据结构之一,它由一系列连续的内存空间组成,可以存储相同类型的数据。
数组的特点是随机存取,即可以通过索引直接访问指定位置的元素。
数组在存取数据时效率非常高,但插入和删除操作则比较低效。
它的应用场景包括存储一组有序的数据、快速查找等。
二、链表(Linked List)链表是一种非连续的数据结构,由多个节点组成,每个节点包含一个数据元素和指向下一个节点的指针。
链表的特点是插入和删除操作效率高,但查找操作则比较低效,需要遍历整个链表。
链表适用于频繁插入和删除元素的场景,比如实现队列、栈等。
三、栈(Stack)栈是一种特殊的数据结构,它遵循先入后出(LIFO)的原则。
栈可以用数组或链表来实现,常见的操作包括入栈(push)和出栈(pop)。
栈的应用场景很广,比如表达式求值、函数调用等。
四、队列(Queue)队列是一种遵循先入先出(FIFO)原则的数据结构。
队列可以用数组或链表来实现,常见的操作包括入队(enqueue)和出队(dequeue)。
队列的应用包括任务调度、消息传递等。
五、树(Tree)树是一种层次结构的数据结构,由节点和边组成。
树的结构使得在其中进行搜索、插入和删除等操作非常高效。
常见的树结构包括二叉树、二叉搜索树、平衡二叉树、红黑树等。
树的应用非常广泛,比如文件系统、数据库索引等。
六、图(Graph)图是一种由节点和边组成的非线性数据结构,它包括有向图和无向图。
图的表示方式有邻接矩阵和邻接表两种,它的应用场景包括网络拓扑分析、搜索算法等。
七、排序算法排序算法是数据处理中非常重要的一类算法,主要用于将一组无序的数据按照某种规则进行排序。
常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。
数据结构与算法知识点必备
数据结构与算法知识点必备一、数据结构知识点1. 数组(Array)数组是一种线性数据结构,它由相同类型的元素组成,通过索引访问。
数组的特点是随机访问速度快,但插入和删除操作较慢。
常见的数组操作包括创建、访问、插入、删除和遍历。
2. 链表(Linked List)链表是一种动态数据结构,它由节点组成,每一个节点包含数据和指向下一个节点的指针。
链表的特点是插入和删除操作快,但访问速度较慢。
常见的链表类型包括单向链表、双向链表和循环链表。
3. 栈(Stack)栈是一种后进先出(LIFO)的数据结构,只能在栈顶进行插入和删除操作。
常见的栈操作包括入栈(push)和出栈(pop)。
4. 队列(Queue)队列是一种先进先出(FIFO)的数据结构,只能在队尾插入元素,在队头删除元素。
常见的队列操作包括入队(enqueue)和出队(dequeue)。
5. 树(Tree)树是一种非线性数据结构,由节点和边组成。
树的特点是层次结构、惟一根节点、每一个节点最多有一个父节点和多个子节点。
常见的树类型包括二叉树、二叉搜索树、平衡二叉树和堆。
6. 图(Graph)图是一种非线性数据结构,由节点和边组成。
图的特点是节点之间的关系可以是任意的,可以有环。
常见的图类型包括有向图、无向图、加权图和连通图。
7. 哈希表(Hash Table)哈希表是一种根据键(key)直接访问值(value)的数据结构,通过哈希函数将键映射到数组中的一个位置。
哈希表的特点是查找速度快,但内存消耗较大。
常见的哈希表操作包括插入、删除和查找。
二、算法知识点1. 排序算法(Sorting Algorithms)排序算法是将一组元素按照特定顺序罗列的算法。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。
2. 查找算法(Search Algorithms)查找算法是在一组元素中寻觅特定元素的算法。
常见的查找算法包括线性查找、二分查找和哈希查找。
树和二叉树实验报告
树和二叉树、实验目的1. 掌握二叉树的结构特征,以及各种存储结构的特点及适用范围。
2. 掌握用指针类型描述、访问和处理二叉树的运算。
、实验要求1. 认真阅读和掌握本实验的程序。
2. 上机运行本程序。
3. 保存和打印出程序的运行结果,并结合程序进行分析。
4. 按照二叉树的操作需要,重新改写主程序并运行,打印出文件清单和运行结果。
、实验内容1. 输入字符序列,建立二叉链表。
2. 按先序、中序和后序遍历二叉树(递归算法)。
3. 按某种形式输出整棵二叉树。
4. 求二叉树的高度。
5. 求二叉树的叶节点个数。
6. 交换二叉树的左右子树。
7. 借助队列实现二叉树的层次遍历。
8. 在主函数中设计一个简单的菜单,分别调试上述算法。
为了实现对二叉树的有关操作,首先要在计算机中建立所需的二叉树。
建立二叉树有各种不同的方法。
一种方法是利用二叉树的性质5来建立二叉树,输入数据时要将节点的序号(按满二叉树编号)和数据同时给出:(序号,数据元素0)。
另一种方法是主教材中介绍的方法,这是一个递归方法,与先序遍历有点相似。
数据的组织是先序的顺序,但是另有特点,当某结点的某孩子为空时以字符“#”来充当,也要输入。
若当前数据不为“#”则申请一个结点存入当前数据。
递归调用建立函数,建立当前结点的左右子树。
四、解题思路1、先序遍历:O访问根结点,G先序遍历左子树,C3先序遍历右子树2、中序遍历:O中序遍历左子树,C2访问根结点,。
中序遍历右子树3、后序遍历:O后序遍历左子树,C2后序遍历右子树,C3访问根结点4、层次遍历算法:采用一个队列q,先将二叉树根结点入队列,然后退队列,输出该结点;若它有左子树,便将左子树根结点入队列;若它有右子树,便将右子树根结点入队列,直到队列空为止。
因为队列的特点是先进后出,所以能够达到按层次遍历二叉树的目的。
五、程序清单#in clude<stdio.h>#in clude<stdlib.h>#defi ne M 100typedef char Etype; //定义二叉树结点值的类型为字符型typedef struct BiTNode {//树结点结构Etype data;struct BiTNode *lch,*rch;}BiTNode,*BiTree;BiTree que[M];int fron t=0,rear=0;//函数原型声明BiTNode *creat_bt1();BiTNode *creat_bt2();void preorder(BiTNode *p);void ino rder(BiTNode *p);void postorder(BiTNode *p);void enq ueue(BiTree);BiTree delqueue();void levorder(BiTree);int treedepth(BiTree);void prtbtree(BiTree,i nt);void excha nge(BiTree);in t leafco un t(BiTree);void pain tleaf(BiTree);BiTNode *t;int coun t=0;//主函数void mai n() {char ch;int k;do{prin tf("\n\n\n");prin tf("\n=================== 主菜单===================");prin tf("\n\n 1.建立二叉树方法1");prin tf("\n\n 2.建立二叉树方法2");prin tf("\n\n 3•先序递归遍历二叉树”);prin tf("\n\n 4•中序递归遍历二叉树”);prin tf("\n\n 5.后序递归遍历二叉树”);printf("\n\n 6.层次遍历二叉树”);prin tf("\n\n 7.计算二叉树的高度”);prin tf("\n\n 8.计算二叉树中叶结点个数”);prin tf("\n\n 9.交换二叉树的左右子树”);printf("\n\n 10.打印二叉树”);printf("\n\n 0.结束程序运行”);prin tf("\n============================================");printf("\n 请输入您的选择(0,1,2,3,4,5,6,7,8,9,10)");sea nf("%d",&k);switch(k){case 1:t=creat_bt1( );break; //调用性质5建立二叉树算法case 2:pri ntf("\n 请输入二叉树各结点值:");fflush(stdi n);t=creat_bt2();break; //调用递归建立二叉树算法case 3:if(t){printf("先序遍历二叉树:");preorder(t);prin tf("\n");}else printf(” 二叉树为空!\n");break;case 4:if(t){printf("中序遍历二叉树:");ino rder(t);prin tf("\n");}else printf("二叉树为空!\n");break;case 5:if(t)postorder(t);{printf("后序遍历二叉树:");prin tf("\n");}else printf(” 二叉树为空!\n");break;case 6:if(t){printf("层次遍历二叉树:");levorder(t);prin tf("\n");}else printf("二叉树为空!\n");break;case 7:if(t){printf("二叉树的高度为:%d",treedepth(t));prin tf("\n");}else printf("二叉树为空!\n");break;case 8:if(t){printf("二叉树的叶子结点数为:%d\n",leafcount(t));prin tf("\n");printf("二叉树的叶结点为:");pai ntleaf(t);else printf(” 二叉树为空!\n");break;case 9:if(t){printf("交换二叉树的左右子树:\n");excha nge(t);prtbtree(t,0);prin tf("\n");}else printf("二叉树为空!\n");break;case 10:if(t){printf("逆时针旋转90度输出的二叉树:\n");prtbtree(t,0);prin tf("\n");}else printf("二叉树为空!\n");break;case 0:exit(0);} //switch}while(k>=1 &&k<=10);printf("\n再见!按回车键,返回… \n");ch=getchar();} //main//利用二叉树性质5,借助一维数组V建立二叉树BiTNode *creat_bt1(){ BiTNode *t,*p,*v[20];i nt i,j;Etype e;/*输入结点的序号i、结点的数据e*/printf("\n请输入二叉树各结点的编号和对应的值(如1,a):");sca nf("%d,%c",&i,&e);while(i!=0&&e!='#') {//当i为0, e为#时,结束循环p=(BiTNode*)malloc(sizeof(BiTNode));p->data=e;p->lch=NULL;p->rch=NULL;v[i]=p;if(i==1)t=p; //序号为1的结点是根else{j=i/2;if(i%2==0)v[j]->lch=p;//序号为偶数,作为左孩子else v[j]_>rch=p; //序号为奇数,作为右孩子}printf("\n请继续输入二叉树各结点的编号和对应的值:”);scan f("%d,%c",&i, &e);}return(t);}//creat_bt1;//模仿先序递归遍历方法,建立二叉树BiTNode *creat_bt2(){BiTNode *t;Etype e;scan f("%c",&e);if(e==' #')t=NULL; //对于#值,不分配新结点else{t=(BiTNode *)malloc(sizeof(BiTNode));t->data=e;t->lch=creat_bt2(); //左孩子获得新指针值t->rch=creat_bt2(); //右孩子获得新指针值return(t);} 〃creat_bt2//先序递归遍历二叉树void preorder(BiTNode *p) {if(P){prin tf("%3c",p->data);preorder(p_>lch);preorder(p->rch);}} //preorder〃中序递归遍历二叉树void ino rder(BiTNode *p){if(p){ino rder(p->lch);prin tf("%3c",p->data);ino rder(p->rch);}} //ino rder//后序递归遍历二叉树void postorder(BiTNode *p){ if(p){ postorder(p->lch);postorder(p->rch);prin tf("%3c",p->data);}} //postorder void enq ueue(BiTree T){if(fron t!=(rear+1)%M){rear=(rear+1)%M;que[rear]=T;}}BiTree delqueue(){if(fron t==rear)return NULL;fron t=(fro nt+1)%M;return(que[fro nt]);}void levorder(BiTree T)//层次遍历二叉树{BiTree p;if(T){enq ueue(T);while(fro nt!=rear){p=delqueue( );prin tf("%3d",p->data);if(p->lch!=NULL)e nqueue(p->lch); if(p->rch!=NULL)e nq ueue(p->rch);}}} int treedepth(BiTree bt){int hl,hr,max;if(bt!=NULL){ hl=treedepth(bt->lch); hr=treedepth(bt->rch);max=(hl>hr)?hl:hr; return (max+1);}else return (0);} void prtbtree(BiTree bt,i nt level)形{int j;if(bt){prtbtree(bt->rch,level+1);for(j=0;j<=6*level;j++)pri ntf(" ”);prin tf("%c\n",bt->data);prtbtree(bt->lch,level+1);}}//计算二叉树的高度〃逆时针旋转90度输出二叉树树void excha nge(BiTree bt) // 交换二叉树左右子树{BiTree p;if(bt){p=bt->lch;bt->lch=bt->rch;bt->rch=p;excha nge(bt->lch);excha nge(bt->rch);}}in t leafcou nt(BiTree bt) // 计算叶结点数{if(bt!=NULL){leafc oun t(bt->lch);leafc oun t(bt->rch);if((bt->lch==NULL) &&(bt->rch==NULL))coun t++;}return(co unt);void pai ntleaf(BiTree bt) // 输出叶结点{if(bt!=NULL) {if(bt->lch==NULL&&bt->rch==NULL)prin tf("%3c",bt->data);pain tleaf(bt->lch);pain tleaf(bt->rch);}}图11.2所示二叉树的输入数据顺序应该是:abd#g###ce#h##f##图11.2 二叉树示意图运行结果:=================王采单1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 1请输入二叉树各结点的编号和对应的值(如1,a):1,a 请继续输入二叉树各结点的编号和对应的值:2,b请继续输入二叉树各结点的编号和对应的值:3,c请继续输入二叉树各结点的编号和对应的值:4,d请继续输入二叉树各结点的编号和对应的值:6,e请继续输入二叉树各结点的编号和对应的值:7,f请继续输入二叉树各结点的编号和对应的值:9,g请继续输入二叉树各结点的编号和对应的值:13,h请继续输入二叉树各结点的编号和对应的值:===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 3先序遍历二叉树:abdgcehf===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 4中序遍历二叉树:dgbaehcf===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23. 先序递归遍历二叉树4. 中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 5后序遍历二叉树:gdbhefca===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 6层次遍历二叉树:97 98 99100101102103104===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 7 二叉树的高度为:4王采单 1. 建立二叉树方法 12. 建立二叉树方法 23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 8 二叉树的叶子结点数为:3二叉树的叶结点为: g h f1. 建立二叉树方法 12. 建立二叉树方法 23. 先序递归遍历二叉树===================王采单"); ”);4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 9交换二叉树的左右子树:dgbaehc===================王采单");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 10 逆时针旋转90度输出的二叉树:dgbaehc王采单”);1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 2请输入二叉树各结点值:abd#g###ce#h##f##===================主菜单===================");1. 建立二叉树方法12. 建立二叉树方法23•先序递归遍历二叉树4•中序递归遍历二叉树5. 后序递归遍历二叉树6. 层次遍历二叉树7. 计算二叉树的高度8. 计算二叉树中叶结点个数9. 交换二叉树的左右子树10. 打印二叉树0.结束程序运行请输入您的选择(0,1,2,3,4,5,6,7,8,9,10) 0请按任意键继续•• •六、调试心得及收获建立二叉树有两种方法:一种方法是利用二叉树的性质5来建立二叉树;另一种方法是主教材中介绍的方法,这是一个递归方法,与先序遍历有点相似。
算法与程序设计知识点
算法与程序设计知识点1.数据结构1.1 数组数组是一种线性数据结构,用于存储固定大小的相同类型的数据元素。
1.2 链表链表是一种线性数据结构,由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
1.3 栈栈是一种先进后出(LIFO)的数据结构,只能在栈顶进行插入和删除操作。
1.4 队列队列是一种先进先出(FIFO)的数据结构,只能在队首进行删除操作,在队尾进行插入操作。
1.5 树树是一种非线性的数据结构,由一组以层次关系存储的节点组成。
1.6 图图是一种非线性的数据结构,由一组节点和边组成,用于表示事物之间的关系。
2.排序算法2.1 冒泡排序冒泡排序是一种简单的排序算法,重复地比较相邻的两个元素,若顺序错误则交换位置。
2.2 插入排序插入排序是一种简单直观的排序算法,将未排序序列中的元素依次插入到已排序序列的适当位置。
2.3 选择排序选择排序是一种简单的排序算法,每次从未排序序列中选择最小(或最大)的元素放到已排序序列的末尾。
2.4 快速排序快速排序是一种常用的排序算法,通过递归地分解问题,然后组合结果得到有序序列。
2.5 归并排序归并排序是一种分治法排序算法,将序列分成两个子序列,分别排序,然后再合并结果。
3.编程基础3.1 变量和表达式变量是用于存储数据的占位符,表达式是由操作符和操作数组成的计算式。
3.2 控制结构控制结构用于控制程序的执行流程,包括条件语句(if-else)、循环语句(for、while)、跳转语句(break、continue)等。
3.3 函数和过程函数是一段封装了特定功能的代码,过程是一段没有返回值的函数。
3.4 异常处理异常处理用于捕获和处理程序中出现的异常情况,以保证程序的正常执行。
4.算法设计4.1 递归和迭代递归是一种通过调用自身解决问题的方法,迭代是通过循环解决问题。
4.2 动态规划动态规划是一种通过将问题分解为子问题的方法来解决复杂问题。
4.3 贪心算法贪心算法是一种通过每一步选择最优解来求解整体最优解的方法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构实验报告班级:学号:姓名:实验一:约瑟夫环一、实验目的综合应用所学的知识分析问题、解决问题,学会用单链表与循环链表解决问题,提高实际编程能力及程序调试能力。
二、实验要求采用单链表或循环链表设计约瑟夫环三、实验内容约瑟夫环问题是:编号为1,2,…,n的n个人按顺时针方向围坐一圈,每人有一个正整数编号。
从某个位置上的人开始报数,数到m的人便出列,下一个人(第m+1个)又从1数起,数到m的人便是第二个出列的人,依次重复下去,直到最后一个人出列。
于是得到一个新的次序,试设计程序求出出列顺序。
输入数据检测结果,m=4,n=8。
四、实验原理用单链表(或循环链表)存储数据,利用循环按要求将链表中的数据输出,实现约瑟夫环。
五、实验程序与结果#include <iostream>#include<stdio.h>#include<conio.h>using namespace std;struct person{ int data;person *next; };int main(){ int n=0;int m=0;cout<<"请输入总人数n:";cin>>n;cout<<"请输入m:";cin>>m;person *head=new person;person *p=head;for (int i=1;i<=n;i++){ if(i==1)head->data=i;else{ p->next=new person;p=p->next;p->data=i;}//设置节点;}p->next=head;//连接首尾节点;cout<<"结果为:"<<ends;while(p->next!=p){ for (int j=1;j<m;j++)p=p->next;person *q=p;p=p->next;q->next=p->next;//删除节点;cout<<p->data<<" ";//输出删除的节点delete p;p=q; }cout<<p->data;delete p;cout<<endl;getch();return 0;}//单向循环链表实验二:二叉树的遍历一、实验目的综合应用所学的知识分析问题、解决问题,学会用建立二叉树并对其进行遍历,提高实际编程能力及程序调试能力。
二、实验要求建立一个二叉树并对其进行遍历(先序,中序,后序)三、实验内容1、问题描述:建立一个二叉树,并分别用前序、中序、后序遍历该二叉树。
2、说明:输入数据:5,6,7,0,0,8,9,0,0,7,6,0,0,0,10,11,0,0,11,15,12,0,0,15,0,0,16,0,0其中“0”表示空子树。
输出数据:先序:5,6,7,8,9,7,6,10,11,11,15,12,15,16。
中序:7,6,9,8,6,7,5,11,10,12,15,15,11,16。
后序:7,9,6,7,8,6,11,12,15,15,16,11,10,5。
四、实验仪器与设备计算机,JDK,记事本五、实验原理建立一个二叉树,利用递归的方法实现对该二叉树的前序,中序,后序的遍历,并输出遍历结果。
六、实验程序#include<iostream>#include<stdio.h>#include<conio.h>using namespace std;typedef struct btnode{ int data;btnode *Lchild,*Rchild;}*Btnode;void Creat(Btnode & t){ int ch;cin>>ch;if(ch==0)t=NULL;else{ btnode *p=new btnode;p->data=ch;t=p;Creat(t->Lchild);Creat(t->Rchild); }}void Preorder(Btnode & p){ if(p!=NULL){ cout<<p->data<<",";Preorder(p->Lchild);Preorder(p->Rchild); } }void Midorder(Btnode & p){ if(p!=NULL){ Midorder(p->Lchild);cout<<p->data<<",";Midorder(p->Rchild); } }void Folorder(Btnode & p){ if(p!=NULL){ Folorder(p->Lchild);Folorder(p->Rchild);cout<<p->data<<","; }}void main(){ btnode *head=new btnode;cout<<"请输入数据:";Creat(head);cout<<"前序遍历:";Preorder(head);cout<<endl;cout<<"中序遍历:";Midorder(head);cout<<endl;cout<<"后序遍历:";Folorder(head);getch();}八、实验结果九、实验体会通过本次实验,我更深刻的理解了二叉树的性质,加深了对二叉树的遍历的认识,通过上机实验,增强了动手以及自己思考能力。
实验三拓扑结构排序一、实验内容题目:实现下图的拓扑排序。
二、目的与要求1、目的a、了解拓扑排序的方法及其在工程建设中的实际意义。
b、掌握拓扑排序的算法,了解拓扑排序的有向图的数据结构。
2、要求用C语言编写程序,实现图的拓扑排序操作。
三、实验仪器与设备计算机,JDK,记事本四、程序源代码#include<iostream>#include<cmath>#include<cstdio>#include<algorithm>#include<stack>using namespace std;#define MAX 9999stack<int>mystack;int indegree[MAX];struct node{int adjvex;node* next;}adj[MAX];int Create(node adj[],int n,int m)//邻接表建表函数,n代表定点数,m代表边数{ int i;node *p;for(i=0;i<=n-1;i++){ adj[i].adjvex=i;adj[i].next=NULL; }for(i=0;i<=m-1;i++){ cout<<"请输入第"<<i<<"条边:";int u,v;cin>>u>>v;p=new node;p->adjvex=v;p->next=adj[u].next;adj[u].next=p;}return 1;}void print(int n)//邻接表打印函数{ int i;node *p;for(i=0;i<=n-1;i++){ p=&adj[i];while(p!=NULL){ cout<<p->adjvex<<' ';p=p->next; }cout<<endl;}}void topsort(node adj[],int n){ int i;node *p;memset(indegree,0,sizeof(indegree));for(i=0;i<=n-1;i++){ p=adj[i].next;while(p!=NULL){ indegree[p->adjvex]++;p=p->next;}}for(i=0;i<=n-1;i++){ if(indegree[i]==0)mystack.push(i);}int count=0;while(mystack.size()!=0){ i=mystack.top();mystack.pop();cout<<i<<' ';count++;for(p=adj[i].next;p!=NULL;p=p->next) { int k=p->adjvex;indegree[k]--;if(indegree[k]==0)mystack.push(k);}}cout<<endl;if(count<n)cout<<"有回路"<<endl; }int main(){ int n;int m;cout<<"请输入顶点数及边数:";cin>>n>>m;Create(adj,n,m);cout<<"输入的邻接表为:"<<endl; print(n);cout<<"拓扑排序结果为:"<<endl; topsort(adj,n);system("pause");return 0;}四、实验结果五、实验体会通过实验了解了拓扑结构,更加熟悉了拓扑排序的算法,增强了自主思考与解决问题的能力。
实验四内排序一、实验内容1、插入排序2、快速排序(quick sorting)3、堆排序二、实验程序1、插入排序(insert sorting)最差情况下,直接插入排序的最大时间代价为θ(n²),最小时间代价为θ(n),平均时间代价为θ(n²)。
#include <iostream>using namespace std;/*交换函数,作用是交换数组中的两个元素的位置*/void swap(int array[],int i,int j){int tmp=array[i];array[i]=array[j];array[j]=tmp;} /*插入排序*/void InsertSort(int array[],int n){for(int i=1;i<n;i++){for(int j=i;j>0;j--){if(array[j]>array[j-1])swap(array,j,j-1);elsebreak; } } }int main(){ int array[5]={3,1,2,5,4};InsertSort(array,5);for(int i=0;i<5;i++)cout<<array[i]<<" ";cout<<endl;return 0;}2、快速排序(quick sorting)快速排序的最大时间代价为θ(n²),最小时间代价为θ(n*logn),平均时间代价为θ(n*logn)。