JS数据结构算法总结

1、每个算法的思想是什么？

2、每个算法的稳定性怎样？时间复杂度是多少？算法稳定性指的是：假定在待排序序列中有多个相同的数字，经过排序后的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

3、在什么情况下，算法出现最好情况 or 最坏情况？

4、每种算法的具体实现又是怎样的？

 

Sort_1：冒泡排序

 

基本思想：通过无序区中相邻记录关键字间的比较和位置的交换,使关键字最小的记录如气泡一般逐渐往上“漂浮”直至“水面”。

算法稳定性：由于冒泡排序，两个数一样的时候，没必要交换位置，因此是稳定的。

算法复杂度：最好情况下：正序有序，则只需要比较n次。故，为O(n)，最坏情况下: 逆序有序，则需要比较(n-1)+(n-2)+……+1，故，为O(N*N)

var bubbleSort = function (arr) {
    var len = arr.length;
    for (var i = 0; i < len-1; i++) {
        for(var j=i+1;j<len;j++){
            var temp;
            if(arr[i]>arr[j]){
                temp=arr[i];
                arr[i]=arr[j];  //实现数据的交换，当相等的时候不做替换，因此是稳定的。
                arr[j]=temp;
            }
        }
    }
    return arr;
};

Sort_2：快速排序

 

基本思想：找到一个基准点，一般是中间部分，把数组分为2部分，大小分开，然后再合并。

算法稳定性：由于快速排序左右分开放的时候可能会将两个相同的数的相对位置改变，所以是不稳定的。

算法复杂度：最坏情况下是O(n^2)，当分开的序列是1和n-1的情况时。平均和最好情况下复杂度为O（nlogn），当平均分开序列的时候。

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

Sort_3：选择排序

 

基本思想：给每个位置选择当前元素最小的，比如给第一个位置选择最小的，给第二位置选择剩下元素最小的......

算法稳定性：比如5 8 5 2 9，第一遍的时候第一个位置的5会和2互换，这时候，两个5的相对位置就发生了改变。第一个5跑到了第二个5的后面去了。因此是不稳定的。

算法复杂度：最坏和最好、平均都是O（n^2）;

var selectSort = function (arr) {
    var minIndex;
    for(var i=0;i<arr.length-1;i++){
        minIndex = i;
        for(var j=i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                minIndex=j;  //找到最小值的index
            }
        }
        var temp=arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=temp;
    }
    return arr;
};

Sort_4：插入排序

 

基本思想： 往有序序列中插入未排好的数。第一个有序序列就是第一个数。依次类推。。。

算法稳定性：由于相对位置没有改变，因此是稳定的。

算法复杂度：最好O（n）,最坏和平均为O（n^2）;

var insertSort = function (arr) {
   for(var i=1;i<arr.length;i++){
       if(arr[i]<arr[i-1]){
           var j=i-1;
           var temp = arr[i];
           arr[i] = arr[j];
           while (j>=0&&temp<arr[j]){
               arr[j+1]=arr[j];
               j--;
           }
           arr[j+1]=temp;
       }
   }
    return arr;
};

Sort_5：堆排序

 

基本思想：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。（一般升序采用大顶堆，降序采用小顶堆）http://www.cnblogs.com/chengxiao/p/6129630.html

稳定性：不稳定

复杂度：均为O（nlogn）;