JS_数组_排序

01-复习
    作用域
          全局：所有人都可以使用，生命周期：会话级，不建议使用（少用）
          局部：只有函数内部可以使用，生命周期：函数结束，不建议使用
          作用域链：先看自己有没有这个变量，自己没有找上一次，一直到全局全局没有报错

            递归
                解决不固定层数的对象
            
            对象
                var obj = {}                字面量
                var obj2 = new Object()     构造函数

                obj.name = 'Jack'           增加

                obj.name = 'Rose'           修改

                // 只能删除属性，点后面的都是属性
                delete obj.name             删除

                console.log(obj.xxx)        查找
                console.log(obj['xxx'])

            循环对象
                for (var attr in obj) {
                    attr -> 属性名
                    obj[attr] -> 属性值
                }

            数组
                var arr = []

            数据类型
                基本：number string boolean undefined null
                复杂：function object array
        执行之后有区别
                    // function fn() {
        //     var a = 12          // 执行完立即消失
        // }
        // fn()

        // 闭包
        // function fn() {
        //     var a = 12          // a 不消失

        //     function fun() {
        //     }
        //     fun()
        // }

        // fn()

        // 变量（delete只能删除属性）
        var a = 100

        delete a

        console.log(a)      // 100
        delete删除属性问题
            delete运算符  只能删除自有属性,不能删除继承属性 (要删除继承属性必须从定义这个属性的原型对象上删除它,而且会影响到所有继承自这个原型的对象)

02-练习
    每五个偶数求一次平均值，每个平均值存到新数组里面，输出新数组
         <script>
        // 定义一个数组
        var arr = []
        // 存30个偶数
        for (var i = 2; i <= 60; i += 2) {
            arr.push(i)
        }
        console.log(arr)

        // 新数组
        var newArr = []
        // 求和
        var sum = 0
        // 求平均值，把所有平均值放到一个新数组里面
        for (var i = 0; i < arr.length; i++) {
            // console.log(arr[i])
            sum += arr[i]

            // 是不是算到第五个值
            if ((i + 1) % 5 === 0) {
                // 平均值放到新数组里面
                newArr.push(sum / 5)

                // 重新开始计算
                sum = 0
            }
        }

        console.log(newArr)
    </script>

03-数组
    二维数组
        var arr = [
[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
....
 ]
            例子： 1-25 每五个数存一次
                  // 大数组
        var bigArr = []
        // 数组
        var arr = []

        // 添加25个数
        for (var i = 1; i <= 25; i++) {
            arr.push(i)         // 存数字
            if (i % 5 === 0) {      // 判断数组满5个值没有
                bigArr.push(arr)    // 满五个值的数组存到大数组里面

                arr = []            // 清空，为了重新开始存
            }
        }

        console.log(bigArr)

04-数组写法
            // Array
        // - []             字面量
        // - new Array()    构造函数
        var arr = [12, 5, 7, 99, 103]

        // var arr2 = new Array(100, 200, 300, 400)
        //  构造函数写法里面只有一个值的时候是数组长度
        // var arr3 = new Array(10)
        // console.log(arr, arr2, arr3)

        // 数组操作
        // - push pop unshift shift

        // push
        // - 数组最后添加
        var res = arr.push(20, 31, 66)

        // pop
        // - 删除数组最后一个
        // - 返回值：被删除的那一个
        var res = arr.pop()

        // unshift
        // - 数组最前面添加
        var res = arr.unshift(200, 100)

        // shift
        // - 删除数组最前面的
        // - 返回值：被删除的那一个
        var res = arr.shift()

        console.log(arr)
        console.log(res)

05-数组练习
        引用问题（地址问题，两个复杂数据类型如果是连等的情况就一个改另一个也跟着变）
    后面数组更改，前面的数组不变
     var arr2 = arr
     arr2.push(999)
         <script>
        var arr = [12, 5, 7, 99, 103, 1]
        // 重新建立一个数组
        var arr2 = []
        for (var i = 0; i < arr.length; i++) {
            arr2.push(arr[i])
        }
        arr2.push(999)

        console.log(arr, arr2)
    </script>

06-封装函数操作数组
    例子：输入的数字是否在数组内
        <script>
        var arr = [12, 5, 7, 99, 103, 1]

        function findArr(arr, n) {
            // 循环传过来的数组
            for (var i = 0; i < arr.length; i++) {
                // 数组中的每一个都和传过的参数n比较
                if (arr[i] === n) {
                    // 找到直接终止函数运行 返回true
                    return true
                }
            }
            // 循环结束都没有进入条件,那肯定是没找到 返回false
            return false
        }
        var b = findArr(arr, 1)
        var b2 = findArr(arr, 100)

        console.log(b, b2)
    </script>

07-练习
    数组增长值  每个值增长百分之30，不能改变原数组
        <script>
        // 数组增长值  每个值增长百分之30，不能改变原数组
        // - [10, 100, 1000]
        var arr = [10, 100, 1000]

        function fn(arr, n) {
            var newArr = []         // 新数组

            for (var i = 0; i < arr.length; i++) {
                newArr.push(arr[i] * n)     // 老数组的每个值乘上一个百分比值 存到新数组里面
            }

            // console.log(arr, newArr)
            return newArr       // 返回一个新数组
        }
        var newArr = fn(arr, 1.5)           // 传参的时候那个数组，倍率  接收一个新数组
        var newArr2 = fn(arr, 2)            // 传参的时候那个数组，倍率  接收一个新数组

        console.log(newArr, newArr2)
    </script>

08-数组操作
      数组操作
   - push pop shift unshift indexOf slice splice concat reverse join sort
          <script>
      
        var arr = [12, 5, 7, 99, 103, 1]

        // indexOf
        // - 查找
        // - 返回值：返回下标 找不到返回-1
        // var res = arr.indexOf(999)
        // console.log(res)

        // slice
        // - 复制
        // - 返回值：返回一个新数组
        // var res = arr.slice()
        // var res = arr.slice(3)
        // var res = arr.slice(3, 5)           // 两个参数都是下标
        // console.log(res, arr)

        // splice
        // - 切
        // - 返回值：返回一个新数组  改变原数组
        // var res = arr.splice(1)
        // var res = arr.splice(3, 2)                       // 第一个参数是位置，第二个参数是个数
        // var res = arr.splice(3, 2, 'abc', 100, 200)         // 第三个参数以后都是添加
        // console.log(arr, res)

        // concat
        // - 连接数组
        // - 返回值：返回一个新数组
        // var res = arr.concat([100, 200, 300], 'str')
        // console.log(arr, res)

        // reverse
        // - 反转数组
        // - 返回值：返回一个新数组   改变原数组
        // var res = arr.reverse()
        // console.log(arr, res)

        // join
        // - 转字符串
        // - 返回值：一个字符串
        // var res = arr.join()
        // var res = arr.join('')
        // var res = arr.join('-')
        var res = arr.join('/')
        console.log(res)

        // sort
        // - 排序
        // arr.sort()       // 只能排序字符串 a - z
        arr.sort(function (a, b) {
            // return a - b            // 从小到大
            return b - a            // 从大到小
        })

        console.log(arr)
    </script>

09-练习
    去重
         <script>
        // 去重
        var arr = ['a', 'b', 'c', 'd', 'b', 'c', 'c', 'd', 'a', 'b', 'c']

        arr.sort()

        console.log(arr)

        for (var i = 0; i < arr.length; i++) {
            if (arr[i] === arr[i + 1]) {
                // 删除一个
                arr.splice(i, 1)
                i--
            }
        }

        console.log(arr)
    </script>

10-冒泡排序
     <script>
        /*
            [5, 7, 12, 99, 1, 103]
            [5, 7, 12, 1, 99, 103]
            [5, 7, 1, 12, 99, 103]
            [5, 1, 7, 12, 99, 103]
            [1, 5, 7, 12, 99, 103]
        */
        var count = 0

        var arr = [12, 5, 7, 99, 103, 1]

        for (var j = 0; j < arr.length - 1; j++) {
            for (var i = 0; i < arr.length - 1 - j; i++) {
                count++
                if (arr[i] > arr[i + 1]) {
                    // 换位置
                    var tmp = arr[i]
                    arr[i] = arr[i + 1]
                    arr[i + 1] = tmp
                }
            }
        }

        console.log(arr)
        console.log(count)
    </script>

11-选择排序
    含义
        选择一个最大值 和 当前下标值换位置
            减少换位置的次数
                        选择一个最大值 和 当前下标值换位置
            减少换位置的次数
            var i = 0 var maxIndex = 5  [103, 7, 12, 99, 1, 5]
            var i = 1 var maxIndex = 3  [103, 99, 12, 7, 1, 5]
            var i = 2 var maxIndex = 2  [103, 99, 12, 7, 1, 5]
            var i = 3 var maxIndex = 3  [103, 99, 12, 7, 1, 5]
            var i = 4 var maxIndex = 5  [103, 99, 12, 7, 5, 1]
                <script>
        var arr = [12, 5, 7, 99, 103, 1]

        var maxIndex = 0
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i
            }
        }
        var tmp = arr[0]
        arr[0] = arr[maxIndex]
        arr[maxIndex] = tmp

        var maxIndex = 1
        for (var i = 1; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i
            }
        }
        var tmp = arr[1]
        arr[1] = arr[maxIndex]
        arr[maxIndex] = tmp

        var maxIndex = 2
        for (var i = 2; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i
            }
        }
        var tmp = arr[2]
        arr[2] = arr[maxIndex]
        arr[maxIndex] = tmp

        var maxIndex = 3
        for (var i = 3; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i
            }
        }
        var tmp = arr[3]
        arr[3] = arr[maxIndex]
        arr[maxIndex] = tmp

        var maxIndex = 4
        for (var i = 4; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i
            }
        }
        var tmp = arr[4]
        arr[4] = arr[maxIndex]
        arr[maxIndex] = tmp

        console.log(arr)

    </script>

11-选择排序2
    <script>
        var arr = [12, 5, 7, 99, 103, 1]
        var count = 0

        for (var j = 0; j < arr.length; j++) {
            var maxIndex = j
            for (var i = j; i < arr.length; i++) {
                if (arr[i] > arr[maxIndex]) {
                    maxIndex = i
                }
            }
            // 优化
            if (maxIndex !== j) {
                count++
                var tmp = arr[j]
                arr[j] = arr[maxIndex]
                arr[maxIndex] = tmp

            }
        }
        console.log(arr)
        console.log(count)

    </script>