2020-12-03

算法学习-三大排序

会用到的数组API

splice()实现数组的增删改查

• splice(n,m)从数组索引n开始，删除m个元素，把删除的部分以新数组返回，原来的数组会发生改变
• splice(n,0,x)从索引n开始，不删除，把x添加到索引n的前面

push()向末尾追加

unshift()向开头追加

concat()数组拼接

sort()数组排序

• 按每一项的第一个字符排，局限性，只能处理10以内的数字

• arr.sort(function(a,b){
  return a-b;
  })
  

排序算法

冒泡排序

算法动画图解—这个app可以通过动画的形式去学习算法，ios没有破解版

从头开始比较相邻的元素，如果第一个大于第二个，就交换位置

第一次排序（最大的到了最后一个位置）

23 45 65 61 78 19 12 80 30 72 80 31 83 2 70 46 90

重复这样一个过程每次都把最大的排到后边

代码如下：

let arr = [12,8,24,16,3];
        //当前项和后一项进行比较，如果当前项>后一项，则两项交换位置，让大的靠后即可。
        function bubble(arr){
            //外层循环控制比较的轮数
            for(var i=0;i<arr.length-1;i++){
                //里层循环控制每一轮比较的次数
                for(var j=0;j<arr.length-i-1;j++){
                    if(arr[j]>arr[j+1]){
                        let flag = arr[j+1];
                        arr[j+1] = arr[j];
                        arr[j] = flag;
                    }
                }
            }
            return arr;
        }
    let ary = bubble(arr);
    console.log(ary);

另一种交换位置的

[arr[j],arr[j+1]] = [arr[j+1],arr[j]];

插入排序

<script>
        let arr = [12,8,24,16,1];
        function insert(arr)
        {
            //1.准备一个新数组，用来存储排序的
            let handle = [];
            handle.push(arr[0]);

            //从第二个开始依次排序，一直把所有的都排序完
            for(let i=1;i<arr.length;i++){
                let A = arr[i];
                //和handle比较
                for(let j=handle.length-1;j>=0;j--){
                    let B= handle[j];
                    if(A>B){
                        handle.splice(j+1,0,A);//把A放在B的后边
                        break;
                    }
                    //已经比到第一项
                    if(j===0){
                        handle.unshift(A);
                    }
                }
            }
            return handle;
        }
        var ary = insert(arr);
        console.log(ary);
    </script>

快速排序

• arr = [12,8,15,16,3,24]

• 先找到数组的中间项

• 把它从原来的数组中移除

• 获取这一项的结果 --15 此时 arr = [12,8,16,3,24]

• 依次拿数组中的每一项与中间项进行比较，大于中间数放在右边，小于中间项放在左边

• 左边【12，8，1】 右边【16，24】–再次选出中间项比较（不断重复此操作）

• 最后：左边+中间+右边

递归：函数执行的时候自己调用自己—但是会导致栈溢出

这个不会导致栈溢出

function fn(){
            setTimeout(() => {
                fn();
            }, 0）;
        }

<script>
        let arr = [12,8,15,16,3,24];
        function quick(arr){
            //结束递归（arr<=1项，则不用处理）
            if(arr.length<=1){
                return arr;
            }
            //1.找到数组的 中间项,z在原有数组中删除
            let middle = Math.floor(arr.length/2);
            let middle_value = arr.splice(middle,1)[0];
            //2.准备左右两个数组,循环剩下数组中的每一项，比当前项小的放在左边，反之放到右边
            let arr_left = [],arr_right = [];
            for(var i=0;i<arr.length;i++){
                let flag = arr[i];
                flag<middle_value?arr_left.push(flag):arr_right.push(flag);
            }
            // 递归方式让左右两边的方式持续这样处理，直到左右两边的都排好序为止
            // 最后 左边+中间+右边
            return quick(arr_left).concat(middle_value,quick(arr_right));
        }
        arr = quick(arr);
        console.log(arr);
    </script>