js数据结构--排序算法

排序算法是属于数据结构的知识点

一般常见的排序有10种

 <script>
 冒泡排序: 逐个冒泡到上面去
        var arr = [1,3,8,5,7,6,2]
        function bubbleSort(array){
            //冒泡的次数
            for(var i=1;i<array.length;i++){
                for(var j=0;j<array.length-i;j++){//记录比较次
                    //比较
                    if(array[j]>array[j+1]){
                        //换位置
                        var temp = array[j] //先保留j位置的值
                        array[j] = array[j+1] //将j+1位置的值赋值给j位置
                        array[j+1] = temp //将开始保存的j位置的值赋给j+1位置
                    }
                } 
            }         
        }
         bubbleSort(arr)
        逐层冒泡 第一次执行的冒泡执行比较的次数为当前的长度-1
        冒泡的总次数为长度-1
        j和j+1比 比较完进行位置交换
        冒泡的比较次数一次比一次少 最后到达一次结束
 选择排序:
        function selectorSort(array){
            for(var i=0;i<array.length-1;i++){//只剩一个数就不比了
                //设置第一个数为最小值
                var min = i
                for(var j=i+1;j<array.length;j++){
                    if(array[min]>array[j]){ //如果比最小值还小
                        min = j //使用min记录一下比这个值
                    }
                }
                if(min!=i){
                    //min不指向我们开始指定的下标位置
                    //换位置
                    var temp = array[i]
                    array[i] = array[min]
                    array[min] = temp
                }
            }
        }
        // selectorSort(arr)
          每次选择当前的第一个数为最小值
          这个值跟后面的所有去比较 然后对应的比我这个值还小的 把下标记录起来 将这个下标赋值给min
           判断min是否是我前面给到的值 如果是不做操作 如果不是交换位置
 插入排序：
        从后往前比 初始下标为1
        第一次比较为1和0比较 比较一次
        第二次比较为2和1比较 1和0比较 比较俩次
        ... 后面持续递增
        function insertSort(array){
            for(var i=1;i<array.length;i++){
                for(var j=i;j>0;j--){
                    if(array[j-1]>array[j]){
                        var temp = array[j-1]
                        array[j-1] = array[j]
                        array[j] = temp
                    }
                }
            }
        }
         insertSort(arr)
 插入排序（第二种）
        function insertion(array){
            for(var i=1;i<array.length;i++){
                var preIndex = i-1 //获取前一个下标
                var current = array[i] //先保存当前的值 为防止
                while(preIndex>=0 && current < array[preIndex]){
                  如果前一个下标大于等于0 和 当前的值为小于上一个
                    array[preIndex+1] = array[preIndex] //将本身这个位置的值赋值为上一个
                    preIndex-- //递减 继续往前走
                }
                array[preIndex+1] = current //当前的位置的值等于原本位置的值
            }
        }
         insertion(arr)
         console.log(arr);

 快速排序(冒泡升级)
         function qSort(array){
             var max = array.length-1//定义最大下标
             var min = 0 //最小下标
             var center = Math.round((max+min)/2)
             while(min<max && array[min]<array[center]){ //左边
                 min++
                max = center
                 center = Math.round((max+min)/2)
             }
             while(max>min && array[max]>array[center]){ //右边
                 max--
                 min = center
                 center = Math.round((max+min)/2)
             }           
             if(max==min){
                 return array
             }
         }
 快速排序 无限二分 找中间值
        function quickSort(arr) {
            if (arr.length <= 1) { //长度为1或者小于1退出
                 return arr
            }
            var centerIndex = Math.round(arr.length / 2) //取中间值下标
            var center = arr.splice(center, 1)[0] //接收删除的中间值
            var left = [] //左边的数组
            var right = [] //右边的数组
            for (var i = 0; i < arr.length; i++){ //循环遍历
                if (arr[i] < center) { //小于中间值 加到左边
                    left.push(arr[i])
                }else {
                    right.push(arr[i])//大于中间值 加到左边
                }
            }
            return quickSort(left).concat([center], quickSort(right));//返回合并的数组
        }
        console.log(quickSort(arr));
     </script>

排序方法

 <script>
        var arr = ['a','b','c','d']
        var strArr = arr.reverse() //反转 将数组元素全倒过来 
        console.log(strArr);
reverse 会影响之前的数组 没有参数 返回值为倒转过来的数组
strArr 和 arr俩个其实指向的是一个变量 所以操作 strArr会影响arr 操作arr也会影响strArr
        console.log(strArr == arr); //true
        console.log(strArr === arr); //true
        console.log(arr);
        arr.sort() //排序 重点 默认为从小到大
        console.log(arr);
        var arr1 = [15,70,3,6,8,7]
        arr1.sort() //排序 重点
        默认为从小到大默认排序方式是根据ascii码 如果是数值会自动转换为string 只取第一位
        console.log(arr1);
        指定比较的方法进行比较
        arr1.sort(function(a,b){
            return a-b //返回的是1 1就是正序 a-b -1就是倒序 b-a
        })
        console.log(arr1);
        var numArr = arr1.sort(function(a,b){
            return b-a //返回的是1 1就是正序 a-b -1就是倒序 b-a
        })
        console.log(arr1);
        console.log(numArr);
 sort 方法默认（无参的方式）按照ascii码进行比较 对应的顺序为从小到大 返回值为排序好的数组
 里面可以指定参数 参数是一个function 这个里面有俩个参数 a b 如果是返回为 a-b 为1 就是正序
 相反如果返回 b-a 就是-1 那就是倒序
        var arr2 = [2,1,5,3,0]
        var arr3 =  arr2.sort(function(a,b){
            return a-b
        })
        var arr4 =  arr2.sort(function(a,b){
            return b-a
        })
        arr2.push(10) //arr2变了 arr3变了 arr4变了
        var numberArr =  [0,1,2,4,3]
        numberArr.sort(function(a,b){
            if(a>b){ //必须具备比较过程
                return 1 //正序
            }
            return -1//倒序
        })
        console.log(numberArr);
    </script>

截取 连接方法

<script>
        push pop shift unshift reverse sort concat slice
        var arr = [1,2,3,4]
        var arr1 = [4,5,6,7]
 连接方法：
   concat 进行数组合并操作 对应的返回值为一个新的数组 不改变原本的数组
   传入的参数 是一个数组 也可以是单个元素 连接到后面
        var newArr =  arr.concat(arr1)
        console.log(arr);// 还是 1 2 3 4
        console.log(newArr);
        var newArr1 = arr.concat(3)
        console.log(newArr1);
  截取方法 slice截取对应数组的某一段内容组成一个新的数组 返回的是一个新的数组
  不会改变原本的数组 参数为开始下标和结束下标(不包含结束的下标)
        var sliceArr = arr1.slice(1,3)
        console.log(sliceArr);//5 6
        console.log(arr1.slice(0,1));//4
        console.log(sliceArr.slice(0,1));//5
        console.log(arr1.slice(arr1.length-1,arr1.length));//截取最后一个
    </script>

push 添加到末尾
pop 删除末尾
shift 删除开头
unshift 添加到开头
reverse 反转
sort 排序
concat 合并
slice 截取
join 连接成字符串
splice 删除
indexOf 正序查找下标
lastIndexOf 反序查找下标
根据对应的值找下标 找到了返回对应第一次出现的下标 找不到返回-1

<script>      
        var arr = ['a','b','c','b']
        console.log(arr.indexOf('b'));//indexOf找的是第一次出现的位置 默认从下标0开始找 没有找到返回-1
        console.log(arr.indexOf('b',0));//1
        console.log(arr.indexOf('b',2));//从下标1开始找 下标还是原本的下标
        var arr1 =  [1,1,2,3,4,1]
        console.log(arr1.indexOf(1));//0
        console.log(arr1.indexOf(1,2));//5
        console.log(arr1.indexOf(1,10));//-1
        lastIndexOf 从后往前
        console.log(arr1.lastIndexOf(1));//5
        console.log(arr1.lastIndexOf(1,2));//1
    </script>

splice方法

<script>
        push pop shift unshift splice sort reverse 会影响原本的数组
        concat slice join  不会影响原本的数组
        var arr = [1,2,3,4]
        会改变之前的数组 返回的是一个删除的数组
        删除 开始下标 删除的个数(个数可以被省略 删到最后)
        var newArr = arr.splice(0,2)// 1 2
        console.log(newArr); // 1 2
        console.log(arr); // 3 4
        var arr1 =  [5,6,7,8]
        var spliceArr = arr1.splice(1) //从下标1开始删除 删到最后
        console.log(spliceArr); // 6 7 8
        console.log(arr1);//5
        将删除位置的数据替换
        var arr2 = [6,7,8,9]
        var spliceArr1 = arr2.splice(1,2,10,11)// 删除7 8 将 10和11放到7 8的位置
        console.log(spliceArr1); // 7 8
        console.log(arr2); // 6 10 11 9
        不删除 插入元素到指定的位置
        var arr3 = [1,2,3]
        var insertArr = arr3.splice(1,0,'a') //不删除元素 插入a到数组中去
        console.log(insertArr); //空数组 
        console.log(arr3); //插入到指定的位置 1 a 2 3
        会改变之前的数组 返回的是一个被删除元素组成的数组
         如果是1个参数 那么就是从这个指定的参数下标删到结束
         如果是2个参数 那么就是从指定的参数下标位置 删对应的指定个数
         如果是3个参数 或者以上的参数 那么就是从指定的参数下标位置 删对应的指定个数 再将后面的数据填入对应的删除位置
         如果第二个参数为0 那么返回的是一个空数组 不删除 单纯的将对应的数据插入到指定的下标
    </script>

join方法

<script>
        push pop shift unshift reverse sort concat slice join
        join连接 连接成字符串 返回值为string
        不会影响原本的数组
        var arr = [1,2,3]
        var str  = arr.join() //相当于全部连一块 默认以,分割 arr.join() == arr.join(',')
        console.log(str);
        var str1 = arr.join("/") 
        console.log(str1);
    </script>