快速排序经典

合集下载

头歌数据结构十大经典排序算法 -回复

头歌数据结构十大经典排序算法 -回复

头歌数据结构十大经典排序算法-回复什么是经典排序算法?经典排序算法是指在计算机科学领域中被广泛应用和研究的排序算法。

排序是计算机科学中的基本操作之一,它的目标是将一组元素按照某种特定的顺序进行排列。

经典排序算法通常被用来解决排序问题,可以应用于数据的排序、搜索、统计等各种计算任务中。

在这篇文章中,我们将讨论头歌数据结构中的十大经典排序算法,探索每个算法的原理和实现方法,以及它们的优缺点和适用场景。

1. 冒泡排序(Bubble sort)冒泡排序是一种简单直观的排序算法,它的基本思想是重复地交换相邻两个元素,将较大的元素逐渐“浮”到数组的尾部。

具体实现可以使用两层嵌套循环,外层循环控制比较的轮数,内层循环进行元素比较和交换。

冒泡排序的时间复杂度为O(n^2)。

2. 选择排序(Selection sort)选择排序是一种简单的选择最小元素的排序算法,它的基本思想是从头开始,逐个选择最小的元素,并将其放置到已排序部分的末尾。

具体实现可以使用两层嵌套循环,外层循环控制已排序部分的末尾位置,内层循环用于选择最小元素。

选择排序的时间复杂度为O(n^2)。

3. 插入排序(Insertion sort)插入排序是一种简单直观的排序算法,它的基本思想是将已排序部分的元素依次与未排序部分的元素进行比较并插入到正确的位置。

具体实现可以使用两层嵌套循环,外层循环控制未排序部分的元素,内层循环用于比较和插入元素。

插入排序的时间复杂度为O(n^2)。

4. 希尔排序(Shell sort)希尔排序是一种改进的插入排序算法,它的基本思想是将数组划分为若干个子序列,并分别对子序列进行插入排序,直到整个数组有序。

具体实现使用增量序列来控制子序列的划分和插入排序的间隔,最终将整个数组排序。

希尔排序的时间复杂度为O(nlogn)。

5. 归并排序(Merge sort)归并排序是一种分治法排序算法,它的基本思想是将数组分成两个子数组,分别对子数组进行递归排序,然后将排序好的子数组合并成一个有序的数组。

十大经典排序算法总结

十大经典排序算法总结

⼗⼤经典排序算法总结最近⼏天在研究算法,将⼏种排序算法整理了⼀下,便于对这些排序算法进⾏⽐较,若有错误的地⽅,还请⼤家指正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)的第⼀批算法之⼀。

scratch经典算法实例

scratch经典算法实例

scratch经典算法实例以下是几个经典的算法实例:1. 冒泡排序算法(Bubble Sort):冒泡排序是一种简单的排序算法。

它通过不断交换相邻的两个元素将最大的元素冒泡到最后一位,然后再对剩下的元素进行同样的操作,直到整个数组排序完成。

2. 插入排序算法(Insertion Sort):插入排序是一种简单直观的排序算法。

它将数组分为已排序和未排序两部分,每次从未排序部分选取一个元素,插入到已排序部分的正确位置。

3. 选择排序算法(Selection Sort):选择排序是一种简单直观的排序算法。

它每次从未排序部分选择最小(或最大)的元素,然后与未排序部分的第一个元素进行交换。

4. 快速排序算法(Quick Sort):快速排序是一种高效的排序算法。

它通过选择一个基准元素,将数组分为两部分,一部分小于基准元素,一部分大于基准元素,然后对两部分分别递归地进行快速排序。

5. 归并排序算法(Merge Sort):归并排序是一种高效的排序算法。

它通过将数组分成两部分,对每部分递归地进行归并排序,然后将两个有序的部分合并成一个有序的数组。

6. 二分查找算法(Binary Search):二分查找是一种高效的查找算法。

它通过将有序数组分为两部分,每次根据中间元素与目标值的大小关系,将查找范围缩小一半,直到找到目标值或查找范围为空。

7. 链表反转算法(Reverse Linked List):链表反转是一种常见的操作。

它通过将链表的指针方向逆转,实现原链表的反转。

8. 字符串匹配算法(String Matching):字符串匹配是一种常见的问题。

常用的算法包括暴力匹配、KMP算法和Boyer-Moore算法等,它们通过不同的方法在文本中查找指定的模式串。

以上算法示例都是经典而重要的算法,对算法的理解和掌握有很大帮助。

除了上述算法外,还有很多其他的经典算法,如动态规划、贪心算法、最短路径算法等,它们在实际应用中有着广泛的用途。

经典算法实例范文

经典算法实例范文

经典算法实例范文算法是一系列解决问题的步骤或规则,是计算机科学中非常重要的概念。

经典算法是指在计算机科学领域被广泛应用并被证明相对高效的算法。

本文将介绍几个经典算法的实例。

一、排序算法排序算法是最基本、最常用的算法之一、下面将介绍两个经典的排序算法。

1.冒泡排序冒泡排序是一种简单的排序算法,它的基本思路是多次遍历数组,每次将相邻的两个元素逐个比较,如果顺序不对则交换位置。

这样一次遍历后,最大的元素会被移到最后。

重复n-1次遍历,就可以完成排序。

冒泡排序的时间复杂度是O(n^2)。

2.快速排序快速排序是一种高效的排序算法,它的基本思路是选择一个基准元素,通过一趟排序将待排序的序列分成两个独立的部分,其中一部分的所有元素都小于基准,另一部分的所有元素都大于等于基准。

然后对这两个部分分别进行递归排序,最后合并两个部分得到有序序列。

快速排序的时间复杂度是 O(nlogn)。

二、查找算法查找算法是在给定的数据集合中一些特定元素的算法。

下面将介绍两个常用的查找算法。

1.二分查找二分查找也称为折半查找,是一种在有序数组中查找一些特定元素的算法。

它的基本思路是首先确定数组中间位置的元素,然后将要查找的元素与中间元素进行比较,如果相等则返回位置,如果小于则在左部分继续查找,如果大于则在右部分继续查找。

二分查找的时间复杂度是 O(logn)。

2.哈希查找哈希查找是通过哈希函数将关键字映射到哈希表中的位置,然后根据映射位置在哈希表中查找关键字。

哈希查找的时间复杂度是O(1)。

三、图算法图是由节点和边组成的一种数据结构,图算法主要用于解决与图相关的问题。

下面将介绍两个常用的图算法。

1.广度优先广度优先是一种用于图的遍历和的算法。

它的基本思路是从图的其中一顶点出发,遍历所有与之相邻的顶点,然后再依次遍历这些相邻顶点的相邻顶点,以此类推,直到访问完所有顶点,或者找到目标顶点。

广度优先使用队列来实现,时间复杂度是O(,V,+,E,),其中,V,表示图的顶点数,E,表示图的边数。

快速排序ppt课件

快速排序ppt课件

在实际项目中的应用
数据库索引
数据库索引的建立和维护可以采用快速排序的思想。通 过快速排序的分区操作,可以将索引分成有序的多个部 分,便于快速查找和定位数据。
搜索引擎
搜索引擎中的网页排名算法可以采用快速排序的思想。 通过对网页进行快速排序,可以将最相关的网页排在前 面,提高搜索结果的准确性和用户体验。
提高效率。
02
快速排序算法原理
分治策略
分治策略是快速排序的核心思想,即将一个复杂的问题分解为若干个较小的、更易 于解决的子问题。
在快速排序中,原数组被选定的基准元素划分为两个子数组,使得一个子数组的所 有元素都比基准元素小,另一个子数组的所有元素都比基准元素大。
通过递归地对这两个子数组进行快速排序,最终得到有序的数组。
05
快速排序的变种
快速三向切分排序
总结词
基于快速排序的变种,将数组分为三个部分进行排序。
详细描述
快速三向切分排序是在快速排序的基础上进行的一种改进。它将待排序的数组分为三个部分,左边的已排序部分、 中间的未排序部分和右边的已排序部分。然后对中间的未排序部分进行快速排序,并将结果与左右两边的已排序 部分进行合并,从而实现整个数组的排序。
pivot = arr[len(arr) // 2]
代码实现
middle = [x for x in arr
01 if x == pivot]
right = [x for x in arr if
03 x > pivot]
return quicksort(left) +
02
middle +
quicksort(right)
VS
详细描述
快速基数排序是一种非比较型整数排序算 法,它将整数按位数切割成不同的数字, 然后按每个位数分别比较。具体实现中, 从最低位开始,对每一位使用稳定的排序 算法(如计数排序)进行排序,直到最高 位。由于只针对整数有效,因此对于浮点 数需要做一些额外处理。

快速排序详解(lomuto划分快排,hoare划分快排,classic经典快排,dualp。。。

快速排序详解(lomuto划分快排,hoare划分快排,classic经典快排,dualp。。。

快速排序详解(lomuto划分快排,hoare划分快排,classic经典快排,dualp。

快速排序(lomuto划分快排,hoare划分快排,classic经典快排,dualpivot双轴快排)@⽬录⼀、快速排序思想快速排序的思想,是找出⼀个中轴(pivot),之后进⾏左右递归进⾏排序,关于递归快速排序,C程序算法如下。

void quick_sort(int *arr,int left,int right){if(left>right) return;int pivot=getPivot();quick_sort(arr,left,pivot-1);quick_sort(arr,pivot+1,right);}⼆、划分思想关于划分,不同的划分决定快排的效率,下⾯以lomuto划分和hoare划分来进⾏讲述思路1.lomuto划分思想:lomuto划分主要进⾏⼀重循环的遍历,如果⽐left侧⼩,则进⾏交换。

然后继续进⾏寻找中轴。

最后交换偏移的数和最左侧数,C程序代码如下。

/**lomuto划分*/int lomuto_partition(int *arr,int l,int r){int p=arr[l];int s=l;for(int i=l+1;i<=r;i++)if(arr[i]<p) {s++;int tmp=arr[i];arr[i]=arr[s];arr[s]=tmp;}int tmp=arr[l];arr[l]=arr[s];arr[s]=tmp;return s;}2.hoare划分思想:hoare划分思想是先从右侧向左进⾏寻找,再从左向右进⾏寻找,如果左边⽐右边⼤,则左右进⾏交换。

外侧还有⼀个嵌套循环,循环终⽌标志是⼀重遍历,这种寻找的好处就是,在⼀次遍历后能基本有序,减少递归的时候产⽣的⽐较次数。

这也是经典快排中所使⽤的⽅法/**hoare划分*/int hoare_partition(int *a,int l, int r) {int p = a[l];int i = l-1;int j = r+1 ;while (1) {do {j--;}while(a[j]>p);do {i++;}while(a[i] < p);if (i < j) {int temp = a[i];a[i] = a[j];a[j] = temp;}elsereturn j;}}3.经典快排的划分改进经典快排实际对hoare划分进⾏了少许改进,这个temp变量不需要每次找到左右不相等就⽴即交换,⽽是,暂时存放,先右边向左找,将左边放在右边,再左边向右找,把右边放左边,最后把初始temp变量放在左值。

排序算法十大经典方法

排序算法十大经典方法

排序算法十大经典方法
排序算法是计算机科学中的经典问题之一,它们用于将一组元素按照一定规则排序。

以下是十大经典排序算法:
1. 冒泡排序:比较相邻元素并交换,每一轮将最大的元素移动到最后。

2. 选择排序:每一轮选出未排序部分中最小的元素,并将其放在已排序部分的末尾。

3. 插入排序:将未排序部分的第一个元素插入到已排序部分的合适位置。

4. 希尔排序:改进的插入排序,将数据分组排序,最终合并排序。

5. 归并排序:将序列拆分成子序列,分别排序后合并,递归完成。

6. 快速排序:选定一个基准值,将小于基准值的元素放在左边,大于基准值的元素放在右边,递归排序。

7. 堆排序:将序列构建成一个堆,然后一次将堆顶元素取出并调整堆。

8. 计数排序:统计每个元素出现的次数,再按照元素大小输出。

9. 桶排序:将数据分到一个或多个桶中,对每个桶进行排序,最后输出。

10. 基数排序:按照元素的位数从低到高进行排序,每次排序只考虑一位。

以上是十大经典排序算法,每个算法都有其优缺点和适用场景,选择合适的算法可以提高排序效率。

C语言入门必学—10个经典C语言算法

C语言入门必学—10个经典C语言算法

C语言入门必学—10个经典C语言算法C语言是一种广泛使用的编程语言,具有高效、灵活和易学的特点。

它不仅在软件开发中被广泛应用,也是计算机科学专业的必修课。

在学习C语言的过程中,掌握一些经典的算法是非常重要的。

本文将介绍10个经典C语言算法,帮助读者更好地了解和掌握C语言。

一、冒泡排序算法(Bubble Sort)冒泡排序算法是最简单、也是最经典的排序算法之一。

它通过不断比较相邻的元素并交换位置,将最大(或最小)的元素逐渐“冒泡”到数组的最后(或最前)位置。

二、选择排序算法(Selection Sort)选择排序算法是一种简单但低效的排序算法。

它通过不断选择最小(或最大)的元素,并与未排序部分的第一个元素进行交换,将最小(或最大)的元素逐渐交换到数组的前面(或后面)。

三、插入排序算法(Insertion Sort)插入排序算法是一种简单且高效的排序算法。

它通过将数组分为已排序和未排序两个部分,依次将未排序部分的元素插入到已排序部分的合适位置。

四、快速排序算法(Quick Sort)快速排序算法是一种高效的排序算法。

它采用了分治的思想,通过将数组分为较小和较大两部分,并递归地对两部分进行排序,最终达到整个数组有序的目的。

五、归并排序算法(Merge Sort)归并排序算法是一种高效的排序算法。

它采用了分治的思想,将数组一分为二,递归地对两个子数组进行排序,并将结果合并,最终得到有序的数组。

六、二分查找算法(Binary Search)二分查找算法是一种高效的查找算法。

它通过不断将查找范围折半,根据中间元素与目标值的大小关系,缩小查找范围,最终找到目标值所在的位置。

七、递归算法(Recursive Algorithm)递归算法是一种通过自我调用的方式解决问题的算法。

在C语言中,递归算法常用于解决树的遍历、问题分解等情况。

八、斐波那契数列算法(Fibonacci Sequence)斐波那契数列是一列数字,其中每个数字都是前两个数字的和。

世界十大经典算法

世界十大经典算法

世界十大经典算法世界十大经典算法算法是计算机科学中非常重要的概念,它是一种解决问题的方法和步骤的描述。

以下是世界上广泛应用且被业界认可的十大经典算法: 1. 二分查找算法(Binary Search Algorithm):在有序数组中查找目标元素的算法。

通过将目标元素与数组中间元素进行比较,可以将搜索范围缩小一半,从而提高搜索效率。

2. 快速排序算法(Quick Sort Algorithm):一种基于分治法的排序算法。

它通过选择一个基准元素,将数组分为两个子数组,其中一个子数组的元素都小于等于基准元素,另一个子数组的元素都大于等于基准元素,然后递归地对子数组进行排序。

3. 归并排序算法(Merge Sort Algorithm):一种基于分治法的排序算法。

它将数组分成两个子数组,然后递归地对子数组进行排序,并将排序好的子数组合并成一个有序的数组。

4. 广度优先搜索算法(Breadth-First Search Algorithm):用于图遍历的一种算法。

它从图的某个顶点开始,逐层遍历其邻接顶点,直到遍历完所有顶点。

广度优先搜索常用于寻找最短路径或解决迷宫等问题。

5. 深度优先搜索算法(Depth-First Search Algorithm):用于图遍历的一种算法。

它从图的某个顶点开始,沿着一条路径一直向下遍历,直到无法继续为止,然后回溯到上一个没有遍历完的邻接顶点,继续遍历其他路径。

深度优先搜索常用于生成迷宫、图的连通性问题等。

6. Dijkstra算法(Dijkstra's Algorithm):用于求解单源最短路径问题的一种算法。

它根据权重赋值给每条边,计算出从源节点到其他节点的最短路径。

7. 动态规划算法(Dynamic Programming Algorithm):一种基于分治法的优化算法。

动态规划在问题可分解为重叠子问题时,通过保存子问题的解,避免重复计算,从而提高算法效率。

快排复杂度及其证明

快排复杂度及其证明

快排复杂度及其证明快速排序(Quicksort)是一种经典的排序算法,其平均时间复杂度为O(nlogn)。

该算法的核心思想是通过递归地将数组分割成较小的子数组,然后分别对子数组进行排序。

快速排序的步骤如下:首先选择一个基准元素,然后将数组中比基准元素小的元素放在基准元素的左边,将比基准元素大的元素放在基准元素的右边。

接着递归地对左右两个子数组进行排序,直到整个数组有序。

快速排序的时间复杂度分析如下:在最好情况下,每次划分都能平分数组,时间复杂度为O(nlogn);在最坏情况下,每次划分只能将数组分成一个元素和其余元素两部分,时间复杂度为O(n^2)。

然而,通过随机选择基准元素或者使用三数取中法可以避免最坏情况的发生,从而保证快速排序的平均时间复杂度为O(nlogn)。

快速排序的时间复杂度证明可以通过数学归纳法进行推导。

假设对n个元素的数组进行快速排序的时间复杂度为T(n),则有:T(n) = 2T(n/2) + O(n)。

其中2T(n/2)表示对左右两个子数组进行排序的时间复杂度,O(n)表示划分数组的时间复杂度。

根据主定理(Master Theorem)可知,对于递推式T(n) = aT(n/b) + f(n),其中a>=1,b>1,f(n)是多项式,有以下三种情况:1. 若f(n) = O(n^d),其中d<logba,则T(n) = O(n^logba);2. 若f(n) = Θ(n^d * log^k n),其中d=logba,则T(n) = O(n^d * log^(k+1) n);3. 若f(n) = Ω(n^d),其中d>logba,则T(n) = O(f(n))。

根据快速排序的递推式T(n) = 2T(n/2) + O(n),可以得到a=2,b=2,f(n)=O(n)。

因此,根据主定理可知,快速排序的时间复杂度为O(nlogn)。

快速排序是一种时间复杂度为O(nlogn)的高效排序算法,通过合理选择基准元素和递归地划分子数组,可以在平均情况下实现较快的排序速度。

【十大经典排序算法(动图演示)】 必学十大经典排序算法

【十大经典排序算法(动图演示)】 必学十大经典排序算法

【十大经典排序算法(动图演示)】必学十大经典排序算法0.1 算法分类十种常见排序算法可以分为两大类:比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序。

非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此也称为线性时间非比较类排序。

0.2 算法复杂度0.3 相关概念稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面。

不稳定:如果a原本在b的前面,而a=b,排序之后a 可能会出现在b 的后面。

时间复杂度:对排序数据的总的操作次数。

反映当n变化时,操作次数呈现什么规律。

空间复杂度:是指算法在计算机内执行时所需存储空间的度量,它也是数据规模n的函数。

1、冒泡排序(Bubble Sort)冒泡排序是一种简单的排序算法。

它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。

走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述比较相邻的元素。

如果第一个比第二个大,就交换它们两个;对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;针对所有的元素重复以上的步骤,除了最后一个;重复步骤1~3,直到排序完成。

1.2 动图演示1.3 代码实现1.unction bubbleSort(arr) {2. varlen = arr.length;3. for(vari = 0; i arr[j+1]) {// 相邻元素两两对比6. vartemp = arr[j+1];// 元素交换7. arr[j+1] = arr[j];8. arr[j] = temp;9. }10. }11. }12. returnarr;13.}2、选择排序(Selection Sort)选择排序(Selection-sort)是一种简单直观的排序算法。

快速排序经典例题

快速排序经典例题

快速排序经典例题快速排序是一种经典的排序算法,它能够在平均情况下以O(n log n)的时间复杂度对一个数组进行排序。

快速排序的核心思想是通过一次划分操作将待排序数组分成两个部分,其中一部分的所有元素都小于等于划分元素,另一部分的所有元素都大于划分元素,然后对这两部分分别进行递归排序。

下面我们将通过一个经典的例题来详细介绍快速排序的算法流程。

假设我们有一个包含n个整数的数组,我们的目标是将它们按照非降序进行排序。

下面是一个简单的例题:例题:给定一个数组[9, 7, 5, 11, 12, 2, 14, 3, 10, 6],请使用快速排序算法将其进行排序。

解题步骤如下:1. 选择一个划分元素pivot。

在这个例题中,我们可以选择数组的第一个元素9作为pivot。

2. 根据划分元素将数组分成两个部分。

遍历数组,将小于等于pivot的元素放在数组左侧,将大于pivot的元素放在数组右侧。

在这个例题中,我们得到的划分结果如下:[5, 2, 3, 6, 7, 9, 14, 12, 10, 11]3. 对划分结果的左右两部分进行递归排序。

我们分别对左侧的子数组[5, 2, 3, 6, 7]和右侧的子数组[14, 12, 10, 11]进行递归排序。

4. 重复步骤1到步骤3,直到每个子数组只包含一个元素或是空数组。

5. 合并排序后的子数组。

最后,将排序后的子数组进行合并,我们得到最终的排序结果为:[2, 3, 5, 6, 7, 9, 10, 11, 12, 14]快速排序的时间复杂度主要取决于划分的效果。

在最坏情况下,每次划分都将数组划分成一个元素和n-1个元素两部分,这种情况下快速排序的时间复杂度为O(n^2)。

然而,在平均情况下,快速排序的时间复杂度为O(n log n)。

快速排序是一种原地排序算法,即不需要额外的空间来存储排序结果。

通过交换数组元素来实现排序,因此它的空间复杂度为O(log n)。

然而,在最坏情况下,快速排序需要O(n)的额外空间来进行递归调用。

学生成绩表的快速排序

学生成绩表的快速排序

学生成绩表的快速排序快速排序(Quick Sort)是一种经典的排序算法,它的时间复杂度为O(nlogn)。

要对学生成绩表进行快速排序,可以按照以下步骤进行操作:1.选择一个枢轴元素(pivot),可以选择成绩表中的任意一个元素。

2.将成绩表中的元素按照与枢轴元素的大小关系,分为两个子序列:一个小于枢轴元素的子序列(一般称为"左子数组")和一个大于枢轴元素的子序列(一般称为"右子数组")。

这个过程叫做分区(Partition)。

3.递归地对左子数组和右子数组进行快速排序,重复上述步骤,直到每个子数组只剩下一个元素或为空。

4.将排序后的左子数组和右子数组合并,即得到最终的有序成绩表。

以下是一个示例的快速排序算法的Python实现:def quick_sort(scores):if len(scores) <= 1:return scoreselse:pivot = scores[0]less = [x for x in scores[1:] if x <= pivot]greater = [x for x in scores[1:] if x > pivot]return quick_sort(less) + [pivot] + quick_sort(greater)# 示例调用scores = [85, 90, 70, 95, 80]sorted_scores = quick_sort(scores)print(sorted_scores)执行以上代码后,将输出成绩表的排序结果。

请注意,以上示例只是一种基本的快速排序算法实现,并不能处理一些特殊情况,比如输入的数据包含重复元素、边界条件处理等。

实际应用中,可以根据具体要求对算法进行优化和适配。

经典十大排序算法

经典十大排序算法

经典⼗⼤排序算法前⾔排序种类繁多,⼤致可以分为两⼤类:⽐较类排序:属于⾮线性时间排序,时间复杂度不能突破下界O(nlogn);⾮⽐较类排序:能达到线性时间O(n),不是通过⽐较来排序,有基数排序、计数排序、桶排序。

了解⼀个概念:排序的稳定性稳定是指相同⼤⼩的元素多次排序能保证其先后顺序保持不变。

假设有⼀些学⽣的信息,我们先根据他们的姓名进⾏排序,然后我们还想根据班级再进⾏排序,如果这时使⽤的时不稳定的排序算法,那么第⼀次的排序结果可能会被打乱,这样的场景需要使⽤稳定的算法。

堆排序、快速排序、希尔排序、选择排序是不稳定的排序算法,⽽冒泡排序、插⼊排序、归并排序、基数排序是稳定的排序算法。

1、冒泡排序⼤多数⼈学编程接触的第⼀种排序,名称很形象。

每次遍历排出⼀个最⼤的元素,将⼀个最⼤的⽓泡冒出⽔⾯。

时间复杂度:平均:O(n2);最好:O(n);最坏:O(n2)空间复杂度:O(1)public static void bubbleSort(int[] arr) {/*** 总共⾛len-1趟即可,每趟排出⼀个最⼤值放在最后*/for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - i - 1; j++) {if (arr[j] > arr[j + 1]) {int tp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tp;}}}}2、选择排序最直观易理解的排序算法,每次排出⼀个最⼩的元素。

也是最稳定的算法,时间复杂度稳定为O(n^2)。

需要⼀个变量记录每次遍历最⼩元素的位置。

时间复杂度:O(n2)空间复杂度:O(1)public static void selectSort(int[] arr){int n = arr.length;for (int i = 0; i < n; i++) {int maxIdx = 0;for(int j = 1; j < n - i; j++){if(arr[maxIdx] < arr[j]){maxIdx = j;}}int tp = arr[maxIdx];arr[maxIdx] = arr[n - 1 - i];arr[n - 1 - i] = tp;}}3、插⼊排序⼀种直观的排序算法,从第⼆个元素开始,每次往前⾯遍历找到⾃⼰该在的位置。

快速排序的例子

快速排序的例子

快速排序的例子1. 你知道吗,快速排序就像整理混乱的玩具箱!比如说,你有一堆各种玩具混在一起,快速排序就是那个能快速把它们整理得井井有条的神奇方法。

想象一下,把那些玩具按大小、类型一下子分好类,是不是超级厉害?这就是快速排序的魅力啊!2. 哎呀呀,快速排序简直就像是厨房里的高效大厨!就好比你有一堆食材杂乱无章地堆着,快速排序能迅速地给它们安排好位置。

像切菜、配菜一样,把数据也能准确快速地排好序,酷不酷呀?绝对神奇啊!3. 快速排序啊,那可真是如同高明的指挥家呀!你想想,一场混乱的音乐会,各种乐器声音交织在一起。

而快速排序就像指挥家的指挥棒,迅速让这些声音有序起来,形成美妙的旋律。

这不就是快速排序在数据世界里做的事吗?太妙啦!4. 嘿,快速排序简直和整理书架的高手一样牛!假设你的书架乱得不像话,书都堆在一起。

快速排序这时候就出马啦,能快速把书按照某种规则摆放好。

这不就像数据在快速排序的作用下变得整齐有序一样吗?多有意思啊!5. 哇哦,快速排序就好像是赛跑比赛里的发令员!一旦下令,数据们就迅速地奔跑起来,找到自己合适的位置。

这不就像运动员按照指令迅速列队一样吗?真的好神奇呢!6. 快速排序,那可真是像拆乱麻的小能手!想象一团乱糟糟的线团,快速排序能神奇地把它理顺。

数据不也是这样吗,通过快速排序变得有条理,是不是很厉害呢?太让人惊叹啦!7. 你瞧,快速排序宛如装修房子的大师傅!面对乱七八糟的房间,快速排序就能像大师傅一样,刷刷几下让一切都焕然一新。

数据也是,经过快速排序变得整齐漂亮。

这就是快速排序的魔力呀,真的很牛啊!我的观点结论:快速排序真是个超棒的算法,能快速有效地让数据变得有序,在很多场景中都大有用处!。

计算机10大经典算法

计算机10大经典算法

计算机10⼤经典算法算法⼀:快速排序法快速排序是由东尼·霍尔所发展的⼀种排序算法。

在平均状况下,排序 n 个项⽬要Ο(n log n)次⽐较。

在最坏状况下则需要Ο(n2)次⽐较,但这种状况并不常见。

事实上,快速排序通常明显⽐其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在⼤部分的架构上很有效率地被实现出来。

快速排序使⽤分治法(Divide and conquer)策略来把⼀个串⾏(list)分为两个⼦串⾏(sub-lists)。

算法步骤:1 .从数列中挑出⼀个元素,称为 “基准”(pivot),2. 重新排序数列,所有元素⽐基准值⼩的摆放在基准前⾯,所有元素⽐基准值⼤的摆在基准的后⾯(相同的数可以到任⼀边)。

在这个分区退出之后,该基准就处于数列的中间位置。

这个称为分区(partition)操作。

3. 递归地(recursive)把⼩于基准值元素的⼦数列和⼤于基准值元素的⼦数列排序。

递归的最底部情形,是数列的⼤⼩是零或⼀,也就是永远都已经被排序好了。

虽然⼀直递归下去,但是这个算法总会退出,因为在每次的迭代(iteration)中,它⾄少会把⼀个元素摆到它最后的位置去。

算法⼆:堆排序算法堆排序(Heapsort)是指利⽤堆这种数据结构所设计的⼀种排序算法。

堆积是⼀个近似完全⼆叉树的结构,并同时满⾜堆积的性质:即⼦结点的键值或索引总是⼩于(或者⼤于)它的⽗节点。

堆排序的平均时间复杂度为Ο(nlogn) 。

算法步骤:1.创建⼀个堆H[0..n-1]2.把堆⾸(最⼤值)和堆尾互换3. 把堆的尺⼨缩⼩1,并调⽤shift_down(0),⽬的是把新的数组顶端数据调整到相应位置4. 重复步骤2,直到堆的尺⼨为1算法三:归并排序归并排序(Merge sort,台湾译作:合并排序)是建⽴在归并操作上的⼀种有效的排序算法。

该算法是采⽤分治法(Divide and Conquer)的⼀个⾮常典型的应⽤。

六大经典算法

六大经典算法

六大经典算法经典算法是计算机科学中非常重要的一部分,它们被广泛应用于各种领域,包括数据结构、排序、搜索、图论和机器学习等。

下面我将介绍六大经典算法,分别是:冒泡排序、快速排序、插入排序、选择排序、归并排序和二分查找。

一、冒泡排序冒泡排序是一种简单的排序算法,它重复地遍历要排序的列表,比较相邻的元素,并按照大小顺序交换它们。

通过多次遍历,将最大的元素逐渐“冒泡”到列表的末尾,直到整个列表有序为止。

二、快速排序快速排序是一种高效的排序算法,它采用分治的思想,将一个待排序的列表不断划分为两个子列表,然后分别对子列表进行排序,最后将排序好的子列表合并起来。

快速排序的关键在于选择一个基准元素,并根据基准元素将列表划分为左右两个子列表,然后递归地对子列表进行排序。

三、插入排序插入排序是一种简单直观的排序算法,它的工作原理是将一个元素插入到已排序的列表中的适当位置,从而得到一个新的有序列表。

插入排序的核心思想是将待排序的列表分为已排序和未排序两部分,然后依次将未排序部分的元素插入到已排序部分中。

四、选择排序选择排序是一种简单的排序算法,它每次从待排序的列表中选择最小(或最大)的元素,然后将其放到已排序的列表的末尾。

通过多次选择最小(或最大)元素,选择排序可以得到一个有序的列表。

五、归并排序归并排序是一种高效的排序算法,它采用分治的思想,将一个待排序的列表递归地划分为两个子列表,然后分别对子列表进行排序,最后将排序好的子列表合并起来。

归并排序的关键在于将两个有序的子列表合并成一个有序的列表。

六、二分查找二分查找是一种高效的查找算法,它适用于有序列表。

二分查找的核心思想是不断地将待查找的区间分为两部分,然后根据目标值与中间值的大小关系,确定接下来要查找的区间,直到找到目标值或查找区间为空。

总结:以上六大经典算法分别是冒泡排序、快速排序、插入排序、选择排序、归并排序和二分查找。

这些算法在计算机科学中具有重要的地位,它们不仅可以用来解决排序和查找问题,还可以应用于其他领域,如图论、机器学习等。

头歌数据结构十大经典排序算法

头歌数据结构十大经典排序算法

头歌数据结构十大经典排序算法导言在计算机科学中,排序算法是一类常见且重要的算法。

通过对一组元素进行排序,我们可以提高数据的组织性和检索效率。

本文将介绍头歌数据结构十大经典排序算法,包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。

冒泡排序冒泡排序是一种简单直观的排序算法。

它通过多次比较和交换相邻元素的方式,将较大(或较小)的元素逐渐交换至数组的一端,从而达到排序的目的。

选择排序选择排序是一种简单且高效的排序算法。

它通过每次选择未排序部分的最小元素,并将其交换至已排序部分的末尾,从而逐步构建有序序列。

插入排序插入排序是一种自然而然的排序算法。

它通过将待排序元素逐个插入已排序序列的正确位置,不断扩大已排序部分的范围,从而完成排序。

希尔排序希尔排序是一种高效的插入式排序算法。

它通过将待排序元素分组,分组内进行插入排序,然后逐步减小分组的大小,以达到整体有序的目的。

归并排序归并排序是一种高效且稳定的排序算法。

它将已排序的子序列合并,不断递归地执行该操作,直到合并整个序列,从而实现排序。

快速排序快速排序是一种高效的分治排序算法。

它通过选择一个基准元素,将序列分割成两部分,并分别对这两部分进行排序,最终将序列有序地整合起来。

堆排序堆排序是一种高效且稳定的排序算法。

它利用堆这种特殊的数据结构,在每次构建堆过程中,获取最大(或最小)元素,并将其放入已排序部分的末尾,从而完成排序。

计数排序计数排序是一种非比较性的排序算法。

它通过统计每个元素出现的次数,计算每个元素应该在有序序列中的位置,从而完成排序。

桶排序桶排序是一种高效的排序算法。

它通过将元素分配到不同的桶中,并对每个桶进行排序,从而得到排序结果。

基数排序基数排序是一种高效的排序算法。

它通过将待排序元素按照个位、十位、百位等进行排序,最终得到有序序列。

结语头歌数据结构十大经典排序算法是计算机科学中不可或缺的内容。

计算机十大经典算法

计算机十大经典算法

计算机十大经典算法计算机科学领域有许多经典的算法,这些算法在解决各种问题时起到了重要的作用。

本文将介绍十大经典算法,分别是:二分查找算法、冒泡排序算法、选择排序算法、插入排序算法、快速排序算法、归并排序算法、堆排序算法、动态规划算法、贪心算法和图的深度优先搜索算法。

一、二分查找算法二分查找算法是一种在有序数组中查找目标元素的算法。

该算法的基本思想是将数组分为两部分,然后判断目标元素在哪一部分中,继续在该部分中进行二分查找,直到找到目标元素或者确定目标元素不存在。

二、冒泡排序算法冒泡排序算法是一种简单的排序算法,它重复地遍历要排序的数组,每次比较相邻的两个元素,如果它们的顺序错误就交换它们,直到没有任何一对元素需要交换为止。

三、选择排序算法选择排序算法是一种简单的排序算法,它每次从待排序的数组中选择最小的元素,并将其放到已排序数组的末尾,直到所有元素都排序完成。

四、插入排序算法插入排序算法是一种简单直观的排序算法,它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

五、快速排序算法快速排序算法是一种高效的排序算法,它的基本思想是通过一趟排序将待排序的数组分割成两部分,其中一部分的所有元素都比另一部分的所有元素小,然后再按此方法对两部分进行快速排序,整个过程递归进行,直到整个数组有序。

六、归并排序算法归并排序算法是一种稳定的排序算法,它的基本思想是将待排序的数组不断地划分为更小的数组,直到每个小数组只有一个元素,然后将这些小数组两两合并,直到合并成一个有序的数组。

七、堆排序算法堆排序算法是一种利用堆的数据结构进行排序的算法,它的基本思想是将待排序的数组构造成一个大顶堆或小顶堆,然后依次取出堆顶元素并调整堆,直到所有元素都被取出,最后得到一个有序的数组。

八、动态规划算法动态规划算法是一种解决多阶段决策过程最优化的算法,它的基本思想是将原问题拆分成多个子问题,通过求解子问题的最优解来求解原问题的最优解。

计算机经典算法的有趣故事

计算机经典算法的有趣故事

计算机经典算法的有趣故事在计算机科学领域中,有一些经典算法以其高效性和普适性而闻名。

这些算法背后往往有着有趣的故事,让人了解到它们的起源和发展的奇妙之处。

一个著名的经典算法是快速排序算法。

这个算法是由英国计算机科学家查尔斯·安东尼·理查德·霍尔提出的,并在1962年刊登在《计算机通信与信息处理》杂志上。

故事中,霍尔当时正在大规模数据排序的研究中苦苦挣扎。

最初,他的排序算法是相当慢的,但是在一次意外的灵感中,他发现了一种基于分治法的排序方法。

就这样,快速排序算法诞生了,并迅速成为了最常用的排序算法之一。

另一个经典算法是二分查找算法。

这个算法的故事可以追溯到古代的埃及。

据说,在公元前12世纪的古埃及,一位名叫阿赫梅斯的数学家提出了一种神奇的算法,用于快速查找一本著名的历法书。

这个算法后来被称为二分查找算法,因为它的基本思想是将待查找的区间不断二分,从而快速找到目标值。

尽管阿赫梅斯的算法被用于历法书的查找,但它的精髓和思想一直流传到现代计算机科学中。

还有一个广为人知的经典算法是迪杰斯特拉算法,用于解决图中最短路径问题。

这个算法的故事可以追溯到荷兰的一位计算机科学家艾兹赫尔·迪杰斯特拉。

迪杰斯特拉在1956年提出了一种解决荷兰铁路线路规划问题的算法。

他的算法基于图论和优先队列的概念,能够高效地找到两点之间最短路径。

迪杰斯特拉的这一工作被广泛应用于网络路由和导航系统中,成为了解决最短路径问题的经典算法。

这些经典算法的故事向我们展示了计算机科学的发展历程,以及伟大科学家们的智慧和创新能力。

它们的存在不仅使计算机应用领域得以高效发展,也使我们对计算机和算法有了更深的理解。

相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

高快省的排序算法
有没有既不浪费空间又可以快一点的排序算法呢?那就是“快速排序”啦!光听这个名字是不是就觉得很高端呢。

假设我们现在对“6 1 2 7 9 3 4 5 10 8”这个10个数进行排序。

首先在这个序列中随便找一个数作为基准数(不要被这个名词吓到了,就是一个用来参照的数,待会你就知道它用来做啥的了)。

为了方便,就让第一个数6作为基准数吧。

接下来,需要将这个序列中所有比基准数大的数放在6的右边,比基准数小的数放在6的左边,类似下面这种排列:
3 1 2 5
4 69 7 10 8
在初始状态下,数字6在序列的第1位。

我们的目标是将6挪到序列中间的某个位置,假设这个位置是k。

现在就需要寻找这个k,并且以第k位为分界点,左边的数都小于等于6,右边的数都大于等于6。

想一想,你有办法可以做到这点吗?
排序算法显神威
方法其实很简单:分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。

先从右往左找一个小于6的数,再从左往右找一个大于6的数,然后交换他们。

这里可以用两个变量i和j,分别指向序列最左边和最右边。

我们为这两个变量起个好听的名字“哨兵i”和“哨兵j”。

刚开始的时候让哨兵i指向序列的最左边(即
i=1),指向数字6。

让哨兵j指向序列的最右边(即=10),指向数字。

首先哨兵j开始出动。

因为此处设置的基准数是最左边的数,所以需要让哨兵j先出动,这一点非常重要(请自己想一想为什么)。

哨兵j一步一步地向左挪动(即j--),直到找到一个小于6的数停下来。

接下来哨兵i再一步一步向右挪动(即i++),直到找到一个数大于6的数停下来。

最后哨兵j停在了数字5面前,哨兵i停在了数字7面前。

现在交换哨兵i和哨兵j所指向的元素的值。

交换之后的序列如下:
6 1 2 59 3 4 710 8
到此,第一次交换结束。

接下来开始哨兵j继续向左挪动(再友情提醒,每次必须是哨兵j先出发)。

他发现了4(比基准数6要小,满足要求)之后停了下来。

哨兵i也继续向右挪动的,他发现了9(比基准数6要大,满足要求)之后停了下来。

此时再次进行交换,交换之后的序列如下:
6 1 2 5 4 3 9
7 10 8
第二次交换结束,“探测”继续。

哨兵j继续向左挪动,他发现了3(比基准数6要小,满足要求)之后又停了下来。

哨兵i继续向右移动,糟啦!此时哨兵i和哨兵j相遇了,哨兵i和哨兵j都走到3面前。

说明此时“探测”结束。

我们将基准数6和3进行交换。

交换之后的序列如下:
3 1 2 5
4 69 7 10 8
到此第一轮“探测”真正结束。

此时以基准数6为分界点,6左边的数都小于等于6,6右边的数都大于等于6。

回顾一下刚才的过程,其实哨兵j的使命就是要找小于基准数的数,而哨兵i的使命就是要找大于基准数的数,直到i和j碰头为止。

OK,解释完毕。

现在基准数6已经归位,它正好处在序列的第6位。

此时我们已经将原来的序列,以6为分界点拆分成了两个序列,左边的序列是“3 1 2 5 4”,右边的序列是“9 7 10 8”。

接下来还需要分别处理这两个序列。

因为6左边和右边的序列目前都还是很混乱的。

不过不要紧,我们已经掌握了方法,接下来只要模拟刚才的方法分别处理6左边和右边的序列即可。

现在先来处理6左边的序列现吧。

左边的序列是“3 1 2 5 4”。

请将这个序列以3为基准数进行调整,使得3左边的数都小于等于3,3右边的数都大于等于3。

好了开始动笔吧
如果你模拟的没有错,调整完毕之后的序列的顺序应该是:
2 1
3 5 4
OK,现在3已经归位。

接下来需要处理3左边的序列“2 1”和右边的序列“5 4”。

对序列“2 1”以2为基准数进行调整,处理完毕之后的序列为“1 2”,到此2已经归位。

序列“1”只有一个数,也不需要进行任何处理。

至此我们对序列“2 1”已全部处理完毕,得到序列是“1 2”。

序列“5 4”的处理也仿照此方法,最后得到的序列如下:
1 2 3 4 5 6 9 7 10 8
对于序列“9 7 10 8”也模拟刚才的过程,直到不可拆分出新的子序列为止。

最终将会得到这样的序列,如下
1 2 3 4 5 6 7 8 9 10
到此,排序完全结束。

细心的同学可能已经发现,快速排序的每一轮处理其实就是将这一轮的基准数归位,直到所有的数都归位为止,排序就结束了。

下面上个霸气的图来描述下整个算法的处理过程。

这是为什么呢?
快速排序之所比较快,因为相比冒泡排序,每次交换是跳跃式的。

每次排序的时候设置一个基准点,将小于等于基准点的数全部放到基准点的左边,将大于等于基准点的数全部放到基准点的右边。

这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换,交换的距离就大的多了。

因此总的比较和交换次数就少了,速度自然就提高了。

当然在最坏的情况下,仍可能是相邻的两个数进行了交换。

因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N2),它的平均时间复杂度为O(NlogN)。

其实快速排序是基于一种叫做“二分”的思想。

我们后面还会遇到“二分”思想,到时候再聊。

先上代码,如下
1.#include <stdio.h>
2.int a[101],n;//定义全局变量,这两个变量需要在子函数中使用
3.void quicksort(int left,int right)
4.{
5.int i,j,t,temp;
6.if(left>right)
7.return;
8.
9. temp=a[left]; //temp中存的就是基准数
10. i=left;
11. j=right;
12.while(i!=j)
13. {
14.//顺序很重要,要先从右边开始找
15.while(a[j]>=temp && i<j)
16. j--;
17.//再找右边的
18.while(a[i]<=temp && i<j)
19. i++;
20.//交换两个数在数组中的位置
21.if(i<j)
22. {
23. t=a[i];
24. a[i]=a[j];
25. a[j]=t;
26. }
27. }
28.//最终将基准数归位
29. a[left]=a[i];
30. a[i]=temp;
31.
32. quicksort(left,i-1);//继续处理左边的,这里是一个递归的过程
33. quicksort(i+1,right);//继续处理右边的,这里是一个递归的过程
34.}
35.int main()
36.{
37.int i,j,t;
38.//读入数据
39. scanf("%d",&n);
40.for(i=1;i<=n;i++)
41. scanf("%d",&a[i]);
42. quicksort(1,n); //快速排序调用
43.
44.//输出排序后的结果
45.for(i=1;i<=n;i++)
46. printf("%d ",a[i]);
47. getchar();getchar();
48.return 0;
49.}
可以输入以下数据进行验证
1061279345108
运行结果是
12345678910
涨姿势环节
快速排序由 C. A. R. Hoare(东尼霍尔,Charles Antony Richard Hoare)在1960年提出,之后又有许多人做了进一步的优化。

如果你对快速排序感兴趣可以去看看东尼霍尔1962年在Computer Journal发表的论文“Quicksort”以及《算法导论》的第七章。

快速排序算法仅仅是东尼霍尔在计算机领域才能的第一次显露,后来他受到了老板的赏识和重用,公司希望他为新机器设计一个新的高级语言。

你要知道当时还没有PASCAL或者C语言这些高级的东东。

后来东尼霍尔参加了由Edsger Wybe Dijkstra(1972年图灵奖得主,这个大神我们后面还会遇到的到时候再细聊)举办的“ALGOL 60”培训班,他觉得自己与其没有把握去设计一个新的语言,还不如对现有的“ALGOL 60”进行改进,使之能在公司的新机器上使用。

于是他便设计了“ALGOL 60”的一个子集版本。

这个版本在执行效率和可靠性上都在当时“ALGOL 60”的各种版本中首屈一指,因此东尼霍尔受到了国际学术界的重视。

后来他在“ALGOL X”的设计中还发明了大家熟知的“case”语句,后来也被各种高级语言广泛采用,比如PASCAL、C、Java语言等等。

当然,东尼霍尔在计算机领域的贡献还有很多很多,他在1980年获得了图灵奖。

相关文档
最新文档