数组的 去重和排序

去重

破坏原数组的去重

思路

1. 遍历数组
2. 从当前元素的下一个元素开始查找该元素
3. 如果后面有与当前元素相同的元素 ， 就删除后面的元素
4. 考虑到删除一个元素会改变下一个元素的位置，从而漏掉下一个元素的遍历，所以，删除之后,再次对当前索引的元素进行判断

代码实现

 function dedupArr1(arr) {
            // 遍历数组 
            for (let i = 0; i < arr.length; i++) {

                // 从当前元素的下一个元素开始查找该元素，返回索引值
                let index = arr.indexOf(arr[i], i + 1);

                // 如果索引值不是 -1 ，即后面有与当前元素相同的元素 ， 就删除后面的元素
                // 考虑到删除一个元素会改变下一个元素的位置，从而漏掉下一个元素的遍历，所以，删除之后,i--
                if (index != -1) {
                    arr.splice(index, 1);
                     i--;
                }
            }
            return arr;
        }
        
         // 目标数组
        let arr1 = [1, 2, 1, 2, 7, 9, 6, 2, 4, 3, 6];
        
        dedupArr1(arr1);
        console.log(arr1)

运行结果

注意

array.indexOf(item, start) 方法在数组中搜索指定项目，并返回其位置。
搜索将从指定位置开始，如果未指定开始位置，则从头开始，并在数组末尾结束搜索。
如果未找到该项目，则 indexOf() 返回 -1。
如果该项目出现多次，则 indexOf() 方法返回第一次出现的位置。

去重后形成新数组

思路

1. 定义空数组用来接收去重后的元素
2. 遍历数组 ， 如果一个元素在新数组中不存在，就添加到新数组里
3. 返回新数组

代码

function deddupArr2(arr) {

            // 定义空数组用来接收去重后的元素
            let newArr = [];

            // 遍历数组 ， 如果一个元素在新数组中不存在，就添加到新数组里
            for (ele of arr) {
                if (newArr.indexOf(ele) == -1) {
                    newArr.push(ele);
                }
            }
            // 返回新数组
            return newArr;
        }

        // 目标数组
        let arr1 = [1, 2, 1, 2, 7, 9, 6, 2, 4, 3, 6];
        let arr2 = deddupArr2(arr1);
        console.log("原数组：", arr1, "新数组：", arr2);

运行结果

注意

分清楚 遍历的是目标数组，而push 加入的是新数组

排序

Arrary.sort()

Arrary.sort() 对数组的项目进行排序,会改变原始数组
默认情况下，sort() 升序
arr.sort((a,b)=>a-b); //升序排
arr.sort((a,b)=>b-a); //降序

冒泡排序

思路

升序排为例

1. 对相邻的两个数进行比较
2. 如果前一个大，就换位置，否则不换
3. 每一趟比较完可以确定一个最大的数

代码

function upSort(arr) {
         // 外层循环,比较的趟数
         for (let i = 0; i < arr.length; i++) {
            // 每趟比较
            for (let j = 0; j < arr.length; j++) {
               if (arr[j] > arr[j + 1]) {
                  [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
               }
            }
         }
      }

      // 目标数组
      let arr1 = [2, 6, 8, 9, 5, 4, 0, 7, 3, 1];
 	  console.log(arr1);

      upSort(arr1)
      console.log(arr1);

运行结果

注意

通过数组解构赋值，可以快速交换两个元素的值
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j] ] // 交换相邻两个元素的值

选择排序

思路

升序排为例

1. 每一个元素和它后面的元素进行比较
2. 如果比后面的大，就与后面的数字交换位置
3. 每一趟比较完可以确定一个最小的数

代码

 function selsort(arr){

         for(let i =0;i<arr.length;i++){
            for(let j=i+1;j<arr.length;j++){
               if(arr[i]>arr[j]){
                  [arr[j], arr[i]] = [arr[i], arr[j]]
               }
            }
         }
      }
      
      // 目标数组
      let arr1 = [2, 6, 8, 9, 5, 4, 0, 7, 3, 1];

      selsort(arr1);
      console.log(arr1);

运行结果

注意

内层循环从 i+1开始