十大排序法综合排序的设计和实现
任务排序的基本方法
任务排序的基本方法以任务排序的基本方法为题，本文将介绍几种常用的任务排序方法，包括顺序排序、重要性排序、紧急性排序和ABC排序。
一、顺序排序顺序排序是最常见的任务排序方法之一。
它按照任务的完成时间或者先后顺序进行排序。
例如，当我们制定一个计划表时，可以按照任务的开始时间或者截止时间进行排序，确保任务按照预定的顺序进行。
二、重要性排序重要性排序是根据任务的重要性对任务进行排序。
在工作或者学习中，有些任务可能比其他任务更加重要，需要优先完成。
通过将任务按照重要性进行排序，我们可以更好地安排时间和资源，确保重要的任务得到优先处理。
三、紧急性排序紧急性排序是根据任务的紧急程度对任务进行排序。
有些任务可能是突发事件或者紧急任务，需要立即处理。
通过将任务按照紧急性进行排序，我们可以及时应对紧急情况，确保任务能够按时完成。
四、ABC排序ABC排序是一种根据任务的重要性、紧急性和其他因素进行综合排序的方法。
其中，A代表最重要、最紧急的任务；B代表重要但不紧急的任务；C代表不重要但紧急的任务。
通过将任务按照ABC进行排序，我们可以合理安排时间和资源，提高工作效率。
在实际应用中，我们可以根据任务的特点和具体情况选择合适的排序方法。
有时候，我们可以结合使用多种排序方法，以更好地管理和完成任务。
除了以上介绍的常用任务排序方法外，还有其他一些特殊的任务排序方法，例如：1. 奥卡姆剃刀法则：根据奥卡姆剃刀原理，将任务按照最简单和最直接的方式进行排序，以节省时间和精力。
2. 增量排序法：按照任务的完成度进行排序，先完成已经开始进行的任务，再进行下一个任务。
3. 时间管理矩阵：将任务按照重要性和紧急性进行划分，分为四个象限，以帮助我们更好地管理和排序任务。
任务排序是有效管理时间和资源的重要方法之一。
通过选择合适的任务排序方法，我们可以合理安排任务，提高工作效率，达到更好的成果。
在实际应用中，我们可以根据任务的特点和具体情况选择合适的排序方法，灵活运用，以达到最佳效果。
十大经典排序算法总结
⼗⼤经典排序算法总结最近⼏天在研究算法，将⼏种排序算法整理了⼀下，便于对这些排序算法进⾏⽐较，若有错误的地⽅，还请⼤家指正0、排序算法说明0.1 排序术语稳定：如果a=b,且a原本排在b前⾯，排序之后a仍排在b的前⾯不稳定：如果a=b,且a原本排在b前⾯，排序之后排在b的后⾯时间复杂度：⼀个算法执⾏所耗费的时间空间复杂度：⼀个算法执⾏完所需内存的⼤⼩内排序：所有排序操作都在内存中完成外排序：由于数据太⼤，因此把数据放在磁盘中，⽽排序通过磁盘和内存的数据传输才能进⾏0.2算法时间复杂度、空间复杂度⽐较0.3名词解释n:数据规模k:桶的个数In-place:占⽤常数内存，不占⽤额外内存Out-place:占⽤额外内存0.4算法分类1.冒泡排序冒泡排序是⼀种简单的排序算法。
它重复地⾛访过要排序的数列，⼀次⽐较两个元素，如果它们的顺序错误就把它们交换过来。
⾛访数列的⼯作是重复地进⾏直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端1.1算法描述⽐较相邻的元素，如果前⼀个⽐后⼀个打，就交换对每⼀对相邻元素做同样的⼯作，从开始第⼀对到结尾最后⼀对，这样在最后的元素应该会是最⼤的数针对所有的元素重复以上的步骤，除了最后⼀个重复步骤1-3，知道排序完成1.2动图演⽰1.3代码实现public static int[] bubbleSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++)for (int j = 0; j < array.length - 1 - i; j++)if (array[j + 1] < array[j]) {int temp = array[j + 1];array[j + 1] = array[j];array[j] = temp;}return array;}1.4算法分析最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)2.选择排序表现简单直观的最稳定的排序算法之⼀，因为⽆论什么数据都是O(n2)的时间复杂度，⾸先在未排序序列中找到最⼩（⼤）元素，与数组中第⼀个元素交换位置，作为排序序列的起始位置，然后再从剩余未排序元素中继续寻找最⼩（⼤）的元素，与数组中的下⼀个元素交换位置，也就是放在已排序序列的末尾2.1算法描述1.初始状态：⽆序区为R[1..n],有序区为空2.第i躺排序开始时，当前有序区和⽆序区R[1..i-1]、R[i..n]3.n-1趟结束，数组有序化2.2动图演⽰2.3代码实现public static int[] selectionSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++) {int minIndex = i;for (int j = i; j < array.length; j++) {if (array[j] < array[minIndex]) //找到最⼩的数minIndex = j; //将最⼩数的索引保存}int temp = array[minIndex];array[minIndex] = array[i];array[i] = temp;}return array;}2.4算法分析最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)3、插⼊排序是⼀种简单直观的排序算法，通过构建有序序列，对于未排序序列，在已排序序列中从后向前扫描，找到相应位置并插⼊，需要反复把已排序元素逐步向后挪位，为最新元素腾出插⼊空间3.1算法描述1.从第⼀个元素开始，该元素可以认为已经被排序2.取出下⼀个元素（h），在已排序的元素序列中从后往前扫描3.如果当前元素⼤于h，将当前元素移到下⼀位置4.重复步骤3，直到找到已排序的元素⼩于等于h的位置5.将h插⼊到该位置6.重复步骤2-53.2动图演⽰3.3代码实现public static int[] insertionSort(int[] array) {if (array.length == 0)return array;int current;for (int i = 0; i < array.length - 1; i++) {current = array[i + 1];int preIndex = i;while (preIndex >= 0 && current < array[preIndex]) {array[preIndex + 1] = array[preIndex];preIndex--;}array[preIndex + 1] = current;}return array;}3.4算法分析最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)4、希尔排序是简单插⼊排序经过改进之后的⼀个更⾼效的版本，也称为缩⼩增量排序，同时该算法是冲破O(n2）的第⼀批算法之⼀。
各种排序方法总结
选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
冒泡法：这是最原始，也是众所周知的最慢的算法了。
他的名字的由来因为它的工作看来象是冒泡：复杂度为O(n*n)。
当数据为正序，将不会有交换。
复杂度为O(0)。
直接插入排序：O(n*n)选择排序：O(n*n)快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中最高好的，大多数情况下总是最好的。
归并排序：l og2(n)*n堆排序：l og2(n)*n希尔排序：算法的复杂度为n的1.2次幂这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的情况1.数组的大小是2的幂，这样分下去始终可以被2整除。
假设为2的k次方，即k=log2(n)。
2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。
第一层递归，循环n次，第二层循环2*(n/2)......所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n所以算法复杂度为O(lo g2(n)*n) 其他的情况只会比这种情况差，最差的情况是每次选择到的midd le都是最小值或最大值，那么他将变成交换法（由于使用了递归，情况更糟）。
但是你认为这种情况发生的几率有多大？？呵呵，你完全不必担心这个问题。
实践证明，大多数的情况，快速排序总是最好的。
如果你担心这个问题，你可以使用堆排序，这是一种稳定的O(log2(n)*n)算法，但是通常情况下速度要慢于快速排序（因为要重组堆）。
绩效管理_排序法_操作说明(3篇)
第1篇一、引言绩效管理是企业人力资源管理的重要组成部分，通过对员工工作表现的评估，可以帮助企业了解员工的工作效率、能力和潜力，从而实现人力资源的有效配置。
排序法是绩效管理中常用的一种评估方法，本文将详细介绍排序法的操作步骤和注意事项。
二、排序法概述排序法是一种将员工按照绩效表现进行排序的评估方法。
通过将员工的工作表现与其他员工进行比较，可以得出每个员工的相对绩效水平。
排序法分为简单排序法和强制分布排序法两种。
1. 简单排序法：根据评估者的主观判断，将员工按照绩效表现从好到差进行排序。
2. 强制分布排序法：将员工按照绩效表现划分为几个等级，如优秀、良好、一般、较差等，每个等级的人数比例是固定的。
三、排序法操作步骤1. 确定评估指标在实施排序法之前，首先要确定评估指标。
评估指标应包括员工的工作态度、工作能力、工作成果等方面，确保评估的全面性和客观性。
2. 制定评估标准根据评估指标，制定相应的评估标准。
评估标准应明确、具体、可量化，便于评估者进行判断。
3. 收集评估数据收集员工在工作中的表现数据，包括工作业绩、客户满意度、同事评价等。
数据来源可以是员工自评、上级评价、同事评价等。
4. 评估者培训对参与排序的评估者进行培训，使其了解排序法的目的、操作步骤和注意事项，提高评估的准确性。
5. 进行排序根据收集到的评估数据和评估标准，评估者对员工进行排序。
排序过程中，应注意以下几点：（1）客观公正：评估过程中，应避免主观臆断，确保评估结果的公正性。
（2）全面考虑：在排序时，应综合考虑员工的工作表现、潜力、团队合作等多方面因素。
（3）遵循原则：在排序过程中，应遵循公平、公正、公开的原则。
6. 确定绩效等级根据排序结果，将员工划分为不同的绩效等级，如优秀、良好、一般、较差等。
7. 反馈与沟通将排序结果反馈给员工，与员工进行沟通，了解员工对排序结果的意见和建议，共同探讨改进措施。
8. 持续改进根据排序结果，对员工进行针对性的培训和激励，提高员工的工作绩效。
排序算法十大经典方法
排序算法十大经典方法
排序算法是计算机科学中的经典问题之一，它们用于将一组元素按照一定规则排序。
以下是十大经典排序算法：
1. 冒泡排序：比较相邻元素并交换，每一轮将最大的元素移动到最后。
2. 选择排序：每一轮选出未排序部分中最小的元素，并将其放在已排序部分的末尾。
3. 插入排序：将未排序部分的第一个元素插入到已排序部分的合适位置。
4. 希尔排序：改进的插入排序，将数据分组排序，最终合并排序。
5. 归并排序：将序列拆分成子序列，分别排序后合并，递归完成。
6. 快速排序：选定一个基准值，将小于基准值的元素放在左边，大于基准值的元素放在右边，递归排序。
7. 堆排序：将序列构建成一个堆，然后一次将堆顶元素取出并调整堆。
8. 计数排序：统计每个元素出现的次数，再按照元素大小输出。
9. 桶排序：将数据分到一个或多个桶中，对每个桶进行排序，最后输出。
10. 基数排序：按照元素的位数从低到高进行排序，每次排序只考虑一位。
以上是十大经典排序算法，每个算法都有其优缺点和适用场景，选择合适的算法可以提高排序效率。
集合排序的几种方法
集合排序的几种方法集合排序是一种常用的数据排序方法,可以用于许多不同的应用程序和领域。
本文将介绍几种常见的集合排序方法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
1. 冒泡排序(Bubble Sort):冒泡排序是一种简单的排序算法,它重复地遍历待排序集合,比较相邻的元素,并交换它们的位置,直到整个集合都被排序。
冒泡排序的时间复杂度为O(n^2),空间复杂度为O(1),因此它是一种经济高效的排序算法。
2. 插入排序(Insertion Sort):插入排序是一种基于比较的排序算法,它首先将待排序元素逐个插入到已排序序列的末尾,然后对插入的位置进行微调。
插入排序的时间复杂度为O(n^2),空间复杂度为O(1),因此也是一种经济高效的排序算法。
3. 选择排序(Selection Sort):选择排序是一种基于比较的排序算法,它首先将待排序元素逐个插入到已排序序列的末尾,然后选择排序的过程中将未排序的元素从中间位置移除。
选择排序的时间复杂度为O(n^2),空间复杂度为O(1),因此也是一种经济高效的排序算法。
4. 快速排序(Quick Sort):快速排序是一种分治算法,它首先将待排序集合划分为两个子集,然后递归地对这两个子集进行快速排序。
快速排序的时间复杂度为O(nlogn),空间复杂度为O(logn),因此它是一种时间复杂度较低但空间复杂度较高的排序算法。
5. 归并排序(Merge Sort):归并排序是一种基于分治的排序算法,它首先将待排序集合划分为两个子集,然后递归地对这两个子集进行归并排序。
归并排序的时间复杂度为O(nlogn),空间复杂度为O(logn),因此也是一种时间复杂度较低但空间复杂度较高的排序算法。
除了以上几种常见的集合排序方法,还有其他一些高级排序算法,如堆排序、计数排序和希尔排序等。
这些算法具有不同的时间复杂度和空间复杂度,可以根据具体的需求选择最适合的算法。
集合排序是一种常用的数据排序方法,可以用于许多不同的应用程序和领域。
十大经典排序法
十大经典排序法
1. 冒泡排序（Bubble Sort）：通过不断比较相邻元素并交换位置来排序，每一轮将最大的元素冒泡到最后。
2. 选择排序（Selection Sort）：通过找到当前未排序部分的最小元素，将其放置到已排序部分的末尾，逐步构建有序序列。
3. 插入排序（Insertion Sort）：将未排序元素逐个插入到已排序部分的正确位置，从而逐步构建有序序列。
4. 希尔排序（Shell Sort）：是插入排序的改进版本，通过比较相隔一定间隔的元素进行排序，逐渐缩小间隔直至为1。
5. 归并排序（Merge Sort）：采用分治策略，将待排序序列不断拆分为子序列，然后将子序列排序并合并得到最终有序序列。
6. 快速排序（Quick Sort）：也是采用分治策略，通过选择一个基准元素将序列划分为左右两部分，分别对两部分进行排序。
7. 堆排序（Heap Sort）：利用二叉堆的性质来进行排序，将待排序元素构建成最大（最小）堆，然后依次取出堆顶元素并调整堆结构。
8. 计数排序（Counting Sort）：适用于元素值范围较小的情况，通过统计元素出现的次数，然后根据统计结果得到有序序列。
9. 桶排序（Bucket Sort）：将元素根据大小分配到不同的桶中，每个桶内部再分别进行排序，最后将各个桶中的元素合并得到有序序列。
10. 基数排序（Radix Sort）：将待排序元素按照位数进行排序，先按个位排序，再按十位排序，依此类推，直到最高位排序完成。
十大排序算法
⼗⼤排序算法算法之排序排序算法基本上是我们⽆论是在项⽬中还是在⾯试中都会遇到的问题，加上最近在看《算法》这本书，所以就准备好好的将排序算法整理⼀下。
所有排序算法都是基于 Java 实现，为了简单，只使⽤了int类型，从⼩到⼤排序基本排序⾼效的排序各⼤排序的时间测试如何选择排序排序之基本排序算法准备阶段：有⼀个交换位置的函数exc/*** 交换a数组中i和j的位置* @param a 需要交换的数组* @param i 位置* @param j 位置*/public static void exc(int a[],int i,int j){// 当他们相等的时候就没必要进⾏交换if(a[i] != a[j]){a[i] ^= a[j];a[j] ^= a[i];a[i] ^= a[j];}}基本排序算法主要是分为插⼊排序，选择排序，冒泡排序和梳排序。
选择排序原理：选择排序的原理很简单，就是从需要排序的数据中选择最⼩的（从⼩到⼤排序），然后放在第⼀个，选择第⼆⼩的放在第⼆个……代码：/*** 选择排序* @param a 进⾏排序的数组*/public static int[] selectionSort(int a[]){int min;for(int i=0;i<a.length;i++){min = i;// 这个for循环是为了找出最⼩的值for (int j = i+1; j < a.length; j++) {if(a[min]>a[j]){min = j;}}/** 如果第⼀个取出的元素不是最⼩值，就进⾏交换* 意思就是：如果取出的元素就是最⼩值，那么就没有必要进⾏交换了 */if(min != i){// 进⾏交换exc(a, i, min);}}return a;}选择排序的动画演⽰img假如数组的长度是N，则时间复杂度：进⾏⽐较的次数：(N-1)+(N-2)+……+1 = N(N-1)/2进⾏交换的次数：N特点：（稳定）1. 运⾏时间与输⼊⽆关。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
十大排序法对大量数据综合排序的设计和实现文档信息开发小组：组长：于微成员：郑鸿、张雪莹、杨宝英单位：软件设计工作室文档类型：软件开发用技术文档当前版本：Microsoft Word作者：杨宝英、郑鸿完成时间：2010年10月10日软件信息系统名称：十大排序法对大量数据综合排序运行环境Windows Seven 环境下Visual C+ + 6.0版本参与编写：于微、郑鸿、张雪莹、杨宝英日期：2010年10月5号-2010年10月10号系统简介：系统面向大众人群，囊括了起泡排序、插入排序、二分排序、选择排序、希尔排序、快速排序、堆排序、桶排序、基数排序、二路归并排序这十个常用排序，此系统可对一百万个随机数进行综合排序，计算各排序时间，以比较各排序工作的效率。
一、序言 (3)二、需求分析说明书 (3)2.1系统介绍 (3)2.2系统面向的用户群体 (3)2.3系统的功能性需求 (3)2.4系统的非功能性需求 (4)2.4.1用户界面需求 (4)2.4.2软硬件环境需求 (4)三、可行性分析报告 (4)四、概要设计 (5)五、详细设计 (5)5.1主函数于各模块的关系 (5)5.2各模块功能函数 (6)5.2.1基数排序函数的实现 (6)5.2.2起泡排序函数的实现 (8)5.2.3选择排序函数的实现 (9)5.2.4插入排序函数的实现 (10)5.2.5希尔排序函数的实现 (11)5.2.6二分排序函数的实现 (11)5.2.7快速排序函数的实现 (13)5.2.8桶排序函数的实现 (14)5.2.9堆排序函数的实现 (16)5.2.10二路归并排序函数的实现 (18)5.2.11过滤重复数据的实现 (20)六、使用说明 (20)七、心得体会 (23)参考资料 (23)随着社会的发展，人们迎来了信息时代，各种信息日益丰富，需要处理的信息也急剧增加，对数据的排序正是这些处理中的重要一部分。
排序讲究效率，而历来的排序算法种类繁多，各有优劣，难以比较。
所以本次设计运用了人们常用的十大排序算法对一百万个随机数据进行综合排序，以便比较出各种算法的优劣。
选择出几种效率较高的算法应用在实际应用中，使计算机的运行效率更高，更加准确，更加科学化和正规化。
二、需求分析说明书2.1系统介绍本系统定位于大众人群，系统开发平台为Windows Seven,程序设计语言为C++，程序的运行环境为Visual C+ + 6.0。
Visual C+ + 6.0版本主要包括文本编辑器、资源编辑器、工程创建工具、Debugger调试器等等。
用户可以在集成开发环境中创建工程、打开工程、建立、打开和编辑文件、编译、链接、运行、调试应用程序。
2.2系统面向的用户群体系统面向的用户群体为研究排序算法优劣及需要对数据进行排序的人群。
或是对排序算法感兴趣的大众人群。
2.3系统的功能性需求2.3.1数据排序的功能系统提供了基数排序、起泡排序、选择排序、插入排序、希尔排序、二分排序、快速排序、桶排序、堆排序、二路归并排序这十大常用排序。
用户可根据自身需要在键盘上输入各排序算法对应的字符，系统即可实现这些算法的排序，并将排序结果显示在系统界面上。
2.3.2大量数据的导入系统为用户提供大量可供排序的数据。
运行程序时，系统将随机产生一百万个数字以便于用户使用。
导入数据应快速稳定。
2.3.2排序时间的自行显示为了比较各个排序算法的效率，系统界面除了显示排序结果以外还会显示所使用的算法的排序时间，以秒为单位，便于用户对比。
2.4系统的非功能性需求2.4.1用户界面需求简洁、易用、易懂，美观、大方、标准，具备一定的兼容性。
、2.4.2软硬件环境需求软件：程序代码在操作系统windows95及以后版本VC++6.0开发环境中编译。
硬件：硬盘 2GB以上。
三、可行性分析报告排序算法在我们日常编写程序中经常会用到，特别是编写信息管理系统之类的程序更是运用得非常广泛，因此对于这十个常用的排序算法都比较熟悉。
通过相关书籍的阅读和网上信息的查询可以很快掌握这些算法。
小组一共四个人，经过合理的分工，从十月五号到十月十号，这六天时间里可以完成代码的编写和程序相关功能的实现以及文档写作这些工作。
再加上工作室提供了很好的编程环境和网络支持，因而该系统的实现是可行的。
四、概要设计4.1系统总体结构图图4.1五、详细设计5.1主函数与各模块的关系图5.1程序运行时，主函数进行初始化操作，从系统导入一百万个随机数。
通过switch-case语句结构对用户指令进行辨别，根据用户指令调用相应功能模块函数。
5.2各模块功能函数5.2.1基数排序函数的实现函数声明：void r_sort(int *dat,int n);基数排序是将数字按位数划分出n个关键字，每次针对一个关键字进行排序，然后针对排序后的序列进行下一个关键字的排序，循环至所有关键字都使用过则排序完成。
代码实现如下：int maxbit(int *dat,int n)//求最大位数，n个元素{int i,tmp,bit_num=0,t;for(i=0;i<n;i++){t=0;tmp=dat[i];while(tmp>0){t++;tmp/=10;}if(bit_num<t)bit_num=t;}return bit_num;}void r_sort(int *dat,int n){int coun[10];//对各位数字计数int bit_num=maxbit(dat,n);int i,tmp;int *tmp_dat;tmp_dat=new int[n];int denominator=1;while(bit_num--)//最大有几位就排几次，从个位到最高位，位数不足的前边自动补0{memset(coun,0,sizeof(coun));for(i=0;i<n;++i){tmp=dat[i]/denominator%10;++coun[tmp];}for(i=1;i<10;++i)coun[i]+=coun[i-1];for(i=n-1;i>=0;--i){tmp=dat[i]/denominator%10;--coun[tmp];tmp_dat[coun[tmp]]=dat[i];}for(i=0;i<n;i++)dat[i]=tmp_dat[i];denominator*=10;}cout << "基数法排序结果如下:" << endl;del(dat,n);}5.2.2起泡排序函数的实现函数声明：void bubblesort(int a[],int n)；起泡排序的基本思想是将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则将两个记录交换，然后比较第二个记录和第三个记录的关键字。
依次类推，直至第n-1个记录和第n个记录的关键字进行比较为止。
起泡排序是一种稳定的排序方法，在随机产生数的情况下，总的时间复杂度为O(n2)。
代码实现如下：void bubblesort(int a[],int n){int temp,i;int left = 1;int right = n-1;int bound=n;do{for (i = right;i >= left; i--){if(a[i] <a[i-1]){temp = a[i-1];a[i-1] = a[i];a[i] = temp;bound = i;}}left = bound+1;for (i = left; i<right+1; i++){if(a[i] < a[i-1]){temp = a[i-1];a[i-1] = a[i];a[i] = temp;bound = i;}}right = bound-1;}while(right-left>1);cout<<"\n起泡法排序结果如下:"<<endl;del(a,n);}5.2.3选择排序函数的实现函数声明：void Selectsort(int a[],int n)；选择排序法的基本思想是：第i趟排序通过n-i次关键码的比较，在n-1+i(1 <= i <= n-1)个记录中选取关键码最小的记录，并和第i个记录交换作为有序序列的第i个记录。
选择排序是一种稳定的排序方法，总的时间复杂度是O(n2)。
代码实现如下：void Selectsort(int a[],int n){int i,j,t;int min;for (i=0; i<n; i++) //对n个记录进行n-1趟简单选择排序{min=i; //记录关键码码最小的位置for (j=i+1; j<n; j++)if (a[j] < a[min]) min=j;if (i!=min){t=a[i];a[i]=a[min];a[min]=t;}}cout<<"\n选择法的排序结果如下:"<<endl;del(a,n);}5.2.4插入排序函数的实现函数声明：void InsertSort(int a[],int n)；直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到排好序的有序表中，直到无序区中没有记录为止，从而得到一个新的有序表。
直接插入排序是一种稳定的排序方法，其时间复杂度为O(n)。
代码实现如下：void InsertSort(int a[],int n){int i,j,temp;for (i =1; i<n; i++){temp= a[i]; //取出要插入的数a[i]，用临时变量temp储存for (j=i-1;j>=0&&temp<a[j];j--) //寻找位置a[j+1] = a[j];a[j+1] = temp;//插入}cout<<"\n插入法的排序结果如下:"<<endl;del(a,n);}5.2.5希尔排序函数的实现函数声明：void Sellsort(int a[],int n)；希尔排序又称增量缩小排序，基本思想是先将序列按增量划分为元素个数相同的若干子序列，在子序列内分别进行直接插入排序，然后不断缩小增量直至为1，最后使用直接插入排序法完成排序。
代码实现如下：void Sellsort(int a[],int n){int i,j,d,temp;for (d = n/2; d >= 1; d = d/2) //以d为增量进行插入排序{for (i = d+1; i<n; i++) //将a[i]插入到所属的子序列中{temp = a[i];for (j = i-d; j>0 && temp<a[j]; j = j-d)a[j+d] = a[j]; //后移记录a[j+d] = temp;}}cout<<"\n希尔法的排序结果如下:"<<endl;del(a,n);}5.2.6二分排序函数的实现函数声明：void Dichotomy(int a[],int n)；二分排序法的基本思想是：在插入第i个元素时，对前面的0～(i-1)个元素进行折半，先跟他们中间的那个元素比，如果小，则对前半再进行折半，否则对后半元素进行折半，直到left>right，然后再把第i个元素前1位与目标位置之间的所有元素后移，再把第i个元素放在目标位置上。