JS数组排序方法有两个： reverse() 和 sort() ，其中 reverse() 可将数组进行倒序，而 sort() 则可将数组项灵活地进行升序或降序排列。

可以看出， reverse() 会直接改变原数组，并且返回值也是倒序后的数组。

记得当年学C语言时，要学各种各样的排序算法，比如经典的冒泡排序法、二分排序法等，现在抛开这些算法不说，JS就自带原生的排序函数，用起来非常方便，它就是 sort() 。

可以看出， sort() 不传参数时会按升序方式对数组项进行排序，并且与 reverse() 一样既改变原数组，同时返回的也是排序后的数组。

我们再来看下一个例子：

这时你可能会说，不对呀，最终排序返回的不应该是 [8, 9, 16, 90] 吗？然鹅事实返回的却是 [16, 8, 9, 90] ，这到底是哪门子逻辑？

事实上， sort() 并不是按照数值进行排序，而是按字符串字母的ASCII码值进行比较排序的，所以当数组项为数字时， sort() 也会自动先将数字转换成字符串，然后再按字母比较的规则进行排序处理。

现在我们再回头看看前面两个例子。当 arr 为 [8,4,9,1] 时，数组每一项转换成字符串后进行排序的结果正好与数字排序结果相同；而当 arr 为 [8,90,9,16] 时，数组每一项转换成字符串后就得按顺序一位一位进行比较，比如升序排序时，“16”应该排在最前面，因为“16”的第一位是“1”，比“8”和“9”的ASCII码值都要小。

啰嗦了这么多，其实我们实际很少会使用这种排序方式，而更多的应该就是纯数字的排序。那么我们该如何正确地使用 sort() 来达到预期的排序效果呢？

接下来就来看看传参后的 sort() 能给我们怎样的精彩表现。

这个函数参数功能其实很简单，实际上就是告诉 sort() 排序方式到底是升序还是降序，我们还是来看具体实例吧~

这种用法的规则是，当 sort() 传入函数中的第一个参数a位于第二个参数b之前，则返回一个负数，相等则返回0，a位于b之后则返回正数。

比如，当要做升序排序时，我们需要想到前面的数肯定是要比后面的数小，所以传入的这个函数参数返回值应该要是个负数，因此函数参数返回 a - b 。

如果实在不好理解，我们可以干脆记下来， a - b 升序， b - a 降序，但是需要注意的是，如果按照这种记忆方式的话，函数括号内的两个参数 a 和 b 的书写顺序可不能颠倒哦~

//排序算法

window.onload = function(){

    var array = [0,1,2,44,4,

                324,5,65,6,6,

                34,4,5,6,2,

                43,5,6,62,43,

                5,1,4,51,56,

                76,7,7,2,1,

                45,4,6,7,8]

    //var array = [4,2,5,1,0,3]

    array = sorting.shellSort(array)

    alert(array)

}

var sorting = {

    //利用sort方法进行排序

    systemSort: function(arr){

        return arr.sort(function(a,b){

            return a-b

        })

    },

    //冒泡排序

    bubbleSort: function(arr){

        var len=arr.length, tmp

        for(var i=0i<len-1i++){

            for(var j=0j<len-1-ij++){

                if(arr[j]>arr[j+1]){

                    tmp = arr[j]

                    arr[j] = arr[j+1]

                    arr[j+1] = tmp

                }

            }

        }

        return arr

    },

    //快速排序

    quickSort: function(arr){

        var low=0, high=arr.length-1

        sort(low,high)

        function sort(low, high){

            if(low<high){

                var mid = (function(low, high){

                    var tmp = arr[low]

                    while(low<high){

                        while(low<high&&arr[high]>=tmp){

                            high--

                        }

                        arr[low] = arr[high]

                        while(low<high&&arr[low]<=tmp){

                            low++

                        }

                        arr[high] = arr[low]

                    }

                    arr[low] = tmp

                    return low

                })(low, high)

                sort(low, mid-1)

                sort(mid+1,high)

            }

        }

        return arr

    },

    //插入排序

    insertSort: function(arr){

        var len = arr.length

        for(var i=1i<leni++){

            var tmp = arr[i]

            for(var j=i-1j>=0j--){

                if(tmp<arr[j]){

                    arr[j+1] = arr[j]

                }else{

                    arr[j+1] = tmp

                    break

                }

            }

        }

        return arr

    },

    //希尔排序

    shellSort: function(arr){

        console.log(arr)

        var h = 1

        while(h<=arr.length/3){

            h = h*3+1  //O(n^(3/2))by Knuth,1973

        }

        for( h>=1h=Math.floor(h/3)){

            for(var k=0k<hk++){

                for(var i=h+ki<arr.lengthi+=h){

                    for(var j=ij>=h&&arr[j]<arr[j-h]j-=h){

                        var tmp = arr[j]

                        arr[j] = arr[j-h]

                        arr[j-h] = tmp

                    }

                }

            }

        }

        return arr

    }

}

给出一个二维数组。请将这个二维数组按第i列(i从1开始)排序，假设第i列同样，则对同样的行按第i+1列的元素排序。假设第i+1列的元素也同样，则继续比较第i+2列，以此类推，直到最后一列。假设第i列到最后一列都同样，则按原序排列。 

实现下面接口：

输入一个m*n 的整数数组。实现按规则排列，返回排列后的数组。

调用者会保证：

比方输入数组为： 

1,2,3

2,3,4

2,3,1

1,3,1

按第二列排序： 

输出： 

1,2,3

2,3,1

1,3,1

2,3,4

分析：从最后一列开始使用稳定的排序算法（必须是稳定，可采用冒泡排序）排序，一直排序到指定的列为止。

---