用javascript实现快速排序

学习笔记，参考网站如下：
① http://zqdevres.qiniucdn.com/data/20110606230401/index.html快速排序（Quicksort）的Javascript实现作者：阮一峰
② http://www.w3school.com.cn/jsref/jsref_splice.asp JavaScript splice() 方法作者：W3shool
③ http://w3school.com.cn/jsref/jsref_floor.asp JavaScript floor() 方法作者：W3shool
④ http://www.w3school.com.cn/jsref/jsref_concat_array.asp JavaScript concat() 方法作者：W3shool

在使用javascript编写快速排序之前，您需要知道3个javascript方法。

①floor方法
用法：floor() 方法可对一个数进行下舍入。
语法：Math.floor(x)
参数：接受一个参数，任意数值或者已被赋值的表达式

console.log(Math.floor(0.3)); //0
console.log(Math.floor(0.5)); //0
console.log(Math.floor(0.7)); //0
console.log(Math.floor(0.9)); //0
console.log(Math.floor(1.1)); //1
console.log(Math.floor(1.3)); //1
console.log(Math.floor(1.5)); //1
console.log(Math.floor(1.7)); //1
console.log(Math.floor(1.9)); //1
console.log(Math.floor(2.1)); //2
console.log(Math.floor(-0.3)); //-1
console.log(Math.floor(-0.5)); //-1
console.log(Math.floor(-0.7)); //-1
console.log(Math.floor(-0.9)); //-1
console.log(Math.floor(-1.1)); //-2
console.log(Math.floor(-1.3)); //-2
console.log(Math.floor(-1.5)); //-2
console.log(Math.floor(-1.7)); //-2
console.log(Math.floor(-1.9)); //-2
console.log(Math.floor(-2.1)); //-3
console.log(Math.floor(-2)); //-2

②concat方法
用法：concat() 方法用于连接两个或多个数组。该方法不会改变原来的数组，而仅仅会返回被连接数组的一个副本。
语法：array.concat(arrayX,arrayY,......,arrayN)
参数：接受多个参数，参数可以是数组，也可以是已被赋值为数组的表达式。

var left = [1, 2, 3];
var middle = [4, 5, 6];
var right = [7, 8, 9];
console.log(left.concat()); //Array[1, 2, 3]
console.log(left.concat(middle)); //Array[1, 2, 3, 4, 5, 6]
console.log(left.concat(middle,right)); //Array[1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(left); //Array[1, 2, 3],原来的数组并没有被改变
console.log(middle); //Array[4, 5, 6],原来的数组并没有被改变
console.log(right); //Array[7, 8, 9],原来的数组并没有被改变

③splice方法
用法： splice() 方法向/从数组中添加/删除元素，然后以数组的形式返回被删除的元素。若没有删除，则返回空数组。该方法会改变原有数组。
语法：array.splice(index,howmany,item1,.....,itemX)
参数：接受多个参数。
index规定添加/删除元素在数组中的索引号，使用负数可从数组结尾处规定位置。必须使用整数，必需传入此参数。
howmany表示要删除元素数量，如果为0，表示不删除任何元素，如果为2，表示以index为起点，删除两个元素。
itemX,....,itemN，该参数可选，表示向数组中添加的新元素。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0)); //Array[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
console.log(arr); //Array[],只传一个参数的话，默认从索引开始删除所有后面的元素。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0,1)); //Array[1]
console.log(arr); //Array[2, 3, 4, 5, 6, 7, 8, 9, 10]

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0,2)); //Array[1, 2]
console.log(arr); //Array[3, 4, 5, 6, 7, 8, 9, 10]

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0,3)); //Array[1, 2, 3]
console.log(arr); //Array[4, 5, 6, 7, 8, 9, 10]

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0,0)); //Array[]
console.log(arr); //Array[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0, 1, "ZERO")); //Array[0]
console.log(arr); //Array["ZERO", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0, 2, "ZERO", "ONE")); //Array[0, 1]
console.log(arr); //Array[ZERO, ONE, 2, 3, 4, 5, 6, 7, 8, 9, 10]

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0, 3, "ZERO", "ONE", "TWO")); //Array[0, 1, 2]
console.log(arr); //Array[ZERO, ONE, TWO, 3, 4, 5, 6, 7, 8, 9, 10]

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.splice(0, 0, "ZERO", "ONE", "TWO")); //Array[0, 1, 2]
console.log(arr); //Array[ZERO, ONE, TWO, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

接下来我们就可以开始用javascript来编写快速排序（Quick Sort）了。

快速排序的思想很简单，整个排序的过程只需要三步：

① 定一个基准，其他的数与这个基准相比较
② 比基准小的挪到基准左边篮子，比基准大的挪到基准右边篮子
③ 左右篮子重复①、②步骤

具体的编写如下：

先定义一个叫做quickSort的函数，该函数接受一个类型为数组的参数。

var quickSort = function(arr){
    
};

接下来的内容都是在这个函数体内编写的，我们先要对传入的数组做一个判断，如果它只有一个数，那证明这个数组就不用排序，我们直接返回这个数组。您需要如此判断。

var quickSort = function(arr){
    if(arr.length <= 1) return arr;
};

接着让我们定义两个空数组，分别代表一左一右两个篮子：

var quickSort = function(arr){
    if(arr.length <= 1) return arr;
    var left = [];
    var right = [];
};

然后，定义一个基准，一般选择中间比较好理解，当然选在哪里都可以，我们需要把这个基准从原数组中拿出来，因此您需要知道基准在数组中的索引是多少，然后利用splice方法将它拿出。
计算基准在数组中的索引：

var quickSort = function(arr){
    if(arr.length <= 1) return arr;
    var left = [];
    var right = [];
    var pivotIndex = Math.floor(arr.length / 2);
};

将基准从数组从拿出来，并且获取基准的值。

var quickSort = function(arr){
    if(arr.length <= 1) return arr;
    var left = [];
    var right = [];
    var pivotIndex = Math.floor(arr.length / 2);
    var pivotArray = arr.splice(pivotIndex, 1);
    var pivot = pivotArray[0];
};

splice返回一个数组，这个数组里只有一个元素，索引为0，所以我们如此拿出该元素的值。

接着我们遍历数组中的所有元素，与基准比较，并且将它们放入正确的数组：

var quickSort = function(arr){
    if(arr.length <= 1) return arr;
    var left = [];
    var right = [];
    var pivotIndex = Math.floor(arr.length / 2);
    var pivotArray = arr.splice(pivotIndex, 1);
    var pivot = pivotArray[0];
    for(var i = 0; i < arr.length; i++){
        if(arr[i] < pivot){
            left.push(arr[i]);
        }
        else{
            right.push(arr[i]);
        }
    }
};

最后使用递归，重复这个过程：

var quickSort = function(arr){
    if(arr.length <= 1) return arr;
    var left = [];
    var right = [];
    var pivotIndex = Math.floor(arr.length / 2);
    var pivotArray = arr.splice(pivotIndex, 1);
    var pivot = pivotArray[0];
    for(var i = 0; i < arr.length; i++){
        if(arr[i] < pivot){
            left.push(arr[i]);
        }
        else{
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
};

让我们测试一下吧：

var arr = [9, 8, 7, 6, 5, 4, 3, 2, 1];
quickSort(arr); //Array [1, 2, 3, 4, 5, 6, 7, 8, 9]

测试通过。

用javascript实现快速排序

你可能感兴趣的:(用javascript实现快速排序)