数组的排序

一.数组的排序和分类

1.排序： 就是把一个乱序的数组通过我们的处理，
让他变成一个有序的数组

2.排序方式：

     a.冒泡排序

     b.选择排序

二.冒泡排序

1.基本思想：

  比较相邻的元素，如果第一个比第二个人大 就交换他们两个
  对每一对相邻的元素做同样的工作，从开始第一队到结尾最后一对，
  完成此步骤后最后的一个元素是最大的一个元素
  针对所有元素重复以上步骤除了最后一个
  持续每次对越来越少的元素重复以上的步骤，知道没有任何一对数字需要比较

下面展示一些 内联代码片。

//以下是冒泡排序的部分案例

        /*
           思想:
             由小到大排： 
               挨着两个数，两两比较，如是前一个数比后一个数大，交换位置，一轮之后最大的数沉底，
               在未排序的数中重复以上操作，
                 arr[i]  arr[i+1]
                     temp
                 if(arr[i] > arr[i+1]){
                    var temp = arr[i]
                    arr[i] = arr[i+1]
                    arr[i+1] = temp
                 }

                
                j 冒泡次数       i 循环变量       比较次数
                1                 0                4
                2                 1                3
                3                 2                2
                4                 1                1
                
                元素个数
                n                                 n-i-1


        */


        //第一冒泡，得到最大的一个数，沉底
        // for (var i = 0; i < arr.length; i++) {
        //     if (arr[i] > arr[i + 1]) {
        //         var temp = arr[i]
        //         arr[i] = arr[i + 1]
        //         arr[i + 1] = temp
        //     }
        // }
        // console.log(arr)

        //第二次冒泡
        // for (var i = 0; i < arr.length - 1; i++) {
        //     if (arr[i] > arr[i + 1]) {
        //         var temp = arr[i]
        //         arr[i] = arr[i + 1]
        //         arr[i + 1] = temp
        //     }
        // }

        // console.log(arr)

        //第三次冒泡
        // for (var i = 0; i < arr.length - 2; i++) {
        //     if (arr[i] > arr[i + 1]) {
        //         var temp = arr[i]
        //         arr[i] = arr[i + 1]
        //         arr[i + 1] = temp
        //     }
        // }
        // console.log(arr)


        //第四次冒泡
        // for (var i = 0; i < arr.length - 3; i++) {
        //     if (arr[i] > arr[i + 1]) {
        //         var temp = arr[i]
        //         arr[i] = arr[i + 1]
        //         arr[i + 1] = temp
        //     }
        // }
        // console.log(arr)

        var arr = [89, 98, 78, 68, 76]
        // j 外层循环表示冒泡排序次数
        for (var j = 0; j < 5-1; j++) {

            // 比较的次数
            for (var i = 0; i < 5-j-1; i++) {
                //挨着两个数，两两比较，如果前一个比后一个大，交换位置
                if (arr[i] > arr[i + 1]) {
                    var temp = arr[i]
                    arr[i] = arr[i + 1]
                    arr[i + 1] = temp
                }
            }

            console.log(arr)
        }

        console.log('================');

        console.log(arr)

三.选择排序

1.基本思想

   首先在未排序的序列中找到最小（大）的元素存放带排序序列的起始位置
   再从剩余未排序序列中继续中寻找最小（大），元素然后放到已排序序列末尾
   重复第二步直到所有元素均排列完毕

下面展示一些 内联代码片。

// 以下是选择排序部分案例

        var arr = [89, 98, 78, 68, 76]
                 // 0  1    2   3   4

                 /*
                   [ 68 ], 98, 78,89 ,76]
                     0     1   2  3    4

                    [ 68 ,76],  78,89 ,98]
                     0     1   2  3    4

                 */
        var n = 5
        // 外层循环，选择排序次数
        for (var i = 0; i < n - 1; i++) {  // i: 0 , 1

            //找最小值索引号
            var minIndex = i    //minIndex: 0 , 1
            for (var j = i+1; j < 5; j++) {  // 让后面的数依次与前面数比较， J :2
                if (arr[j] < arr[minIndex]) {
                    minIndex = j   //minIndex：4
                }
            }
            //交换位置
            var temp = arr[i]
            arr[i] = arr[minIndex]
            arr[minIndex] = temp

            console.log('第'+ (i+1)+'次选择排序 :',arr);
        }

四.数组去重（基础的两种方法）

下面展示一些 内联代码片。

// 以下是一些数组去重的案例

        /* 
            
             方法一:  arr.indexOf(元素)  
                           => 元素在数组中的下标，
                           => 如果没有返回 -1
                     
                    创建一个空数组,存储不重复的数 
                       var newArr = []
               基本思想: 遍历原数组，获取每个元素，判断是否已经存在新数组中，如果不存在，则放入新数组。
                        for(var i = 0; i<length; i++){
                            if( newArr.indexOf(arr[i]) == -1 ){
                                newArr.push(arr[i])
                            }
                        }
                    
        */
        function arrayToHeavy() {
            var arr = [1, 2, 5, 1, 8, 4, 2] // [1,2,5,8,4]
            var newArr = [] // 创建一个空数组,存储不重复的数 
            for (var i = 0; i < arr.length; i++) {
                var item = arr[i] //原数组元素  //item: 1,2,5,1,8,4,2
                if (newArr.indexOf(item) == -1) {
                    newArr.push(item) // [1,2,5,8,4]
                }
            }
            console.log(newArr);
        }


        /*
        方式二: splice(index,1)
              var arr = [1, 2, 5, 1, 8, 4, 2] // [1,2,5,8,4]
                 1
                 1  2, 5, 8, 4, 2
                    2
                    2, 5, 8, 4
        */

        function arraySplice() {
            var arr = [1, 2, 5, 1, 1, 8, 4, 2] // [1,2,5,8,4]

            for (var i = 0; i < arr.length; i++) {
                var item = arr[i] //item: 1
                for (var j = i + 1; j < arr.length; j++) {
                    if(item == arr[j]){  // 1-2 1-5  1-1
                        arr.splice(j,1)  // [1, 2, 5, 1, 8, 4, 2]
                        j--
                    }
                }
            }

            console.log(arr);
        }

        arraySplice()