快速排序一种易于理解的方式实现

看来网上的一些快速排序的例子，发现好多都是代码比较多且不好理解，所以想自己总结一遍这样的博文

来分析快速排序，贴出了java实现的代码，用其他语言实现只要稍作修改就行。

s[]={48,89,34,55,11,56,89,96,10};

以数组s[]为实例来剖析快速排序代码的原理：

数组的初始太：选48做基准数，对数组进行填坑挖数操作
X=s[0],i=0,j=8

48

89

34

55

11

56

89

96

10

2.从最右边开始向左找一个小于48的数，并在此处挖一个坑(挖坑处用红色的00表示)

X=48，i=0, j=8

将a[j]的值填到a[i]处(a[i]=a[j])，并在i处挖一个坑(挖坑处用红色00表示)

10

89

34

55

11

56

89

96

00

3.从最左边开始向右找一个大于48的数

X=48，i=1, j=8

将a[i]的值填到a[j]处(a[j]=a[i])，并在i处挖一个坑(挖坑处用红色00表示)

10

00

34

55

11

56

89

96

89

类似的进行步骤2，后得

X=48，i=1, j=4

10

11

34

55

00

56

89

96

89

类似的进行步骤3，后得

X=48，i=3, j=4

10

11

34

00

55

56

89

96

89

再进行2步骤发现i=j=3,令a[3]=48;得数组

10

11

34

48

55

56

89

96

89

此时对数组：使用分治法思想（观察数组知道，经过填坑挖数操作后的数组有以下特征：

以48为分界线，48左边的数都小于48，48右边的数都大于48）

将数组分为

10

11

34

和

55

56

89

96

89

，然后对两个子数组分而治之：就是对子数组分别做填坑挖数的操作，之后又会产生4个子数组，

直到子数组子只含有一个元素，停止划分。（很容易看出子数组和原数组都在调用填坑挖数的
操作，从而看出这里有一个递归的思想，所以想到递归的办法）

/**

* @author 源泉之志
* 快速排序：填坑挖数+分治法
* 快速排序一种易于理解的方式实现
* Divide-and-ConquerMethod
*
*/
public class QuickSort {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

int s[]={48,89,34,55,11,56,89,96,2};
QuickSort qs = new QuickSort();
qs.quick_sort(s, 0, s.length-1);
System.out.println("输出数组");
for(int i=0;i<s.length;i++){
System.out.print(s[i]+" ");
}
}

/**
* 填坑挖数的代码
* @param s
* @param l
* @param r
* int i=l,  j=r;
* 1.选一个基准量，X=s[i]
* 2.从s[j]处开始从右往左找，找到第一个小于X的值，找到后把s[j]的值赋给s[i]
* 3.从s[i]处开始从左往右找，找到第一个小于X的值，找到后把s[i]的值赋给s[j]
* @return
*/
int addjustArray(int s[],int l,int r){
int i = l, j=r;
int x = s[i];
while(i<j){
while(i<j&&s[j]>=x){
j--;
}
if(i<j){
s[i]=s[j];
i++;
}
while(i<j&&s[i]<=x){
i++;
j--;
}
if(i<j){
s[j]=s[i];
}
}
s[i]=x;

return i;
}

/**
* @param s
* @param l
* @param r
* 分治法:
* 把一个数组以某个基准数做为界线，然后把数组一分为二 ，在把两个子数组都一分为二
* 当每个子数组都为一个元素时，不能在分，递归结束
*/
void divide_and_conquer(int s[],int l,int r){
if(l<r){
int i = addjustArray(s, l, r);
addjustArray(s,l,i-1);
addjustArray(s, i+1, r);
}
}

/**
* 快速排序正是应用这种：填坑挖数+分之法的思想
* 1.选一个基准量，X=s[i]
* 2.从s[j]处开始从右往左找，找到第一个小于X的值，找到后把s[j]的值赋给s[i]
* 3.从s[i]处开始从左往右找，找到第一个小于X的值，找到后把s[i]的值赋给s[j]
*
* 然后循环调用2，3步骤
* @param s
* @param l
* @param r
*/
void quick_sort(int s[],int l,int r){
if(l<r){
int i=l;int j=r;
int x = s[l];
while(i<j){
while(i<r&&s[j]>=x){
j--;
}
if(i<j){
s[i]=s[j];
i++;
}
while(i<j&&s[i]<=x){
i++;
}
if(i<j){
s[j]=s[i];
j--;
}
}
s[i]=x;
quick_sort(s, j, i-1);
quick_sort(s, i+1, r);
}
}
}

这是直接插入排序算法，实现原理很简单，不用细讲

package com.my.lianxi;

public class InsertionSort {

/**
* @param args
* 插入排序算法（又称直接插入排序）
* 插入排序原理：
* 插入排序有点像摸牌   ，桌子上有n张牌背面朝上， 每次拿一张牌到手中， 当手中只有一张牌时它肯定
* 是手上最小的牌，当摸起第二张牌，用第二张牌和第一张比较，如果比第一张小则交换第二张牌的位置，
* 如果大于第一张牌则不交换，直接插在第一张牌的右边，当摸起第三张牌时先和前两张排好序的牌中的
* 第二张比较，如果发现比第二张小则和第二张交换位置，并继续和第一张比较，如果比第一张也小则和
* 第一张在交换位置，依次类推，当摸到第n张牌时和手上已经排好序的n-1张牌比较，找到第n张牌的
* 所需插入的位置，这样一次插入排序完成！
* @author yuzhihua
*/
public static void main(String[] args){
int a[] = {34,12,25,54,23,66,11,89,0,90};
int j=1;
while(j<10){
for(int i=j-1;i>=0;i--){
if(a[i+1]<=a[i]){
int temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}else{
break;
}
}
j++;
}
System.out.println("输出插入排序后的数组:");
for(int i=0;i<10;i++){
System.out.print(a[i]+" ");
}
}
}