学习笔记：快速排序的C++、JavaScript（2种方法）、Java实现

快速排序的C++、JavaScript（2种方法）、Java实现

快速排序思想：
（1）在数据集之中，选择一个元素作为”基准”（pivot）。
（2）所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。
（3）对”基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

（1）C++实现

#include <iostream>
using namespace std;

int partition(int r[], int left, int right) {
    int i = left;
    int j = right;
    int temp;
    while (i < j) {
        while (i < j && r[i] <= r[j]) { //扫描右侧，直到找出一个比r[i]小的数
            j--;
        }
        if (i < j) {
            temp = r[i];
            r[i] = r[j];
            r[j] = temp;
            i++;
        }
        while (i < j && r[i] <= r[j]) { //扫描左侧，直到找出一个比r[j]大的数
            i++;
        }
        if (i < j) {
            temp = r[i];
            r[i] = r[j];
            r[j] = temp;
            j--;
        }
    }
    return i;
}

void quickSort(int r[], int left, int right) {
    if (left < right) {
        int pivot = partition(r, left, right);
        quickSort(r, left, pivot-1);
        quickSort(r, pivot+1, right);
    }
}

int main()
{
    int a[] = {23, 13, 49, 6, 31, 19, 28};
    int len = sizeof(a) / sizeof(int);
    quickSort(a, 0, len-1);
    for (int i = 0; i < len; i++){
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}
// 输出 6 13 19 23 28 31 49

（2）Javascript实现

Javascript有2种方法来实现快速排序，一种是把上面C++版的搬到JavaScript来

function quickSort(a) {
    var partition = function(a, left, right) {
        var i = left;
        var j = right;
        var temp;
        while (i < j) {
            while (i < j && a[i] <= a[j]) {
                j--;
            }
            if (i < j) {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
                i++;
            }
            while (i < j && a[i] <= a[j]) {
                i++;
            }
            if (i < j) {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
                j--;
            }
        }
        return i;
    }
    var left, right;
    if (arguments.length == 1) {
        left = 0;
        right = a.length - 1;
    } else {
        left = arguments[1];
        right = arguments[2];
    }
    if (left < right) {
        var pivot = partition(a, left, right);
        quickSort(a, left, pivot - 1);
        quickSort(a, pivot + 1, right);
    }
}

另一种是在阮一峰的博客上看到的，简单容易理解，链接：
http://www.ruanyifeng.com/blog/2011/04/quicksort_in_javascript.html

function quickSort(a) {
    if (a.length <= 1) {
        return a;  //这个很重要，用来结束递归
    }
    var pivotIndex = parseInt(a.length / 2);  //定义基准元素下标
    var pivot = a.splice(pivotIndex, 1)[0];  //定义基准元素的值，并在原数组中删除它
    var left = [];
    var right = [];
    for (var i = 0; i < a.length; i++) {
        if (a[i] > pivot) {
            right.push(a[i]);
        } else {
            left.push(a[i]);
        }
    }
    return quickSort(left).concat(pivot,quickSort(right));  //返回左边加上基准元素加上右边组成的数组
}

var a = [5, 2, 6, 3, 1, 4, 8, 7];
console.log(quickSort(a));
//输出 [1, 2, 3, 4, 5, 6, 7, 8]

（3）Java实现

public class Test {
    public static void main(String[] args) {
        int[] a = { 5, 9, 3, 7, 2, 8, 45, 20, 44 };
        quickSort(a, 0, a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    private static int partition(int[] a, int left, int right) {
        int i = left;
        int j = right;
        int temp;
        while (i < j) {
            while (i < j && a[i] <= a[j]) {
                j--;
            }
            if (i < j) {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
                i++;
            }
            while (i < j && a[i] <= a[j]) {
                i++;
            }
            if (i < j) {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
                j--;
            }
        }
        return i;
    }

    private static void quickSort(int[] a, int left, int right) {
        if (left < right) {
            int pivot = partition(a, left, right);
            quickSort(a, left, pivot - 1);
            quickSort(a, pivot + 1, right);
        }
    }
}
// 输出 2 3 5 7 8 9 20 44 45