数据结构课程设计各种排序算法比较 附带源代码
内部排序比较 (实验报告+源程序)C++
实验报告3实验名称：数据结构与软件设计实习题目：内部排序算法比较专业：生物信息学班级：01 姓名：学号：实验日期：2010.07.24一、实验目的：比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序；二、实验要求：待排序长度不小于100，数据可有随机函数产生，用五组不同输入数据做比较，比较的指标为关键字参加比较的次数和关键字移动的次数；对结果做简单的分析，包括各组数据得出结果的解释；设计程序用顺序存储。
三、实验内容对各种内部排序算法的时间复杂度有一个比较直观的感受，包括关键字比较次数和关键字移动次数。
将排序算法进行合编在一起，可考虑用顺序执行各种排序算法来执行，最后输出所有结果。
四、实验编程结果或过程：1. 数据定义typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length;}SqList;2. 函数如下，代码详见文件“排序比较.cpp”int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ])3. 运行测试结果，运行结果无误，如下图语速个数为20元素个数为100错误调试无。
10个经典的C语言基础算法及代码
10个经典的C语言基础算法及代码1.冒泡排序算法冒泡排序是一种简单但效率较低的排序算法，在每一轮遍历中比较相邻的两个元素，如果顺序不正确则交换它们，直到整个数组有序为止。
```cvoid bubbleSort(int arr[], int n)for (int i = 0; i < n-1; i++)for (int j = 0; j < n-1-i; j++)if (arr[j] > arr[j+1])int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}```2.选择排序算法选择排序是一种简单直观的排序算法，它每次从待排序的数组中选择最小（或最大）的元素，并放到已排序的数组末尾。
```cvoid selectionSort(int arr[], int n)for (int i = 0; i < n-1; i++)int min_index = i;for (int j = i+1; j < n; j++)if (arr[j] < arr[min_index])min_index = j;}}int temp = arr[i];arr[i] = arr[min_index];arr[min_index] = temp;}```3.插入排序算法插入排序的基本思想是将数组分为已排序和未排序两部分，每次将未排序的元素插入到已排序的合适位置。
```cvoid insertionSort(int arr[], int n)for (int i = 1; i < n; i++)int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key)arr[j+1] = arr[j];j--;}arr[j+1] = key;}```4.快速排序算法快速排序使用分治法的思想，每次选择一个基准元素，将小于基准的元素放到左边，大于基准的元素放到右边，然后递归地对左右两个子数组进行排序。
源代码--数据结构与算法(Python版)chap10 排序
交换类
（2）快速排序 快速排序采用分而治之(Divide and Conquer)
的策略将问题分解成若干个较小的子问题，采用 相同的方法一一解决后，再将子问题的结果整合 成最终答案。快速排序的每一轮处理其实就是将 这一的基准数定位，直到所有的数都排序完成 为止。
21
快速排序的基本步骤：
1. 选定一个基准值（通常可选第一个元素）； 2. 将比基准值小的数值移到基准值左边，形
14
• 交换类
交换类排序的基本思想是：通过交换无序序列 中的记录得到其中关键字最小或最大的记录，并将 其加入到有序子序列中，最终形成有序序列。交换 类排序可分为冒泡排序和快速排序等。
15
交换类
（1）冒泡排序 两两比较待排序记录的关键字，发现两
个记录的次序相反时即进行交换，直到没有 反序的记录为止。因为元素会经由交换慢慢 浮到序列顶端，故称之为冒泡排序。
3. 最后对这个组进行插入排序。步长的选法 一般为 d1 约为 n/2，d2 为 d1 /2， d3 为 d2/2 ，…， di = 1。
11
【例】给定序列（11，9，84，32，92，26，58，91，35， 27，46，28，75，29，37，12 ），步长设为d1 =5、d2 =3、 d3 =1，希尔排序过程如下：
for i in range(1,len(alist)):
#外循环n-1
for j in range(i,0,-1):
#内循环
if alist[j]<alist[j-1]:
alist[j],alist[j-1]=alist[j-1],alist[j] #交换
li=[59,12,77,64,72,69,46,89,31,9] print('before: ',li) insert_sort(li) print('after: ',li)
数据结构课程设计—内部排序算法比较
数据结构课程设计—内部排序算法比较在计算机科学领域中，数据的排序是一项非常基础且重要的操作。
内部排序算法作为其中的关键部分，对于提高程序的运行效率和数据处理能力起着至关重要的作用。
本次课程设计将对几种常见的内部排序算法进行比较和分析，包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
冒泡排序是一种简单直观的排序算法。
它通过重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
这种算法的优点是易于理解和实现，但其效率较低，在处理大规模数据时性能不佳。
因为它在最坏情况下的时间复杂度为 O(n²)，平均时间复杂度也为O(n²)。
插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个序列有序。
插入排序在数据量较小时表现较好，其平均时间复杂度和最坏情况时间复杂度也都是 O(n²)，但在某些情况下，它的性能可能会优于冒泡排序。
选择排序则是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。
以此类推，直到全部待排序的数据元素排完。
选择排序的时间复杂度同样为O(n²)，但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。
快速排序是一种分治的排序算法。
它首先选择一个基准元素，将数列分成两部分，一部分的元素都比基准小，另一部分的元素都比基准大，然后对这两部分分别进行快速排序。
快速排序在平均情况下的时间复杂度为 O(nlogn)，最坏情况下的时间复杂度为 O(n²)。
然而，在实际应用中，快速排序通常表现出色，是一种非常高效的排序算法。
归并排序也是一种分治算法，它将待排序序列分成若干个子序列，每个子序列有序，然后将子序列合并成一个有序序列。
C语言八大排序算法
C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法，附动图和详细代码解释！来源：C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式，那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码，不通过不断的锤炼，是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分，系统地学习⼀下是很有必要的。
1、排序的概念排序是计算机内经常进⾏的⼀种操作，其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。
若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。
反之，若参加排序的记录数量很⼤，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。
2、排序分类⼋⼤排序算法均属于内部排序。
如果按照策略来分类，⼤致可分为：交换排序、插⼊排序、选择排序、归并排序和基数排序。
如下图所⽰：3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序：简单选择排序，快速排序，希尔排序，堆排序稳定排序：冒泡排序，直接插⼊排序，归并排序，奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序，然后将第3个元素插⼊到已经排好序的元素中，依次类推（插⼊排序最好的情况就是数组已经有序了）因为插⼊排序每次只能操作⼀个元素，效率低。
元素个数N，取奇数k=N/2，将下标差值为k的数分为⼀组（⼀组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为⼀组，构成有序序列，直到k=1，然后再进⾏直接插⼊排序。
3、简单选择排序选出最⼩的数和第⼀个数交换，再在剩余的数中⼜选择最⼩的和第⼆个数交换，依次类推4、堆排序以升序排序为例，利⽤⼩根堆的性质（堆顶元素最⼩）不断输出最⼩元素，直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶，再重新构造成⼩根堆，再输出堆顶元素，以此类推5、冒泡排序改进1：如果某次冒泡不存在数据交换，则说明已经排序好了，可以直接退出排序改进2：头尾进⾏冒泡，每次把最⼤的沉底，最⼩的浮上去，两边往中间靠16、快速排序选择⼀个基准元素，⽐基准元素⼩的放基准元素的前⾯，⽐基准元素⼤的放基准元素的后⾯，这种动作叫分区，每次分区都把⼀个数列分成了两部分，每次分区都使得⼀个数字有序，然后将基准元素前⾯部分和后⾯部分继续分区，⼀直分区直到分区的区间中只有⼀个元素的时候，⼀个元素的序列肯定是有序的嘛，所以最后⼀个升序的序列就完成啦。
数据结构课程设报告—各种排序算法的比较
数据结构课程设计报告几种排序算法的演示1、需求分析:运行环境:Microsoft Visual Studio 20052、程序实现功能:3、通过用户键入的数据, 经过程序进行排序, 最后给予数据由小到大的输出。
排序的方式包含教材中所介绍的几种常用的排序方式：直接插入排序、折半插入排序、冒泡排序、快速排序、选择排序、堆排序、归并排序。
每种排序过程中均显示每一趟排序的细节。
程序的输入:输入所需排序方式的序号。
输入排序的数据的个数。
输入具体的数据元素。
程序的输出:输出排序每一趟的结果, 及最后排序结果1、设计说明:算法设计思想:a交换排序（冒泡排序、快速排序）交换排序的基本思想是: 对排序表中的数据元素按关键字进行两两比较, 如果发生逆序（即排列顺序与排序后的次序正好相反）, 则两者交换位置, 直到所有数据元素都排好序为止。
b插入排序（直接插入排序、折半插入排序）插入排序的基本思想是: 每一次设法把一个数据元素插入到已经排序的部分序列的合适位置, 使得插入后的序列仍然是有序的。
开始时建立一个初始的有序序列, 它只包含一个数据元素。
然后, 从这个初始序列出发不断插入数据元素, 直到最后一个数据元素插到有序序列后, 整个排序工作就完成了。
c选择排序（简单选择排序、堆排序）选择排序的基本思想是: 第一趟在有n个数据元素的排序表中选出关键字最小的数据元素, 然后在剩下的n-1个数据元素中再选出关键字最小（整个数据表中次小）的数据元素, 依次重复, 每一趟（例如第i趟, i=1, …, n-1）总是在当前剩下的n-i+1个待排序数据元素中选出关键字最小的数据元素, 作为有序数据元素序列的第i个数据元素。
等到第n-1趟选择结束, 待排序数据元素仅剩下一个时就不用再选了, 按选出的先后次序所得到的数据元素序列即为有序序列, 排序即告完成。
d归并排序（两路归并排序）1、两路归并排序的基本思想是: 假设初始排序表有n个数据元素, 首先把它看成是长度为1的首尾相接的n个有序子表（以后称它们为归并项）, 先做两两归并, 得n/2上取整个长度为2的归并项（如果n为奇数, 则最后一个归并项的长度为1）；再做两两归并, ……, 如此重复, 最后得到一个长度为n的有序序列。
数据结构课程设计实践报告
数据结构实验报告本文是范文，仅供参考写作，禁止抄袭本文内容上传提交，违者取消写作资格，成绩不合格！实验名称：排序算法比较提交文档学生姓名：提交文档学生学号：同组成员名单：指导教师姓名：排序算法比较一、实验目的和要求1、设计目的1．掌握各种排序的基本思想。
2．掌握各种排序方法的算法实现。
3．掌握各种排序方法的优劣分析及花费的时间的计算。
4．掌握各种排序方法所适应的不同场合。
2、设计内容和要求利用随机函数产生30000个随机整数，利用插入排序、起泡排序、选择排序、快速排序、堆排序、归并排序等排序方法进行排序，并统计每一种排序上机所花费的时间二、运行环境（软、硬件环境）软件环境：Vc6.0编程软件运行平台： Win32硬件：普通个人pc机三、算法设计的思想1、冒泡排序：bubbleSort()基本思想: 设待排序的文件为r[1..n]第1趟(遍)：从r[1]开始,依次比较两个相邻记录的关键字r[i].key和r[i+1].key,若r[i].key>r[i+1].key，则交换记录r[i]和r[i+1]的位置；否则,不交换。
(i=1,2,...n-1)第1趟之后,n个关键字中最大的记录移到了r[n]的位置上。
第2趟：从r[1]开始,依次比较两个相邻记录的关键字r[i].key和r[i+1].key,若r[i].key>r[i+1].key，则交换记录r[i]和r[i+1]的位置；否则,不交换。
(i=1,2,...n-2)第2趟之后,前n-1个关键字中最大的记录移到了r[n-1]的位置上，作完n-1趟,或者不需再交换记录时为止。
2、选择排序：selSort()每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
选择排序不像冒泡排序算法那样先并不急于调换位置，第一轮（k=1）先从array[k]开始逐个检查，看哪个数最小就记下该数所在的位置于minlIndex中，等一轮扫描完毕，如果找到比array[k-1]更小的元素，则把array[minlIndex]和a[k-1]对调，这时array[k]到最后一个元素中最小的元素就换到了array[k-1]的位置。
数据结构课程设计源代码(完整版)
算法与数据结构课程设计报告设计题目：专业班级学生学号指导教师2014年第1学期第一部分：需求分析1、系统名称：航空客运订票系统航空客运订票的业务活动包括：查询航线、客票预定和办理退票等。
要求在TC或VC环境下设计一个航空客运订票系统，以使上述业务可以借助计算机来完成。
2、要求：(1)每条航线所涉及的信息有：终点站名、航班号、飞机号、飞行日期(星期几)、乘员定额、余票量、已经订票的客户名单(包括姓名、订票量)以及等候替补的客户名单(包括姓名、所需票量)。
(2)作为模拟系统，全部数据可以只存放在内存中。
(3)通过此系统可以实现如下功能：①录入功能：可以录入航班情况②查询功能：根据客户提供的终点站名进行查询，可以输出以下信息：航班号、飞机号、星期几飞行和余票量等。
也可以根据航班号，查询飞机某个航线的情况。
③订票功能：根据客户提出的要求(姓名、终点站名、订票数量)查询该航班的余票量情况。
如尚有足够的余票，则为客户办理订票手续；若已满员或余票量少于订票数量，则需要重新询问客户要求，如需要，可登记排队候补。
④退票功能：根据客户提供的情况(姓名、日期、航班号)，为客户办理退票手续，然后查询该航班是否有人排队候补，若有人排队，则为排在第一位的客户办理订票手续。
第二部分：系统设计图样一：设计说明1：添加航班：整个航班的信息保存在一个结构体flight中，采用结构体数组，每一个航班信息包含航班号、起飞时间、起飞城市、降落时间、降落城市、余票数量。
航班信息通过lulu（）函数进行添加。
添加的信息保存在航班flight结构体数组中。
2：查询航班：查询板块分为两个部分，按姓名查找和按站名查找。
按姓名查找：通过所输入的姓名和已定客户的姓名相匹配，匹配成功则查找成功。
按站名查找：通过所输入的起始站名和终点站名进行匹配，匹配成功则查找成功。
3：订票功能：根据用户的姓名和航班号进行订票，如果所查找的航班号的余票满足用户需要的票数，则订票成功，该信息保存在Customer中，才用结构体数组，包含已定客户的姓名、客户ID、订的票数、起飞时间、起飞城市、降落时间、降落城市、航班号。
数据结构(C语言版)实验报告 (内部排序算法比较)
《数据结构与算法》实验报告一、需求分析问题描述：在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。
试通过随机数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。
基本要求：（l）对以下6种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。
（2）待排序表的表长不小于100000；其中的数据要用伪随机数程序产生；至少要用5组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）。
（3）最后要对结果作简单分析，包括对各组数据得出结果波动大小的解释。
数据测试：二．概要设计1.程序所需的抽象数据类型的定义：typedef int BOOL; //说明BOOL是int的别名typedef struct StudentData { int num; //存放关键字}Data; typedef struct LinkList { int Length; //数组长度Data Record[MAXSIZE]; //用数组存放所有的随机数} LinkList int RandArray[MAXSIZE]; //定义长度为MAXSIZE的随机数组void RandomNum() //随机生成函数void InitLinkList(LinkList* L) //初始化链表BOOL LT(int i, int j,int* CmpNum) //比较i和j 的大小void Display(LinkList* L) //显示输出函数void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum) //希尔排序void QuickSort (LinkList* L, int* CmpNum, int* ChgNum) //快速排序void HeapSort (LinkList* L, int* CmpNum, int* ChgNum) //堆排序void BubbleSort(LinkList* L, int* CmpNum, int* ChgNum) //冒泡排序void SelSort(LinkList* L, int* CmpNum, int* ChgNum) //选择排序void Compare(LinkList* L,int* CmpNum, int* ChgNum) //比较所有排序2 .各程序模块之间的层次（调用）关系：二、详细设计typedef int BOOL; //定义标识符关键字BOOL别名为int typedef struct StudentData //记录数据类型{int num; //定义关键字类型}Data; //排序的记录数据类型定义typedef struct LinkList //记录线性表{int Length; //定义表长Data Record[MAXSIZE]; //表长记录最大值}LinkList; //排序的记录线性表类型定义int RandArray[MAXSIZE]; //定义随机数组类型及最大值/******************随机生成函数********************/void RandomNum(){int i; srand((int)time(NULL)); //用伪随机数程序产生伪随机数for(i=0; i小于MAXSIZE; i++) RandArray[i]<=(int)rand(); 返回;}/*****************初始化链表**********************/void InitLinkList(LinkList* L) //初始化链表{int i;memset(L,0,sizeof(LinkList));RandomNum();for(i=0; i小于<MAXSIZE; i++)L->Record[i].num<=RandArray[i]; L->Length<=i;}BOOL LT(int i, int j,int* CmpNum){(*CmpNum)++; 若i<j) 则返回TRUE; 否则返回FALSE;}void Display(LinkList* L){FILE* f; //定义一个文件指针f int i;若打开文件的指令不为空则//通过文件指针f打开文件为条件判断{ //是否应该打开文件输出“can't open file”;exit(0); }for (i=0; i小于L->Length; i++)fprintf(f,"%d\n",L->Record[i].num);通过文件指针f关闭文件;三、调试分析1.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中，我曾多次修改代码，并根据调试显示的界面一次次调整代码。
数据结构与算法实验源代码
数据结构与算法实验源代码数据结构与算法实验源代码一、实验目的本实验旨在通过编写数据结构与算法的实验源代码，加深对数据结构与算法的理解，并提高编程能力。
二、实验环境本实验使用以下环境进行开发和测试：- 操作系统：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）：是由节点组成的层级结构，其中一种节点作为根节点，其他节点按照父子关系连接。
数据结构课程设计(附代码)-数据结构设计
上海应用技术学院课程设计报告课程名称《数据结构课程设计》设计题目猴子选大王；建立二叉树；各种排序；有序表的合并；成绩管理系统；院系计算机科学与信息工程专业计算机科学与技术班级姓名学号指导教师日期一.目的与要求1. 巩固和加深对常见数据结构的理解和掌握2. 掌握基于数据结构进行算法设计的基本方法3. 掌握用高级语言实现算法的基本技能4. 掌握书写程序设计说明文档的能力5. 提高运用数据结构知识及高级语言解决非数值实际问题的能力表。
3、输出功能：void print(LinkList *head);通过一个while的循环控制语句，在指针p!=NULL时，完成全部学生记录的显示。
知道不满足循环语句，程序再次回到菜单选择功能界面。
4、删除功能：LinkList *Delete(LinkList *head);按想要删除的学生的学号首先进行查找，通过指针所指向结点的下移来完成，如果找到该记录，则完成前后结点的连接，同时对以查找到的结点进行空间的释放，最后完成对某个学生记录进行删除，并重新存储。
5、插入功能：LinkList *Insert(LinkList *head)；输入你想插入的位置，通过指针所指向结点的下移，找到该位置，将该新的学生记录插入到该结点，并对该结点后面的指针下移。
链表长度加一，重新存储。
(5) 程序的输入与输出描述输入：调用LinkList *create()函数，输入学生的姓名、学号、三门功课的成绩；输出：调用void print(LinkList *head)函数，输出学生的记录。
(6) 程序测试主菜单：成绩管理系统的主界面：学生成绩记录的输入：输出学生成绩记录：学生成绩记录的删除（删除学号是1101的学生记录）插入新的学生成绩记录（插入学号为1103的学生记录）(7) 尚未解决的问题或改进方向尚未解决的问题：该成绩管理系统还存在不少缺陷，而且它提供的功能也是有限的，只能实现学生成绩的输入、输出、删除、插入。
数据结构课程设计报告
}
通过查阅资料，希尔排序的复杂度应该为O( )。
通过运行程序，获得其运行时间、比较次数、交换次数和数组规模关系如下：
起泡排序
起泡排序基本思路是遍历未排序的数组，将相邻两个元素中较小的移向后方。多次遍历数组未排序部分后完成排序。
对于堆排序，他的平均时间复杂度为O(n*logn)。
算法实现如下：
voidHeapAdjust(intarray[],inti,intnLength){
intnChild;
intnTemp;
for(;2*i+1<nLength;i=nChild){
nChild=2*i+1;
if(nChild<nLength-1&&array[nChild+1]>array[nChild])++nChild;
inttemp,j;
for(inti= 0;i<len; ++i){
temp= a[i];
j =i- 1;
while(temp > a[j] && j > -1) {
a[j + 1] = a[j];
j -= 1;
}
a[j + 1] = temp;
}//end for
}//endInsert_Sort()
简单选择排序
简单选择排序通过遍历未排序数组，从中选出最小的元素并置于有序数组的第一个，其时间复杂度为O( )，而且这种排序算法是一种稳定的排序算法。
算法实现如下：
voidSelection_Sort(int*a,intlen){
数据结构课程设计题目
数据结构课程设计题目以下7个题目任选其一。
1．排序算法比较利用随机函数产生30000个随机整数，利用插入排序、起泡排序、选择排序、快速排序、堆排序、归并排序等排序方法进行排序，并且（1）统计每一种排序上机所花费的时间。
（2）统计在完全正序，完全逆序情况下记录的比较次数和移动次数。
（3）比较的指标为关键字的比较次数和记录的移动次数(一次记录交换计为3次移动)。
（4）对结果作简单分析，包括对各组数据得出结果波动大小的解释。
2．图的深度遍历对任意给定的图（顶点数和边数自定），建立它的邻接表并输出，然后利用堆栈的五种基本运算（清空堆栈、压栈、弹出、取栈顶元素、判栈空）实现图的深度优先搜索遍历。
画出搜索顺序示意图。
3．图的广度遍历对任意给定的图（顶点数和边数自定），建立它的邻接表并输出，然后利用队列的五种基本运算（置空队列、进队、出队、取队头元素、判队空）实现图的广度优先搜索遍历。
画出搜索顺序示意图。
4．二叉树的遍历对任意给定的二叉树（顶点数自定）建立它的二叉链表存贮结构，并利用栈的五种基本运算（置空栈、进栈、出栈、取栈顶元素、判栈空）实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。
画出搜索顺序示意图。
5．链表操作利用链表的插入运算建立线性链表，然后利用链表的查找、删除、计数、输出等运算反复实现链表的这些操作（插入、删除、查找、计数、输出单独写成函数的形式），并能在屏幕上输出操作前后的结果。
画出搜索顺序示意图。
6．一元稀疏多项式简单计数器（1）输入并建立多项式（2）输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。
序列按指数降序排列。
（3）多项式a和b相加，建立多项式a+b，输出相加的多项式。
（4）多项式a和b相减，建立多项式a-b，输出相减的多项式。
用带头结点的单链表存储多项式。
测试数据：（1）(2x+5x8-3.1x11)+(7-5x8+11x9)（2）(6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15)（3）(x+x2+x3)+0（4）(x+x3)-(-x-x-3)7．实现两个链表的合并基本功能要求：（1）建立两个链表A和B，链表元素个数分别为m和n个。
数据结构源代码(全)
/*顺序表的操作#include<iostream>#include<stdlib.h>using namespace std;Release 13.12 rev 9501 (2013/12/25 19:25:45) gcc 4.7.1 Windows/unicode - 32 bit #define MAX_SIZE 100typedef struct{int *emel;int lenth;}Sq;void init(Sq &l);void create(Sq &l);void trval(Sq &l);void find_value(Sq &l);void find_position(Sq &l);void insert(Sq &l);void dele(Sq &l);int main(){Sq l;init(l);create(l);trval(l);find_value(l);find_position(l);insert(l);trval(l);dele(l);trval(l);return 0;}void init(Sq &l){l.emel =new int[MAX_SIZE];if(l.emel ==NULL){cout<<"\t申请空间失败！"<<endl;exit(1);}l.lenth=0;cout<<"\t成功申请空间！该顺序表的长度目前为:"<<l.lenth<<endl; }void create(Sq &l){cout<<"\t请输入你想输入元素的个数：";int x;cin>>x;if((x<1)&&(x>MAX_SIZE)){cout<<"\t你说输入的数不在范围里"<<endl;return;}int i;for(i=0;i<x;i++){cin>>l.emel[i];}l.lenth=x;cout<<"\t成功赋值！"<<endl;}void trval(Sq &l){int i;cout<<"l(";for(i=0;i<l.lenth;i++){cout<<l.emel[i]<<" ";}cout<<")"<<" 该顺序表现在的长度为："<<l.lenth<<endl;}void find_value(Sq &l){int x,t=0;cout<<"\t请输入你要查找的值：";cin>>x;int i;for(i=0;i<l.lenth;i++){if(l.emel[i]==x){t=1;cout<<"\t成功找到该元素，它是顺序表的第"<<i+1<<"个元素！"<<endl;}}if(t==0){cout<<"\t无该元素！"<<endl;}}void find_position(Sq &l){int x;cout<<"\t请输入你要查找的位置：";cin>>x;int i;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}for(i=1;i<=l.lenth;i++){if(i==x){cout<<"\t成功找到该元素，该值是"<<l.emel[i-1]<<endl;}}}void insert(Sq &l){int i,x,y;cout<<"\t请输入你要插入的位置";cin>>x;cout<<"\t请输入你要插入的值";cin>>y;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}if(x==l.lenth){l.emel[l.lenth]=y;l.lenth=l.lenth+1;return;}for(i=l.lenth;i>=x;i--){l.emel[i]=l.emel[i-1];}l.emel[x-1]=y;l.lenth=l.lenth+1;}void dele(Sq &l){int i,x;cout<<"\t请输入你要删除位置：";cin>>x;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}for(i=x-1;i<=l.lenth;i++){l.emel[i]=l.emel[i+1];}l.lenth=l.lenth-1;}成功申请空间！该顺序表的长度目前为:0请输入你想输入元素的个数：3852成功赋值！l(8 5 2 ) 该顺序表现在的长度为：3请输入你要查找的值：5成功找到该元素，它是顺序表的第2个元素！请输入你要查找的位置：3成功找到该元素，该值是2请输入你要插入的位置3请输入你要插入的值10l(8 5 2 10 ) 该顺序表现在的长度为：4请输入你要删除位置：3l(8 5 10 ) 该顺序表现在的长度为：3--------------------------------Process exited with return value 0Press any key to continue . . .*//*#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败！\n");exit(-1);}head->next=NULL;return head;}void insert(L* head){int x,i;printf("请输入你想输入数据的个数：");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");exit(-1);}printf("请输入值：");scanf("%d",&q->num);q->next=NULL;p->next=q;p=q;}}void print(L* head){L *p;p=head->next;while(p!=NULL){printf("值为：%d\n",p->num);p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点！！！\n");insert(head);printf("成功输入数据！！！\n");print(head);return 0;}*//*线性表的操作#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败！\n");exit(-1);}head->next=NULL;return head;}void init(L* head){int x,i;printf("请输入你想输入数据的个数：");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");exit(-1);}printf("请输入值：");scanf("%d",&q->num);q->next=p->next;p->next=q;}}int print(L* head){L *p;int lenth=0;p=head->next;printf("\t\tL(");while(p!=NULL){lenth++;printf("%d ",p->num);p=p->next;}printf(")\n");return lenth;}int insert(L *head,int lenth){printf("\t\t请输入你要插入的元素的位置:");int in;scanf("%d",&in);if(in<1 || in>lenth){printf("\t\t输入值不在范围内！");return -1;}L *p,*q;p=head->next;q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");return -1;}printf("\t\t请为新节点输入值：");scanf("%d",&q->num);int i=0;while(p!=NULL){i++;if(i==in-1){q->next=p->next;p->next=q;}p=p->next;}lenth++;return lenth;}int dele(L *head,int lenth){printf("\t\t请输入你要删除的元素的位置:");int out;scanf("%d",&out);if(out<1 || out>lenth){printf("\t\t输入值不在范围内！");return -1;}L *p,*q;p=head->next;q=head;int i=0;while(p!=NULL){i++;if(i==out){q->next=p->next;}q=p;p=p->next;}lenth--;return lenth;}void find(L *head,int lenth){printf("\t\t请输入你要查找的元素的位置:");int finder;scanf("%d",&finder);if(finder<1 || finder>lenth){printf("\t\t输入值不在范围内！");return ;}L *p;p=head->next;int i=0;while(p!=NULL){i++;if(i==finder){printf("\t\t你要找的该位置所对应的值为：%d\n",p->num);}p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点！！！\n");init(head);printf("成功输入数据！！！\n");int len;len=print(head);printf("\t\t该线性表的长度为:%d\n",len);len=insert(head,len);len=print(head);printf("\t\t插入后线性表的长度为:%d\n",len);len=dele(head,len);len=print(head);printf("\t\t删除后该线性表的长度为:%d\n",len);find(head,len);return 0;}*//*顺序表的合并#include<iostream>using namespace std;struct LA{int *pa;int lenth;};struct LB{int *pb;int lenth;};struct LC{int *pc;int lenth;};void mergelist(LA la,LB lb,LC &lc);int main(){int x,y;LA la;LB lb;cout<<"\t\t请给线性表LA和LB指定长度：";cin>>x>>y;la.pa =new int(sizeof(int)*x);lb.pb =new int(sizeof(int)*y);int i;for(i=0;i<x;i++){cout<<"请输入表LA的值:";cin>>la.pa[i];}cout<<endl;la.lenth=x;for(i=0;i<y;i++){cout<<"请输入表LB的值:";cin>>lb.pb[i];}lb.lenth=y;cout<<"LA(";for(i=0;i<x;i++){cout<<la.pa[i]<<" ";}cout<<")"<<endl;cout<<"LB(";for(i=0;i<y;i++){cout<<lb.pb[i]<<" ";}cout<<")"<<endl;LC lc;mergelist(la,lb,lc);return 0;}void mergelist(LA la,LB lb,LC &lc){lc.lenth=la.lenth+lb.lenth;lc.pc=new int(sizeof(int)*lc.lenth);int *pa=la.pa,*pb=lb.pb,*pc=lc.pc;int *pa_last=la.pa+la.lenth-1;int *pb_last=lb.pb+lb.lenth-1;while(pa<=pa_last && pb<=pb_last){if(*pa <= *pb){*pc++=*pa++;}else{*pc++=*pb++;}}while(pa<=pa_last){*pc++=*pa++;}while(pb<=pb_last){*pc++=*pb++;}cout<<"LC(";int i=0;for(i=0;i<lc.lenth;i++){cout<<lc.pc[i]<<" ";}cout<<")"<<endl;}*///栈/*#include<iostream>using namespace std;#include<stdlib.h>#define MAXSIZE 100typedef struct{int *base;int *top;int stacksize;}Sqstack;int Initstack(Sqstack &s);void Push(Sqstack &s,int e);void StackTraverse(Sqstack &s);void Gettop(Sqstack &s);void Pop(Sqstack &s);int main(){Sqstack s;Initstack(s);cout<<"\t\t初始化栈成功！"<<endl;Push(s,2);cout<<"\t\t2入栈成功！"<<endl;Push(s,4);cout<<"\t\t4入栈成功！"<<endl;Push(s,6);cout<<"\t\t6入栈成功！"<<endl;Push(s,8);cout<<"\t\t8入栈成功！"<<endl;cout<<"\n由栈底至栈顶的元素为：";StackTraverse(s);Gettop(s);Pop(s);Gettop(s);return 0;}int Initstack(Sqstack &s){s.base=new int[MAXSIZE];if(s.base==NULL){exit(1);}s.top=s.base;s.stacksize=MAXSIZE;}void Push(Sqstack &s,int e){if(s.top-s.base==s.stacksize){exit(1);}*s.top++=e;}void StackTraverse(Sqstack &s){int *p=s.base,i=0;while(p<s.top){i++;cout<<*p++<<" ";}cout<<"\t\t栈的长度是"<<i<<endl;}void Gettop(Sqstack &s){if(s.base==s.top){exit(1);}cout<<"栈顶元素是："<<*(s.top-1)<<endl; }void Pop(Sqstack &s){if(s.top==s.base){exit(1);}cout<<"出栈的第一个元素是:";cout<<*--s.top<<" "<<endl;}*///队列例题：/*#include<iostream>#include<stdlib.h>using namespace std;#define MAXQSIZE 100typedef struct{int *base;int front;int rear;}SqQueue;int InitQueue(SqQueue &q);int EnQueue(SqQueue &q,int x);int DeQueue(SqQueue &q);int main(){SqQueue q;InitQueue(q);EnQueue(q,1);EnQueue(q,3);EnQueue(q,5);EnQueue(q,7);DeQueue(q);DeQueue(q);DeQueue(q);DeQueue(q);return 0;}int InitQueue(SqQueue &q){q.base=new int[MAXQSIZE];if(q.base==NULL){exit(1);}q.front=0;q.rear=0;return 0;}int EnQueue(SqQueue &q,int x){if((q.rear+1)%MAXQSIZE==q.front){exit(0);}q.base[q.rear]=x;q.rear=(q.rear+1)%MAXQSIZE;return 0;}int DeQueue(SqQueue &q){if(q.front==q.rear){exit(0);}int x=q.base[q.front];q.front=(q.front+1)%MAXQSIZE;cout<<x<<endl;}*//*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int date;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front; //队头指针Queueptr rear; //队尾指针}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int e);void TrvalQueue(LinkQueue Q);void DeQueue(LinkQueue &Q);int main(){LinkQueue Q;InitQueue(Q);EnQueue(Q,1);cout<<"\t元素1入队成功！"<<endl;EnQueue(Q,3);cout<<"\t元素3入队成功！"<<endl;EnQueue(Q,5);cout<<"\t元素5入队成功！"<<endl;EnQueue(Q,7);cout<<"\t元素7入队成功！"<<endl;cout<<"\t队列的元素分别是："<<endl;TrvalQueue(Q);cout<<"\t第一个出队的元素是："<<endl;DeQueue(Q);cout<<"\n\t第一个元素出队完成之后队列中从队头至队尾的元素为：";TrvalQueue(Q);return 0;}int InitQueue(LinkQueue &Q){Q.rear=new Qnode;Q.front=Q.rear;if(Q.front==NULL){exit(0);}Q.front->next=NULL;return 0;}void EnQueue(LinkQueue &Q,int e){Qnode *p=new Qnode;if(!p){exit(1);}p->date=e;p->next=NULL;Q.rear->next=p; //连接Q.rear=p; //修改队尾指针}void TrvalQueue(LinkQueue Q){Qnode *p=Q.front->next;//队头元素while(Q.front!=Q.rear){cout <<p->date<<" ";Q.front=p;p=p->next;}cout<<endl;}void DeQueue(LinkQueue &Q){if(Q.front==Q.rear){return;}Qnode *p=Q.front->next;cout<<"\t"<<p->date<<endl;Q.front->next=p->next;if(Q.rear==p){Q.rear=Q.front;delete p;}}*//*//表达式求值#include<iostream>#include<stdlib.h>#include<stdio.h>using namespace std;#define MAXSIZE 100typedef struct{char *base;char *top;char num;}OPND; //数据栈typedef struct{char *base;char *top;char c;}OPTR; //符号栈int Initstack(OPND &op_n,OPTR &op_t);void Pushstack(OPND &op_n,char ch);void Pushstack(OPTR &op_t,char ch);char Popstack(OPND &op_n,char ch);char Popstack(OPTR &op_t,char ch);char Gettop(OPTR op_t);char Gettop(OPND op_n);int In(char ch);char Precede(char x,char y);char operate(char z,char x,char y);int main(){OPND op_n;OPTR op_t;Initstack(op_n,op_t);Pushstack(op_t,'#');char ch;char p;cin>>ch;while(ch!='#' || Gettop(op_t)!='#'){if(!In(ch)){Pushstack(op_n,ch);cin>>ch;}else{switch( Precede(Gettop(op_t),ch) ){case '<':Pushstack(op_t,ch);cin>>ch;break;case '>':char x,y,z;x=Popstack(op_t,x);y=Popstack(op_n,y);z=Popstack(op_n,z);Pushstack(op_n,operate(z,x,y));break;case '=':p=Popstack(op_t,p);cin>>ch;break;}}}cout<<"\t表达式结果是："<<Gettop(op_n)<<endl;return 0;}int Initstack(OPND &op_n,OPTR &op_t){op_n.base=new char[MAXSIZE];op_t.base=new char[MAXSIZE];if((op_n.base==NULL) || (op_t.base==NULL)){exit(1);}op_n.top=op_n.base;op_t.top=op_t.base;op_n.num=MAXSIZE;op_t.c=MAXSIZE;return 0;}void Pushstack(OPND &op_n,char ch){if(op_n.top-op_n.base==op_n.num){return;}*op_n.top++=ch;cout<<ch<<" 入数字栈"<<endl;}void Pushstack(OPTR &op_t,char ch){if(op_t.top-op_t.base==op_t.c){return;}*op_t.top++=ch;cout<<ch<<" 入操作符"<<endl;}char Popstack(OPND &op_n,char ch)if(op_n.top==op_n.base){exit(1);}ch=*--op_n.top;cout<<ch<<" 出数字栈"<<endl;return ch;}char Popstack(OPTR &op_t,char ch){if(op_t.top==op_t.base){exit(1);}ch=*--op_t.top;cout<<ch<<" 出字符栈"<<endl;return ch;}char Gettop(OPTR op_t){char x;if(op_t.top==op_t.base){exit(1);}x=*(op_t.top-1);cout<<"得到操作符栈顶"<<x<<endl;return x;}char Gettop(OPND op_n){char x;if(op_n.top==op_n.base){exit(1);}x=*(op_n.top-1);cout<<"得到操作数栈顶"<<x<<endl;return x;}int In(char ch)if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#') {return 1;}else{return 0;}}char Precede(char x,char y){if(x=='+' || x=='-'){if(y=='+' || y=='-' || y==')' || y=='#'){return '>';}else{return '<';}}if(x=='*'||x=='/'){if(y=='('){return '<';}else{return '>';}}if(x=='('){if(y==')'){return '=';}else if(y=='+'||y=='-'||y=='*'||y=='/'||y=='('){return '<';}}if(x==')'){if(y!='('){return '>';}}if(x=='#'){if(y=='#'){return '=';}else if(y!=')'){return '<';}}}char operate(char z,char x,char y) {if(x=='+'){return (z-'0') + (y-'0')+48;}if(x=='-'){return (z-'0') - (y-'0')+48;}if(x=='*'){return (z-'0')* (y-'0')+48;}if(x=='/'){return (z-'0')/ (y-'0')+48;}}*//*#include<iostream>using namespace std;int main(){char a[10];char *b[10];char **c[10];return 0;}*//*#include<iostream>using namespace std;char f(char x,char y){return (x-'0') * (y-'0')+48;}int main(){char a='3',b='5';char p=f(a,b);cout<<p<<endl;return 0;}*///数列出队/*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int num;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front;Queueptr rear;}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int x); int DeQueue(LinkQueue &Q,int p); int main(){LinkQueue Q;InitQueue(Q);int x,i,y,num=0,e;cout<<"请输入总人数:";cin>>x;for(i=1;i<=x;i++){EnQueue(Q,i);}cout<<"请输入第几个数淘汰:";cin>>y;{for(i=0;i<y;i++){if(i!=y-1){e=DeQueue(Q,e);EnQueue(Q,e);}else{DeQueue(Q,e);num++;}}if(num==x-1){break;}}e=DeQueue(Q,e);cout<<"最后剩下的是："<<e<<endl;return 0;}int InitQueue(LinkQueue &Q){Q.front=new Qnode;Q.rear=Q.front;if(Q.front==NULL){exit(1);}Q.front->next=NULL;}void EnQueue(LinkQueue &Q,int x){Qnode *p=new Qnode;if(!p){exit(1);}p->num=x;p->next=NULL;Q.rear->next=p;}int DeQueue(LinkQueue &Q,int e) {Qnode *p;if(Q.rear==Q.front){exit(0);}p=Q.front->next;e=p->num;Q.front->next=p->next;if(Q.rear==p){Q.front=Q.rear;}delete p;return e;}*//*二叉树#include<iostream>#include<stdlib.h>using namespace std;typedef struct BiTNode{char date;struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;void CreateBiTree(BiTree &T);int Depth(BiTree T);int NodeCount(BiTree T);int LeavesNodeCount(BiTree T);int PreOrderTraverse(BiTree T);int InOrderTraverse(BiTree T);int PostOrderTraverse(BiTree T); int main(){BiTree T;CreateBiTree(T);cout<<"二叉树的深度为："<<Depth(T)<<endl;cout<<"二叉树中结点个数为："<<NodeCount(T)<<endl;cout<<"二叉树中叶子结点个数为："<<LeavesNodeCount(T)<<endl;cout<<"先序遍历：";PreOrderTraverse(T);cout<<"\n中序遍历：";InOrderTraverse(T);cout<<"\n后序遍历：";PostOrderTraverse(T);cout<<endl;return 0;}void CreateBiTree(BiTree &T){cout<<"请为该节点赋值:";char ch;cin>>ch;if(ch=='#'){T=NULL;}else{T =new BiTNode;T->date=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}int Depth(BiTree T){int m,n;if(T==NULL){return 0;}else{m=Depth(T->lchild);n=Depth(T->rchild);if(m>n){return m+1;}else{return n+1;}}}int NodeCount(BiTree T){if(T==NULL){return 0;}else{return NodeCount(T->lchild)+NodeCount(T->rchild)+1;}}int LeavesNodeCount(BiTree T){if(T==NULL){return 0;}else if(T->lchild==NULL && T->rchild==NULL){return 1;}else{return LeavesNodeCount(T->lchild)+LeavesNodeCount(T->rchild);}}int PreOrderTraverse(BiTree T){if(T!=NULL){cout<<T->date;PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}int InOrderTraverse(BiTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date;InOrderTraverse(T->rchild);}}int PostOrderTraverse(BiTree T){if(T!=NULL){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);cout<<T->date;}}请为该节点赋值:-请为该节点赋值:+请为该节点赋值:a请为该节点赋值:#请为该节点赋值:#请为该节点赋值:*请为该节点赋值:b请为该节点赋值:#请为该节点赋值:#请为该节点赋值:-请为该节点赋值:c请为该节点赋值:#请为该节点赋值:#请为该节点赋值:d请为该节点赋值:#请为该节点赋值:#请为该节点赋值:/请为该节点赋值:e请为该节点赋值:#请为该节点赋值:#请为该节点赋值:f请为该节点赋值:#请为该节点赋值:#二叉树的深度为：5二叉树中结点个数为：11二叉树中叶子结点个数为：6先序遍历：-+a*b-cd/ef中序遍历：a+b*c-d-e/f后序遍历：abcd-*+ef/-Process returned 0 (0x0) execution time : 76.214 s Press any key to continue.*//*#include<iostream>#include<stdlib.h>#include<string.h>using namespace std;typedef struct{int weiget;int parent,lchild,rchild;}HTNode,*HuffmanTree;typedef char** HuffmanCode;void creat(HuffmanTree &HT,int n);void Select(HuffmanTree HT,int k,int &min1,int &min2); void creatcode(HuffmanTree HT,HuffmanCode &HC,int n); int min(HuffmanTree HT,int k);int main(){int n;cout<<"请输入叶子节点的个数:";cin>>n;HuffmanTree HT;creat(HT,n);HuffmanCode HC;creatcode(HT,HC,n);return 0;}void creat(HuffmanTree &HT,int n){if(n<1){exit(1);}int m=2*n-1,i;HT=new HTNode[m+1];for( i=1;i<=m;i++){HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for(i=1;i<=n;i++){cout<<"请输入权值:";cin>>HT[i].weiget;}int s1,s2;for(i=n+1;i<=m;i++) //通过n-1次选择来合并创建{Select(HT,i-1,s1,s2);HT[s1].parent=i; //赋值，作为删除的标记HT[s2].parent=i;cout<<"s1:"<<s1<<" s2:"<<s2<<endl;HT[i].lchild=s1; //生成新节点HT[i].rchild=s2;HT[i].weiget=HT[s1].weiget+HT[s2].weiget;}}void Select(HuffmanTree HT,int k,int &min1,int &min2){min1=min(HT,k);min2=min(HT,k);}int min(HuffmanTree HT,int k){int i=0;int min;//存放weight最小且parent为-1的元素的序号int min_wei;//存放权值while(HT[i].parent!=0){i++;}min_wei=HT[i].weiget;min=i;for(;i<=k;i++){if(HT[i].weiget<min_wei && HT[i].parent==0){min_wei=HT[i].weiget;min=i;}}HT[min].parent=1;return min;}void creatcode(HuffmanTree HT,HuffmanCode &HC,int n){HC =new char *[n+1];char *cd=new char[n];cd[n-1]='\0';int i,start;//start指向最后，即编码结束符的位置int current,father;for(i=1;i<=n;i++){start=n-1;current=i;father=HT[i].parent;while(father!=0){--start;if(HT[father].lchild==current){cd[start]='0';}else{cd[start]='1';}current=father;father=HT[father].parent;}HC[i]=new char[n-start];strcpy(HC[i],&cd[start]);cout<<HT[i].weiget<<"对应的编码是："<<HC[i]<<endl;}delete cd;}请输入叶子节点的个数:5请输入权值:1请输入权值:2请输入权值:3请输入权值:4请输入权值:5s1:1 s2:2s1:3 s2:6s1:4 s2:5s1:7 s2:81对应的编码是：0102对应的编码是：0113对应的编码是：004对应的编码是：105对应的编码是：11Process returned 0 (0x0) execution time : 4.003 s Press any key to continue.*///折半查找#include<iostream>#include<stdio.h>using namespace std;#define ENDFLAG 10000typedef int KeyType;typedef char* InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SSTable;void CreateSTable(SSTable &ST,int n){int i;ST.R=new ElemType[n+1];for(i=1;i<=n;i++){cout<<"请输入"<<i<<"个测试数据：";cin>>ST.R[i].key;}ST.length=n;}int Search_Bin1(SSTable ST,KeyType key){int low,high,mid;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){high=mid-1;}else{low=mid+1;}}return 0;}int Search_Bin2(SSTable ST,int low,int high,KeyType key) {int mid;if(low>high){return 0;}mid=(low+high)/2;printf("%d+++++",key==ST.R[mid].key);if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){return Search_Bin2(ST,low,mid-1,key);}else{return Search_Bin2(ST,mid+1,high,key);}}int main(){int n;KeyType key;SSTable ST;cout<<"请输入静态查找表长：";cin>>n;CreateSTable(ST,n);cout<<"请输入待查记录的关键字：";cin>>key;cout<<"Search_Bin1算法计算的位置为："<<Search_Bin1(ST,key)<<endl;cout<<"Search_Bin2算法计算的位置为："<<Search_Bin2(ST,1,ST.length,key)<<endl;return 0;}/*请输入静态查找表长：5请输入1个测试数据：1请输入2个测试数据：2请输入3个测试数据：3请输入4个测试数据：4请输入5个测试数据：5请输入待查记录的关键字：3Search_Bin1算法计算的位置为：3Search_Bin2算法计算的位置为：3Process returned 0 (0x0) execution time : 8.620 sPress any key to continue.*//*#include<iostream>using namespace std;typedef struct{int key;}ElemType;typedef struct BSTNode{ElemType date;struct BSTNode *lchild,*rchild;}BSTNode,*BSTree;void Create(BSTree &T);void Insert(BSTree &T,ElemType e);int InOrderTraverse(BSTree T);int main(){BSTree T;Create(T);InOrderTraverse(T);cout<<"\n中序遍历：";return 0;}void Create(BSTree &T){T=NULL;ElemType e;cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;while(e.key!=0){Insert(T,e);cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;}}void Insert(BSTree &T,ElemType e){if(!T){BSTree S;S=new BSTNode;S->date=e;S->lchild=NULL;S->rchild=NULL;T=S;}else if(e.key<T->date.key){Insert(T->lchild,e);}else{Insert(T->rchild,e);}}int InOrderTraverse(BSTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date.key<<" ";InOrderTraverse(T->rchild);}return 0;}请为节点赋值:(0为结束条件)12请为节点赋值:(0为结束条件)7请为节点赋值:(0为结束条件)17请为节点赋值:(0为结束条件)11请为节点赋值:(0为结束条件)16请为节点赋值:(0为结束条件)2请为节点赋值:(0为结束条件)13请为节点赋值:(0为结束条件)9请为节点赋值:(0为结束条件)21请为节点赋值:(0为结束条件)4请为节点赋值:(0为结束条件)02 4 7 9 11 12 13 16 17 21中序遍历：Process returned 0 (0x0) execution time : 23.808 s Press any key to continue.*/。
(完整版)数据结构经典题目及c语言代码
《数据结构》课程设计题目(程序实现采用C语言)题目1：猴子选王(学时:3）一堆猴子都有编号，编号是1，2,3 .。
.m，这群猴子（m个)按照1-m的顺序围坐一圈，从第1开始数，每数到第n个,该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王.要求:m及n要求从键盘输入,存储方式采用向量及链表两种方式实现该问题求解.//链表#include 〈stdio.h〉＃include 〈stdlib.h>// 链表节点typedef struct _RingNode｛int pos；struct _RingNode ＊next;}RingNode， *RingNodePtr；// 创建约瑟夫环，pHead:链表头指针,count：链表元素个数void CreateRing(RingNodePtr pHead, int count)｛RingNodePtr pCurr = NULL， pPrev = NULL；int i = 1;pPrev = pHead；while（——count 〉 0）｛pCurr = (RingNodePtr）malloc（sizeof（RingNode））;i++;pCurr—〉pos = i；pPrev-〉next = pCurr；pPrev = pCurr;}pCurr-〉next = pHead; // 构成环状链表｝void KickFromRing(RingNodePtr pHead， int n){RingNodePtr pCurr, pPrev；int i = 1； // 计数pCurr = pPrev = pHead；while(pCurr != NULL){if （i == n）｛// 踢出环printf（"\n％d"， pCurr->pos); // 显示出圈循序pPrev—>next = pCurr->next；free（pCurr)；pCurr = pPrev—>next；i = 1;}pPrev = pCurr；pCurr = pCurr—〉next;if （pPrev == pCurr)｛// 最后一个printf("\nKing is %d", pCurr—〉pos）; // 显示出圈循序 free（pCurr)；break；}i++;｝}int main（）｛int n = 0, m = 0；RingNodePtr pHead = NULL;printf("M（person count）= ”）;scanf(”％d”, &m);printf("N（out number) = "）;scanf(”％d”， &n）;if(m 〈= 0 |｜ n <= 0）｛printf("Input Error\n”)；return 0;}// 建立链表pHead = (RingNodePtr)malloc（sizeof（RingNode））； pHead->pos = 1;pHead->next = NULL;CreateRing(pHead， m);// 开始出圈printf("\nKick Order： ")；KickFromRing(pHead， n）；printf(”\n"）;system(”pause”）；return 0；}//数组做：#include<stdio。
数据结构与算法-排序
假定待排序文件由 n 条记录组成，记录依次存储在 r[1]～r[n]中。使用简单冒泡排
序算法对待排序文件中的记录进行排序，具体处理流程如下。
（1）遍历待排序文件 r[1]～r[n]，每访问一条记录 r[j]时，比较所访问记录排序关
键字与所访问记录后一记录排序关键字的大小，核对所访问记录 r[j]与所访问记录后一
则，此排序算法是不稳定的。例如， 给定待排序文件 A={1,2,3,1,4}和B={1,3,1,2,4}，假定某
一排序算法对文件 A 和B 的排序结果分别为{1,1,2,3,4}和{1,1,2,3,4}，由于文件 B 中存在多
项同为 1 的记录，且排序后同为 1 的记录相对位置发生了改变，因此，此算法是不稳定
排序
目
CONTENTS
录
01
排序的概述
02
插入排序算法
03
交换排序算法
04
选择排序算法
05
归并排序算法
06
分配排序算法
07
各种排序技术比较
08
本章小结
01
PART
排序的概述
排序是以某一数据项（称为排序关键字）为依据，将一组无序记录调整成一组有序
记录，形成有序表的过程。排序问题可以定义为以下形式。
件排序时，记录分组以及每趟排序结果如右
图所示。
插入排序算法
2.3希尔排序算法
第一趟排序时，增量 h=4，因此，以
h=4 为记录间隔，将待排序文件中的记录分
为 4 组：{r[1],r[5],r[9]}、{r[2],r[6]}、{r[3],r[7]}
和{r[4],r[8]}，并分别对 4 组记录进行直接插入
数据结构课程设计(排序)
数据结构课程设计[排序综合]学生姓名：学生学号：院（系）：计算机科学与信息技术学院年级专业：指导教师：付丹丹二〇一一年十二月2- 3 - 3摘要数据结构是由数据元素依据某种逻辑联系组织起来的。
对数据元素间逻辑关系的描述称为数据的逻辑结构；数据必须在计算机内存储，数据的存储结构是数据结构的实现形式，是其在计算机内的表示；此外讨论一个数据结构必须同时讨论在该类数据上执行的运算才有意义。
在许多类型的程序的设计中，数据结构的选择是一个基本的设计考虑因素。
许多大型系统的构造经验表明，系统实现的困难程度和系统构造的质量都严重的依赖于是否选择了最优的数据结构。
许多时候，确定了数据结构后，算法就容易得到了。
有些时候事情也会反过来，我们根据特定算法来选择数据结构与之适应。
不论哪种情况，选择合适的数据结构都是非常重要的。
排序算法是数据结构学科经典的内容，其中内部排序现有的算法有很多种，其中包含冒泡排序，直接插入排序，简单选择排序，希尔排序，快速排序，堆排序等，各有其特点。
对排序算法比较的分析可以遵循若干种不同的准则，通常以排序过程所需要的算法步数作为度量，有时也以排序过程中所作的键比较次数作为度量。
特别是当作一次键比较需要较长时间，例如，当键是较长的字符串时，常以键比较次数作为排序算法计算时间复杂性的度量。
当排序时需要移动记录，且记录都很大时，还应该考虑记录的移动次数。
究竟采用哪种度量方法比较合适要根据具体情况而定。
在下面的讨论中我们主要考虑用比较的次数作为复杂性的度量。
41概要1.1设计目的数据结构与算法课程主要是研究非数值计算的程序设计问题中所出现的计算机操作对象以及它们之间的关系和操作的学科。
数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。
学习数据结构与算法是为了将实际问题中涉及的对象在计算机中表示出来并对它们进行处理。
c课课程设计以及源代码
c 课课程设计以及源代码一、教学目标本课程的教学目标是使学生掌握C语言的基本语法、数据结构和算法，培养学生编程思维和解决问题的能力。
具体目标如下：1.知识目标：（1）理解C语言的基本语法，包括变量、数据类型、运算符、表达式等；（2）掌握函数的定义和调用，了解作用域规则；（3）熟悉数组的声明和使用，理解字符串的基本操作；（4）了解指针的概念和应用，掌握指针与数组、指针与函数的关系；（5）学习结构体和联合体，掌握文件操作的基本方法。
2.技能目标：（1）能够运用C语言编写简单的程序，实现输入输出、数据处理等功能；（2）学会使用调试工具，能够发现和解决程序中的错误；（3）掌握常用的算法，如排序、查找、递归等，并能够灵活运用；（4）具备一定的编程规范和编程习惯，能够阅读和理解他人的代码。
3.情感态度价值观目标：（1）培养学生对计算机科学的兴趣和好奇心，激发学生主动学习的动力；（2）培养学生团队合作的精神，学会与他人交流和分享；（3）培养学生勇于面对困难和挑战，培养解决问题的能力；（4）培养学生具有良好的职业操守，注重诚信和责任心。
二、教学内容根据课程目标，本课程的教学内容主要包括以下几个方面：1.C语言的基本语法：变量、数据类型、运算符、表达式、函数等；2.数据结构：数组、字符串、指针、结构体、联合体等；3.算法：排序、查找、递归等常用算法；4.文件操作：文件的打开、关闭、读写等基本操作；5.编程实践：编写简单的程序，锻炼编程能力和解决问题的能力。
三、教学方法为了达到课程目标，本课程将采用多种教学方法，包括：1.讲授法：通过讲解和演示，使学生掌握C语言的基本语法和数据结构；2.讨论法：学生进行小组讨论，培养学生的团队合作能力和解决问题的能力；3.案例分析法：分析典型的编程案例，使学生了解C语言在实际应用中的重要性；4.实验法：让学生动手编写程序，培养学生的编程能力和实践能力。
四、教学资源为了支持教学内容和教学方法的实施，本课程将准备以下教学资源：1.教材：选用权威、实用的C语言教材，为学生提供系统的学习资料；2.参考书：提供相关的参考书籍，丰富学生的知识体系；3.多媒体资料：制作课件、教学视频等，增强课堂教学的趣味性和生动性；4.实验设备：提供计算机实验室，让学生进行编程实践和实验操作。
数据结构课程设计
课程设计说明书课程名称：数据结构和算法设计题目：多种排序院系：计算机科学与信息工程学院学生姓名：学号：专业班级：计科嵌入式（12-1）指导教师：年月日课程设计任务书多种排序摘要：排序是算法中最基础的问题之一，经典的排序算法是前人不断总结得到的，基于比较的方法是比较直观的方式，主要存在插入法排序、堆排序、希尔排序、归并排序、快速排序，每一种排序算法都有自己的优缺点，比如插入法排序适用于那些长度短的排序，要是长的话，有些爱莫能助啦，堆排序主要是依据了二叉堆的特性，但是创建堆的过程也是一个复杂的问题，希尔排序的过程是一个不断精确的过程，但是目前也只是一个经验方式。
归并排序是一个递归的问题，采用分治的思想实现，但是这种算法需要额外的存储空间，快速排序虽然是实践中比较常用的算法，但是对于有序的数组采用快速排序就是灾难。
比较型算法的时间复杂度最优也只能到达O(NlogN)。
关键词：归并排序快排排序选择排序冒泡排序插入排序堆排序希尔排序内部排序目录1. 设计背景 (3)1.1问题描述 (4)1.2 问题分析 (4)2.设计方案 (4)2.1 算法设计 (4)2.2 功能模块分析 (6)3.主要算法流程图 (15)4. 结果与结论 (16)4.1正确结果 (16)4.2错误信息 (18)5. 算法复杂度以及稳定性分析 (18)6. 收获与致谢 (19)7. 参考文献 (19)8. 附件 (20)1. 设计背景1.1问题描述利用随机函数产生N个随机整数（10000以上），对这些数进行多种方法进行排序。
包括：插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序。
1.2 问题分析经典的排序算法是前人不断总结得到的，基于比较的方法是比较直观的方式，主要存在插入法排序、堆排序、希尔排序、归并排序、快速排序，每一种排序算法都有自己的优缺点。
2.设计方案2.1 算法设计（1）选择排序在待排序的一组数据元素中，选出最小的一个数据元素与第一个位置的数据元素交换；然后在剩下的数据元素当中再找最小的与第二个位置的数据元素交换，循环到只剩下最后一个数据元素为止。
数据结构课程设计排序算法总结
排序算法：(1) 直接插入排序 (2) 折半插入排序(3) 冒泡排序 (4) 简单选择排序 (5) 快速排序(6) 堆排序 (7) 归并排序【算法分析】（1）直接插入排序；它是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好的序的有序表中，从而得到一个新的、记录数增加1的有序表。
（2）折半插入排序：插入排序的基本操作是在一个有序表中进行查找和插入，我们知道这个查找操作可以利用折半查找来实现，由此进行的插入排序称之为折半插入排序。
折半插入排序所需附加存储空间和直接插入相同，从时间上比较，折半插入排序仅减少了关键字间的比较次数，而记录的移动次数不变。
（3）冒泡排序：比较相邻关键字，若为逆序（非递增），则交换，最终将最大的记录放到最后一个记录的位置上，此为第一趟冒泡排序；对前n-1记录重复上操作，确定倒数第二个位置记录；……以此类推，直至的到一个递增的表。
(4)简单选择排序：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1<=i<=n）个记录交换之。
(5)快速排序:它是对冒泡排序的一种改进，基本思想是，通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
(6)堆排序: 使记录序列按关键字非递减有序排列，在堆排序的算法中先建一个“大顶堆”，即先选得一个关键字为最大的记录并与序列中最后一个记录交换，然后对序列中前n-1记录进行筛选，重新将它调整为一个“大顶堆”，如此反复直至排序结束。
(7)归并排序:归并的含义是将两个或两个以上的有序表组合成一个新的有序表。
假设初始序列含有n个记录，则可看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2或1的有序子序列；再两两归并，……，如此重复，直至得到一个长度为n的有序序列为止，这种排序称为2-路归并排序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
if(a[j]>=a[j+1])
{
w=a[j];
a[j]=a[j+1];
a[j+1]=w;
}
}
}
}
/*************************冒泡排序函数*************************/
void bubble_sort(int a[])
{
printf("\n下面使用冒泡排序法进行排序:");
总体算法思想为按功能分块，依照预想功能实现顺序拼装。
具体思想请见流程图。
流程图
功能流程图
程序编写流程图
算法流程图
算法设计分析
程序总体采用模块化设计，程序间通过传参和调用进行有机组合。这样的总体布局将将各个功能隔离开来，每个模块负责每个模块的功能，使得程序的布局简单明了。且子程序只有在被调用时才会运行大大节约系统资源减少了运算时间。同时由于功能的隔离使得程序的扩展性大大提高，无论程序将要任何改动时，都会方便很多。
}
for (k=n-1; k>=1; k--)
{
t = *(x+0); /*堆顶放到最后*/
*(x+0) = *(x+k);
*(x+k) = t;
sift(x,k,0); /*剩下的数再建堆*/
}
}
/*************************归并排序****************************/
{
double t1,t2,t;int i;
t1=(double) clock();
if(choice==1)
direct(a);
if(choice==2)
bubble_sort(a);
if(choice==3)
choices_sort(a);
if(choice==4)
{
printf("\n现在使用快速排序法进行排序:\n");
{
for(i=0;i<=30000;i++)
{a[i]=aaa[i];
aa[i].key=aaa[i];}
main1();
}
if (choice1==2)
{
printf("谢谢使用，再见！！");
}
}
/**************************生成随机数函数**********************/
/*************************直接插入排序函数***********************/
void direct(int a[]){
printf("\n现在使用直接插入排序法进行排序:\n");
int i,j,w;
for(i=0;i<30000;i++)
{
for(j=i;j>=0;j--)
void choices_sort(int a[])
{ printf("\n现在使用选择排序法进行排序:\n");
int i,j,k,t;
for(i=0;i<30000;i++)
{
k=i;
for(j=i+1;j<30000;j++)
if(a[k]>a[j])
k=j;
t=a[i];
a[i]=a[k];
t1=(double) clock();
scanf("%d",&choice);
timer(choice);
printf("\n\n排序完毕，请选择下一步您要完成的工作：\n\n1.返回选择另一种排序方法排序\n2.退出\n");
scanf("%d",&choice1);
menu(choice1);
}
/*************************主函数******************************/
int listmerge(struct xlx list[],int first,int second)/*递归传递*/
{
int start=30000;
while(first!=-1&&second!=-1)
if(list[first].key<=list[second].key)
{
list[start].link=first;
while (j<n)
{
if (j<n-1 && *(x+j) < *(x+j+1)) /*判断是否满足堆的条件：满足就继续下一轮比较，否则调整。*/
{
j++;
}
if (t<*(x+j)) /*调整*/
{
*(x+k) = *(x+j);
k = j; /*调整后，开始元素也随之调整*/
j = 2*k + 1;
L[left]=key;
return left;
}
void quick_sort(int L[],int first,int end)
{
int split;
if(first<end)
{ split=quick(first,end,L);
quick_sort(L,first,split-1);
quick_sort(L,split+1,end);
for(j=0;i<30000;j++)
{
b=rand();
if(b>=l&&b<=h)
{
a[i]=b;
aa[i].key=b;
aaa[i]=b;
i++;
}
}
for(i=0;i<30000;i++)
printf("%d ",a[i]);
}
void main1(){
printf("\n\n请选择你所希望使用的排序方法：\n\n1。直接插入排序\n2。冒泡排序\n3。选择排序\n4。快速排序\n5。堆排序\n6。归并排序\n");
return list[30000].link;
}
int rmerge(struct xlx list[],int lower,int upper) /*归并并返回已排序的结果数组的起始位置*/
{
int middle;
if(lower>=upper)
return lower;
else{
middle=(lower+upper);
源代码
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
int a[30000];
int choice;
int choice1;
struct xlx{
int key;
int link;
} aa[30000];
int aaa[300000];
void main1();
printf("%d ",a[i]);
printf("\n排序结束您所用排序时间为：%f秒\n",t);
}
/**************************菜单函数***************************/
void menu(int choice1)
{
int i;
if (choice1==1)
void sjs()
{
int i=0,j,b,h,l;
printf("请输入你所期望的将要生成随机数的取值范围：\n");
printf("最小值（不能为负数）：");
scanf("%d",&l);
printf("最大值（无上限）：");
scanf("%d",&h);
srand( (int) time(0));
return listmerge(list,rmerge(list,lower,middle),
rmerge(list,middle+1,upper));
}
}
/*************************时间计算函数************************/
void timer(int choice)
int i,j,w;
for(i=0;i<30000;i++)
for(j=0;j<30000-i;j++)
if(a[j]>a[j+1])
{
w=a[j];
a[j]=a[j+1];
a[j+1]=w;
}
}
/*************************选择排序****************************/
{ while((left<right)&&(L[right]>=key))
right--;
if(left<right)
L[left++]=L[right];
while((left<right)&&(L[left]<=key))
left++;
if(left<right)L[right--]=L[left];}