"快速排序"的思想很简单，整个排序过程只需要三步：
　　（1）在数据集之中，找一个基准点
　　（2）建立两个数组，分别存储左边和右边的数组
　　（3）利用递归进行下次比较
    [removed]
        function quickSort(arr){
            if(arr.length<=1){
                return arr;//如果数组只有一个数，就直接返回；
            }
            var num = Math.floor(arr.length/2);//找到中间数的索引值，如果是浮点数，则向下取整
            var numValue = arr.splice(num,1);//找到中间数的值
            var left = [];
            var right = [];
            for(var i=0;i
                if(arr  
                    left.push(arr  );//基准点的左边的数传到左边数组
                }
                else{
                   right.push(arr  );//基准点的右边的数传到右边数组
                }
            }
            return quickSort(left).concat([numValue],quickSort(right));//递归不断重复比较
        }
        alert(quickSort([32,45,37,16,2,87]));//弹出“2,16,32,37,45,87”
    [removed]

1、算法思想

    　快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

（1） 分治法的基本思想

    　分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

（2）快速排序的基本思想

    　设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：

①分解： 

    　在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。

  注意：

    　划分的关键是要求出基准记录所在的位置pivotpos。划分的结果可以简单地表示为(注意pivot=R[pivotpos])：

    　R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys

                  其中low≤pivotpos≤high。

②求解： 

   　 通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。

③组合： 

    　因为当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言，"组合"步骤无须做什么，可看作是空操作。

2、快速排序算法QuickSort

  void QuickSort(SeqList R，int low，int high)

   { //对R[low..high]快速排序

     int pivotpos； //划分后的基准记录的位置

     if(low

        pivotpos=Partition(R，low，high)； //对R[low..high]做划分

        QuickSort(R，low，pivotpos-1)； //对左区间递归排序

        QuickSort(R，pivotpos+1，high)； //对右区间递归排序

      }

    } //QuickSort

#include

int a[101],n;//定义全局变量，这两个变量需要在子函数中使用

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>

    {

    t = a[i];

    a[i] = a[j];

    a[j] = t;

    }

    }

"快速排序"的思想很简单，整个排序过程只需要三步：
　　（1）在数据集之中，找一个基准点
　　（2）建立两个数组，分别存储左边和右边的数组
　　（3）利用递归进行下次比较
    [removed]
        function quickSort(arr){
            if(arr.length<=1){
                return arr;//如果数组只有一个数，就直接返回；
            }
            var num = Math.floor(arr.length/2);//找到中间数的索引值，如果是浮点数，则向下取整
            var numValue = arr.splice(num,1);//找到中间数的值
            var left = [];
            var right = [];
            for(var i=0;i
                if(arr  
                    left.push(arr  );//基准点的左边的数传到左边数组
                }
                else{
                   right.push(arr  );//基准点的右边的数传到右边数组
                }
            }
            return quickSort(left).concat([numValue],quickSort(right));//递归不断重复比较
        }
        alert(quickSort([32,45,37,16,2,87]));//弹出“2,16,32,37,45,87”
    [removed]