js-day07数组方法&排序

01回顾
知识回顾:
- 程序语句
应用程序 = 程序语句 + 数据结构 + 算法
- 数组基础
- 数组是做什么的？
- 数组创建方式
- 访问数组元素
+ 索引号
- 数组length属性
- 数组遍历
- 数组数据类型Array
- 数组常用方法
- push
- unshift
- pop
- shift
- splice
- sort
- reverse

        - join
        - indexOf
        - includes
        ...

     - 数组内存结构
        内存区域划分
          + 栈区域
              基本数据类型变量
              引用变量
          + 堆区域
              复杂数据类型也叫对象类型

02数组常用方法
1、join
=>作用: 将数组元素按指定字符拼接成字符串返回
=>参数： 指定字符
=>返回值: 返回拼接之后的字符串 | 原数组并没有改变

    2、indexOf
      =>作用: 返回数组元素索引号
      =>参数： 数组元素
      => 返回值: 索引号
                若参数写的元素不存在，则返回-1
                 拓展: 判断元素是否在数组中
                  arr.indexOf(50) == -1
    3、includes
      =>作用:检索元素是否在数组中 
      =>参数：数组的元素
      =>返回值：true | false

03数组遍历常用方法
0、for循环
1、forEach
作用：循环遍历
语法：
arr.forEach(function(item,index,arr){
//item 数组元素 此项必须有，其余可省略
//index 元素索引号
//arr 原数组
})
2、map
作用：遍历 & 返回到新数组中
语法：同上
var newArr = arr.map(function(item,index,arr){
return item + 1
})
返回值：新的数组
3、filter
作用:找数组中满足条件的元素,返回到新数组中
语法：
var newArr = arr.filter(function(item,index,arr){
return item > 1
})
返回值：新的满足条件数组
4、find
作用:找数组中满足条件的第一个元素
语法：
var newArr = arr.find(function(item,index,arr){
return item > 1
})
返回值：元素数据
5、every
作用：判断数组中所有元素是否全都满足条件，如果全部满足返回true,否则false
语法：
var newArr = arr.every(function(item,index,arr){
return item > 1
})
返回值：true | false
6、some
作用: 数组中只要有元素满足指定的条件,只要有一个满足返回true
语法：
var newArr = arr.some(function(item,index,arr){
return item > 1
})
返回值：true | false
7、reduce
作用: 累加求和 & 遍历
语法：
var newArr = arr.reduce(function(s,item,index){
return s + item //返回的是s的新的值 累加完毕后赋值给newArr
}，0)
返回值：累加的和
参数：两个
第一个：匿名函数(累加，变量)
第二个0：累加和变量S的初始值

04交换数组中两个数的位置

     * 交换数组元素
     * arr 数组
     * i 索引号
     * k 索引号
     //总结的交换数组元素的公式
    function swap(arr,i,k){ //arr数组 i&k 索引号
        var temp = arr[i];
        arr[i] = arr[k]
        arr[k] = temp;
    }
    function text3(){
        var arr = [12,23,34,566]
        swap(arr,1,3)   //直接使用
        console.log(arr);
    }
    text3()

05排序 （算法）面试题+笔试题

    排序: 将一组无序的数据按从小到大或从大到小顺序排列
    
     [98,86,78,66,82]
     由小到大排序后
     [66,78,82,86,98]

    1、冒泡排序，实现排序的一种算法
        思想: n个数进行冒泡排序, 需要n-1次冒泡,
             每次冒泡操作：相邻两个数，两两比较，前一个数比后一个大，交换位置,一轮比较最大数沉底
            0  第一次冒泡: 比较次数 n-1 -0
            1  第二次冒泡: 比较次数 n-1 -1
            i  第二次冒泡: 比较次数 n-1 -i

         请对下列n个数进行冒泡排序?
         
          //外层循环, n个数进行冒泡排序, 需要n-1次冒泡
          for(var i = 0; i < n-1; i++){
              //内层循环,相邻两个数，两两比较，前一个数比后一个大，交换位置
              for(var j = 0; j < n - 1 -i; j++){
                  if(arr[j] > arr[j+1]){
                      var temp = arr[j]
                      arr[j] = arr[j+1]
                      arr[j+1] = temp
                  }
              }
          }

    //由小到大排序
    function maoSort(){
        var arr = [98,86,79,68,90,82]
        var n = arr.length;
        //外层循环, n个数进行冒泡排序, 需要n-1次冒泡
        for(var i = 0 ;i < n-1;i++){
            //内层循环,相邻两个数，两两比较，前一个数比后一个大，交换位置
            for(var j = 0; j < n - 1 - i;j++){
                if(arr[j] > arr[j+1]){
                    var temp = arr[j];
                    arr[j] = arr[j+1]
                    arr[j+1] = temp;
                }
            }
        }
        console.log('由小到大排序',arr);
    }
    maoSort()

     //由大到小排序
     function maoSort1(){
        var arr = [98,86,79,68,90,82]
        var n = arr.length;
        //外层循环, n个数进行冒泡排序, 需要n-1次冒泡
        for(var i = 0 ;i < n-1;i++){
            //内层循环,相邻两个数，两两比较，前一个数比后一个小，交换位置
            for(var j = 0; j < n - 1 - i;j++){
                if(arr[j] < arr[j+1]){
                    var temp = arr[j];
                    arr[j] = arr[j+1]
                    arr[j+1] = temp;
                }
            }
        }
        console.log('由大到小排序',arr);
    }
    maoSort1()

    2、选择排序
    思想：
     首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置（交换位置）
     再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
     重复第二步，直到所有元素均排序完毕。
    
    //由大到小
    function selectSort() {
        var arr = [86, 79, 98, 68, 90, 82]
        var n = arr.length
        //外层循环，n个数进行n-1次选择排序
        for (var j = 0; j < n - 1; j++) {
            //内层循环
            //核心思想: 在未排序的数中找最大数索引号,与未排序的第一个交换位置
            var maxIndex = j //最大数索引号 j:0
            for (var i = j + 1; i < n; i++) { //不用和自己比较 i= j+1
                if (arr[i] > arr[maxIndex]) {
                    maxIndex = i //maxIndex: 2
                }
            }

            //交换位置
            var temp = arr[j]
            arr[j] = arr[maxIndex]
            arr[maxIndex] = temp
        }
        console.log('由大到小 ',arr);
    }
    selectSort()

    // 由小到大 
    function selectSort1() {
        //外层循环 n个数进行n-1次循环
        var arr = [86, 79, 98, 68, 90, 82]
        var n = arr.length
        for (var j = 0; j < n - 1; j++) {
            //内层循环 从未排序的数中找最小数，找到索引号，与未排序的数中的第一个进行交换位置
            var minIndex = j; //记录最小值的索引号
            //依次让后面的数与最小值进行比较，如果比最小值小，把值赋给min
            for (var i = j + 1; i < n; i++) {
                if (arr[i] < arr[minIndex]) {
                    minIndex = i; // 79<86 最小索引号 = 1
                }
            }
            //交换位置
            var temp = arr[j];
            arr[j] = arr[minIndex]
            arr[minIndex] = temp
        }
        console.log("由小到大排序是",arr);
    }
    selectSort1(