快速排序

冒泡排序的执行效率太低，因为每次比较相邻的两个数，所以时间复杂度为O(N²），花费的时间太长，所以为了更加的节省时间，提高程序的运行速率，我们可以采用快速排序。对于一个数集，先把第一个数当作基准数，然后分别从最右端和最左端向另一方向进行搜索，（以从小到大的顺序为例）从右向左搜索的，遇到比基准数小的与从左向右搜索的比基准数大的进行交换，直到两端进行查找的到达同一位置时将此处的数和基准数进行交换位置，其次从这个位置上，把这个数集分为两个部分再次进行这样的排序。其过程如下： 其代码如下： # include <stdio.h> using namespace std ; int a [ 101 ] ; void quicksort ( int left , int right ) { int i , j , t , temp ; if ( left > right ) return ; temp = a [ left ] ; //temp所储存的就是基准数 i = left ; j = right ; while ( i != j ) { //顺序一定要先从右向左找 while ( a [ j ] >= temp && i < j ) //从右到左查询 j -- ; while ( a [ i ] <= temp && i < j ) //从左到右查询 i ++ ; if ( i < j

# include <iostream> using namespace std ; int n , a [ 1000001 ] ; void qsort ( int l , int r ) //应用二分思想 { int mid = a [ ( l + r ) / 2 ] ; //中间数 int i = l , j = r ; do { while ( a [ i ] < mid ) i ++ ; //查找左半部分比中间数大的数 while ( a [ j ] > mid ) j -- ; //查找右半部分比中间数小的数 if ( i <= j ) //如果有一组不满足排序条件（左小右大）的数 { swap ( a [ i ] , a [ j ] ) ; //交换 i ++ ; j -- ; } } while ( i <= j ) ; //这里注意要有= if ( l < j ) qsort ( l , j ) ; //递归搜索左半部分 if ( i < r ) qsort ( i , r ) ; //递归搜索右半部分 } int main ( ) { cin >> n ; for ( int i = 1 ; i <= n ; i ++ ) cin >> a [ i ] ; qsort ( 1 , n ) ; for ( int i = 1 ; i <= n ; i ++ )

快速排序的思路是：把序列分成左、右两部分，使得左边所有的数比右边所有的数小；递归这个过程，直到不能再分为止。 直接在原序列上进行划分： 尾部t是基准数，i指向比t小的左部分，j指向比t大的右部分 若data[j]大于等于data[t],j++; 3. 若data[j]<data[t],交换，然后i++,j++; 4. 重复上述步骤 5. 最后交换data[i]和data[t],得到结果。i指向基准数的当前位置 随机给n个数，进行快速排序 # include <iostream> const int N = 10005 ; int data [ N ] ; # define swap(a,b){int t=a;a=b;b=t;} using namespace std ; int partition ( int left , int right ) { //划分成左右两部分，以i指向的数为界 int i = left ; int t = data [ right ] ; //把尾部的数看成基准数 for ( int j = left ; j < right ; j ++ ) { if ( data [ j ] < t ) { swap ( data [ j ] , data [ i ] ) ; i ++ ; } } swap ( data [ i ] , data [ right ]

概述 最近在温习数据结构，现在针对排序算法写一篇随笔，其中附带原理说明和代码。 插入排序 直接插入排序(Straight Insertion Sort)的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次 从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。 假设{20,30,40,10,60,50}中的前3个数已经排列过，是有序的了；接下来对10进行排列。示意图如下： 图中将数列分为有序区和无序区。我们需要做的工作只有两个：(1)取出无序区中的第1个数，并找出它在有序区对应的位置。(2)将无序区的数据插入到有序区；若有必要的话，则对有序区中的相关数据进行移位。 时间复杂度和稳定性 直接插入排序的时间复杂度是O(N2)。 假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1！因此，直接插入排序的时间复杂度是O(N*N)。 直接插入排序是稳定的算法，它满足稳定算法的定义。 算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的。 插入排序JAVA实现 1 import static javaTest.SortUtils

头文件：stdlib.h 用 法：void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *)); 参数：1 待排序数组首地址 2 数组中待排序元素数量 3 各元素的占用空间大小 4 指向函数的指针，用于确定排序的顺序 # include <stdio.h> # include <stdlib.h> # include <string.h> # include <time.h> # define N 16 # define M 5 # define Q 1000 void init ( int a [ ] ) { int i ; srand ( time ( NULL ) ) ; for ( i = 0 ; i < N ; i ++ ) a [ i ] = rand ( ) % 100 ; } void show ( int a [ ] ) { int i ; for ( i = 0 ; i < N ; i ++ ) printf ( "%3d" , a [ i ] ) ; printf ( "\n" ) ; } int compare ( const void * ai , const void * aj ) { return * ( ( int * ) ai ) - * ( (

快速排序基本思想： 快速排序使用分治的思想。选取一个分界点，通过一趟排序将待排序序列分割成两部分，一部分比分界点值小，一部分比分界点值大。进而递归排序这两部分，最后使得整个序列有序。 快速排序步骤： 确定分界点。分界点的选取可以是array[left]，array[right]，array[(left + right) / 2]或在序列中随机选 取一个元素； 调整范围； 递归处理左右两段序列。 快速排序基本实现分析： 快速排序模板代码： void quick_sort(int *arr, int l, int r) { if(l >= r) return ; int x = arr[l], i = l - 1, j = r + 1; //选取左边界值为分界点x，创建i，j两个指针，使其分别指向l - 1和r + 1； while(i < j) { do i++; while(arr[i] < x); do j--; while(arr[j] > x); if(i < j) swap(&arr[i], &arr[j]); } quick_sort(arr, l, j); quick_sort(arr, j + 1, r); } 快速排序完整实现代码： #include <stdio.h> #include <stdlib.h> void swap(int *first, int

今天又看了一下快排: 实现的代码如下: import java.lang.reflect.Array; import java.util.Arrays; import java.util.Random; public class QuickSort { public static void main(String[] args) { int[] arr = new int[20]; Random rand =new Random(); for(int i=0;i<arr.length;++i) arr[i] = rand.nextInt(40); System.out.println("原数据"+Arrays.toString(arr)); quickSort(arr,0,arr.length-1); System.out.println("排序结果"+Arrays.toString(arr)); } public static void quickSort(int[] arr,int low,int high){ int i,j,temp,t; if(low>high) return; i=low; j=high; temp = arr[low];//基准数 以为例 while (i<j) { while (temp<=arr[j]&&i<j) j--;//找到比基准数小的

数据结构之排序算法——快速排序 代码很多地方借鉴了 http://my.csdn.net/MoreWindows 他的思想， 本人认为该作者已经写的很好了，只是在他的基础上加入了一些自己的理解和说明 如果涉及到版权的问题，请联系我的邮箱，我会尽快删除 希尔排序想关链接： 维基百科： https://zh.wikipedia.org/wiki/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F#C.E8.AA.9E.E8.A8.80 百度百科： http://baike.baidu.com/view/19016.htm 参考博客 ： http://blog.csdn.net/morewindows/article/details/6684558 快速排序 对大量的数据具有很好的性能， 快速排序的基本思想就是，先对数组进行从右向左的扫描，找到第一不大于当前定义的关键值数，与它进行交换，然后在从左向右进行扫描，找到第一个不小于当前关键值的数，将它们交换，然后将数据分成两个部分，前面一部分都小于关键字，后面一部分都大于关键字，然后再前后的部分继续进行前面描述的操作，这就需要递归的调用自己。 源码如下： void Quick_Sort(int array[], int arrayLen) { Sort(array, 0, arrayLen-1); } void Sort

不得不说，手写的快排真的好菜。（即使开了随机数...） 快速排序 #include<iostream> #include<cstdio> #include<cstring> #include<cstdlib> using namespace std; inline int read(); const int Maxn = 100010 ; namespace iNx{ int n; int q[Maxn]; void exchange(int a,int b){ int t=q[a]; q[a]=q[b]; q[b]=t; } void quicksort(int left,int right){ if(left>=right) return ; exchange(left,(rand()%(right-left+1))+left); int key=q[left],i=left,j=right; while(i<j){ while(q[j]>=key&&i<j) j--; if(j>i) q[i++]=q[j]; while(q[i]<=key&&i<j) i++; if(i<j) q[j--]=q[i]; } q[i]=key; quicksort(left,i-1); quicksort(i+1,right); } int main(){ n=read(); int i;

快速排序 什么是快速排序 快速排序使用 分治法 （Divide and conquer）策略来把一个序列（list）分为较小和较大的2个子序列，然后递归地排序两个子序列。 步骤为： 挑选基准值：从数列中挑出一个元素，称为“基准”（pivot）， 分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成， 递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。 递归到最底部的判断条件是数列的大小是零或一，此时该数列显然已经有序。 选取基准值有数种具体方法，此选取方法对排序的时间性能有决定性影响。 —— 维基百科 维基百科上说得很详细！ 性能分析 时间复杂度 快速排序的一次划分算法从两头交替搜索，直到 l o w low l o w 和 h i g h high h i g h 重合，因此其时间复杂度是 O ( n ) O(n) O ( n ) ；而整个快速排序算法的时间复杂度与划分的趟数有关 理想的情况是，每次划分所选择的中间数恰好将当前序列几乎等分，经过 l o g 2 n log2n l o g 2 n 趟划分，便可得到长度为1的子表。这样，整个算法的时间复杂度为 O ( n l o g 2 n ) O(nlog2n) O ( n l o g 2