快速排序

package Algorithm ; public class Day1218 { public static void quickSort ( int [ ] arr , int low , int high ) { if ( low >= high ) { return ; } int key = arr [ low ] , temp ; int start = low , end = high ; while ( start < end ) { while ( start < end && key <= arr [ end ] ) { end -- ; } if ( start < end ) { temp = arr [ end ] ; arr [ end ] = arr [ start ] ; arr [ start ] = temp ; } while ( start < end && key >= arr [ start ] ) { start ++ ; } if ( start < end ) { temp = arr [ end ] ; arr [ end ] = arr [ start ] ; arr [ start ] = temp ; } } //这时候start和end是一样的，指向同一个数 quickSort ( arr , low , start -

快速排序 快速排序的基本思想是 1、先从数列中取出一个数作为基准数 2、分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边 3、再对左右区间重复第二步，直到各区间只有一个数 概括来说为 挖坑填数+分治法 下面举例来进行说明，主要有三个参数，i为区间的开始地址，j为区间的结束地址，X为当前的开始的值 第一步，i=0,j=9,X=21 0 1 2 3 4 5 6 7 8 9 21 32 43 98 54 45 23 4 66 86 第二步，从j开始由，后向前找，找到比X小的第一个数a[7]=4,此时i=0,j=6,X=21 进行替换 0 1 2 3 4 5 6 7 8 9 4 32 43 98 54 45 23 21 66 86 第三步，由前往后找，找到比X大的第一个数a[1]=32,此时i=2,j=6,X=21 0 1 2 3 4 5 6 7 8 9 4 21 43 98 54 45 23 32 66 86 第四步，从j=6开始由，由后向前找，找到比X小的第一个数a[0]=4,此时i=2,j=0,X=21，发现j<=i,所以第一回结束 可以发现21前面的数字都比21小，后面的数字都比21大 接下来对两个子区间[0,0]和[2,9]重复上面的操作即可 下面直接给出过程，就步详细解说了 i=2,j=6,X=43 0 1 2 3 4 5 6 7 8 9 4 21 43

前言 快速排序（Quick Sort）算法和冒泡排序算法类似，都是基于交换排序的思想。快速排序算法对冒泡排序算法进行了改进，从而具有更高的执行效率。而且也是面试常考的一种算法，不仅得会写，更主要的是理解其中的思想。 快速排序的流程 （1）首先设定一个分界值，通过该分界值将数组分为左右两部分 （2）将大于等于分界值的数据集中到数组的右边，小于分界值的数据集中到数组的左边，此时左边部分中各元素都小于等于分界值，右边部分中各元素都大于分界值 （3）然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样将左边放置较小值，右边放置较大值。右侧的数组也做类似处理。 （4）重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好后，再递归排好右侧部分的顺序。当左、右两部分各数据排序完成后，整个数组的排序也就完成了 详细代码 上面的流程，一般看完后会懵懵懂懂，结合下面的代码，然后慢慢理解 public class MyQuickSort { static final int SIZE = 18; /** * @param arr 待排序的数组 * @param left 数组的左边界(例如，从起始位置开始排序，则left=0) * @param right 数组的右边界(例如，排序截至到数组末尾，则right=arr.length-1)

从待排序列中挑出一个元素，作为"基准"(pivot)，通过一趟排序，把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。对前后两个区间重复此操作，直到前后分区的带下是0或1结束。每一次都确定待排序列中一个元素的位置。 def QuickSort(input_list, left, right): def Divsion(input_list, left, right): # pivot为基准 # pivot = input_list[left] while left < right: while left <right and input_list[right] >= input_list[left]: right -= 1 # 找到一个元素小于基准元素，则把该元素放在前面 t=input_list[left] input_list[left] = input_list[right] input_list[right]=t while left < right and input_list[left] <= input_list[right]: left += 1 # 找到一个元素大于基准元素，则把该元素放到后面 t = input_list[right] input_list[right] =

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括 关于时间复杂度： 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序。 O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序。 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。 关于稳定性： 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。 名词解释： n：数据规模 k：“桶”的个数 In-place：占用常数内存，不占用额外内存 Out-place：占用额外内存 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同 冒泡排序 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

qsort函数应用（快速排序） 示例 # include <stdio.h> # include <stdlib.h> # include <string.h> # define N 5 void show ( char name [ N ] [ 20 ] ) ; int compare ( const void * , const void * ) ; int main ( ) { char name [ N ] [ 20 ] = { "CCC" , "AAA" , "FFF" , "DDD" , "EEE" } ; qsort ( name , sizeof ( name ) / sizeof ( name [ 0 ] ) , sizeof ( name [ 0 ] ) , compare ) ; show ( name ) ; return 0 ; } void show ( char name [ N ] [ 20 ] ) { for ( int i = 0 ; i < N ; i ++ ) { printf ( "%s\n" , name [ i ] ) ; } } int compare ( const void * p1 , const void * p2 ) { const char * q1 = ( char * ) p1 ; const char * q2 =

题目链接 快速排序的模板： # include <iostream> using namespace std ; const int N = 1e5 ; int q [ N ] ; int n ; void quick_sort ( int q [ ] , int l , int r ) { if ( l >= r ) return ; int x = q [ l + r >> 1 ] ; int i = l - 1 , j = r + 1 ; while ( i < j ) { while ( q [ ++ i ] < x ) ; while ( q [ -- j ] > x ) ; if ( i < j ) swap ( q [ i ] , q [ j ] ) ; } quick_sort ( q , l , j ) ; quick_sort ( q , j + 1 , r ) ; } int main ( ) { cin >> n ; for ( int i = 0 ; i < n ; i ++ ) scanf ( "%d" , & q [ i ] ) ; quick_sort ( q , 0 , n - 1 ) ; for ( int i = 0 ; i < n ; i ++ ) printf ( "%d " , q [ i ] ) ; return 0 ; } 来源：

5、冒泡排序、二分查找 a) 冒泡 public static void mp(int a[]) { int swap = 0; for (int i = 0; i < a.length; i++) { for (int j = i; j < a.length; j++) { if (a[j] > a[i]) { swap = a[i]; a[i] = a[j]; a[j] = swap; } } } System. out .println(Arrays. toString (a)); } b)二分查找public static int ef(int a[], int tag) { int first = 0; int end = a.length; for (int i = 0; i < a.length; i++) { int middle = (first + end) / 2; if (tag == a[middle]) { return middle; } if (tag > a[middle]) { first = middle + 1; } if (tag < a[middle]) { end = middle - 1; } } return 0; } 　 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来

快速排序 http://m.blog.csdn.net/blog/u013071074/36867589 快速排序是由 C. A. R. Hoare所发展的一种排序算法。其基本思想是基本思想是， 通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。 快速排序使用分治法来把一个串（list）分为两个子串行（sub-lists）。 步骤为： 1、从数列中挑出一个元素，称为 "基准"（pivot）， 2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。 3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 最差时间复杂度：O(n^2) 最优时间复杂度：O(n log n) 平均时间复杂度：O(n log n) 最差空间复杂度：根据实现的方式不同而不同 算法理解 此排序算法， 思想是分治和筛选： 选择一个元素作为分割点， 将链表中分割成两个部分， 第一部分（比分割点小的部分）， 第二部分（比分割点大的部分） 所以整个链表分为三个部分： 分割点、 第一部分、第二部分。 然后对于第一部分 和 第二部分， 分别执行此筛选方法

< ! DOCTYPE html > < html > < head > < meta charset = "utf-8" > < title > Sort_echarts < /title > < script src = "echarts.js" > < /script > < /head > < body > < div id = "main" style = "width: 1000px;height:600px;margin:0px auto" > < /div > < div id = "demo" style = "width: 100px;height:36px;margin:0px auto;text-align: center;font-weight: bold;font-family: 微软雅黑;font-size: 14px" > < /div > < center > < button id = "but" type = "button" onClick = "showtext();run()" style = "width:74px;height:36px;font-weight: bold;font-family: 微软雅黑;font-size: 14px;border-radius: 28px; background-color: #AAAAAA"