冒泡排序法

已知一个数组将数字插入到数组内并排序

var arr = [20, 10, 70, 30, 50];
var n = 15;
// 1. 插入数字
arr.push(n) 
// 2. 冒泡排序
for (var k = 0; k < arr.length - 1; k++) {
    for (var i = 0; i < arr.length - 1 - k; i++) {
        if (arr[i] < arr[i + 1]) {
            var temp = arr[i]
            arr[i] = arr[i + 1]
            arr[i + 1] = temp
        }
    }
}
console.log('冒泡排序结束后的arr: ', arr)

选择排序

已知一个数组，进行排序

var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
// 下标    0  1  2  3  4  5  6  7  8
console.log('原始数组arr: ', arr)

for (var k = 0; k < arr.length; k++) {
    var minIndex = k    // 假设当前最小数值 为 下标 0 的项
    for (var i = k + 1; i < arr.length; i++) {
        if (arr[minIndex] > arr[i]) {
            minIndex = i
        }
    }
    // 交换 真实最小的值  与 下标 0 的值
    var temp = arr[k]
    arr[k] = arr[minIndex]
    arr[minIndex] = temp
}
console.log('选择排序结束后的 arr: ', arr)

数组的方法

1. push;
    语法: 数组.push(数据)
    作用: 向 数组末尾 添加数据
    返回值: 追加数据后, 数组最新的长度

2. pop;
    语法: 数组.pop()
    作用: 删除数组的最后一项
    返回值: 删除的哪一项数据

3. unshift;
    语法: 数组.unshift(数据)
    作用: 向 数组头部 添加数据
    返回值: 追加数据后, 数组最新的长度

4. shift;
    语法: 数组.shift()
    作用: 删除数组头部(第一项)的数据
    返回值: 删除的哪一项数据

5. reverse;
    语法: 数组.reverse()
    作用: 反转数组
    返回值: 反转后的数组

6. sort;
    语法: 数组.sort(); 数组.sort(function (a, b) {retrun a - b}); 数组.sort(function (a, b) {retrun b - a})
    作用:
        不传参数
        会将数组内所有值, 转换为字符串, 然后一位一位的对比(第一位相同,对比第二位,...)
    传参---函数 return a - b
        会将数组内所有的值, 按照数字的 从小到大排列
    传参---函数 return b - a
        会将数组内所有的值, 按照数字的 从大到小排列
    返回值: 
    不传参数
        将排序后的数组返回
    传递参数
        将排序后的数组返回

7. splice;
    语法: 数组.splice(开始索引, 多少个);  数组.splice(开始索引, 多少个, 数据1, 数据2, 数据3...)
    作用: 
        不传参数: 剪切数组中的某一段数据
        传递参数: 剪切数组中的某一段数据, 将第三个参数开始, 当成新数据插入到数组内
        返回值: 截切后的数据(数组形式)

数组的方法 1~7 是能够改变原数组的方法


8. slice;   (不会改变原数组)
    语法: 数组.slice(开始索引, 结束索引)
    参数特点: 
        1. 包含开始索引, 不包含结束索引(到结束索引前一位)
        2. 参数接受负数(相当于 数组.length + 负数)
        3. 不传结束索引     相当于写了 数组.length
        4. 一个参数都不传   相当于复制整个数组, 或者只传递第一个参数为 0
    作用: 复制数组中的某一段数据
    返回值: 复制出来的内容

9. concat;
    语法: 数组.concat(数据1, 数据2)
    作用: 将参数, 合并到指定数组内(如果参数写了数组, 那么会将数组的每一个值合并到指定数组)
    返回值: 合并后的数组

10. join;
    语法: 
        数组.join(连接符)
        参数可以不传, 不传递默认按照 , 逗号
    作用: 通过连接符连接数组的每一个值
    返回值: 连接好的数组

11. indexOf; 
    语法: 数组.indexOf(数据);   数组.indexOf(数据, 开始索引)
    作用: 在数组内寻找指定数据
    返回值: 
        1. 找到数据的时候, 返回数据第一次出现的下标
        2. 找不到的时候, 返回 -1

12. lastIndexOf
    语法: 数组.lastIndexOf(数据);   数组.lastIndexOf(数据, 开始索引)
    作用: 在数组内寻找指定数据(倒叙寻找)
    返回值: 
        1. 找到数据的时候, 返回数据第一次出现的下标
        2. 找不到的时候, 返回 -1

数组的塌陷

    var arr = [0, 1, 2, 3, 4, 5]
    // 下标    0   1  2  3  4  5

    // 需求: 将数组清空(将数组每一项删除)

    for (var i = 0; i < arr.length; i++) {
        arr.splice(i, 1)    // 0  1  2  3  4  5
        i--
    }
    
    //倒着从最大开始删除
    for (var i = arr.length - 1; i >= 0; i--) {
        arr.splice(i, 1)
    }
    console.log(arr)