随手笔记06-有关数组的算法和方法

数组定义

数组可以把一组相关的数据一起存放，并提供方便的访问(获取）方式。
数组是指一组数据的集合，其中的每个数据被称作元素，在数组中可以存放任意类型的元素。数组是一种将一组数据存储在单个变量名下的优雅方式。
引用类型：存储分两部分，在堆中保存数据，在栈中保存地址

typeof 经常用来检测基本数据类型 检测引用类型时，结果object
若想精确判断应用类型，instanceof 返回的是一个布尔型

var arr=[];
console.log(typeof arr);//object
console.log(arr instanceof Array);//true 

数组的一些方法

方法	描述
push ()	向数组末尾添加元素 (可以一次性添加多个元素)
pop()	删除数组末尾元素
shift()	删除数组中的第一个元素
unshift()	在数组头部插入元素(可以一次性增加多个元素)
splice()	用于插入、删除或替换数组的元素
sort()	默认按照ASCII码进行排序(可自定义排序)
reverse()	数组倒序
concat ()	合并数组 (拼接数组可多参)
slice()	分割数组
IndexOf()	判断元素在数组中的位置，找不到返回-1
join()	按照指定字符将数组元素拼接为字符串

数组新方法

注意：迭代方法IE8之下不支持
迭代方法，这些方法都可以实现数组的遍历

方法	描述
forEach()	接收一个函数作为参数(函数有三个参数，分别是：item/index/arr) 遍历数组
every()	返回布尔型 若每一个元素都满足条件返回true
some()	返回布尔型 若有一个元素满足条件就返回true
filter()	返回新数组 把满足条件的元素过滤出来存放到新数组里
map()	返回新数组 将所有元素根据规则统一生成一个新数据放到数组里

排序算法

• 选择排序法

当前元素分别和后面所有的元素作比较，发现小的，交换位置

var arr = [4, 3, 2, 1, 5, 6, 7, 9, 8, 0];
        //外层控制循环趟数
        for (var i = 0; i < arr.length; i++) {
            var temp = arr[i];
            //内层控制每一趟走的次数
            for (var j = i + 1; j < arr.length; j++) {
                //如果发现更小的的数，进行交换 
                if (temp > arr[j]) {
                    arr[i] = arr[j];
                    arr[j] = temp;
                    temp = arr[i];
                }
            }
        }
        console.log(arr);
        //----------控制台输出------------
        //(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 冒泡排序法

相邻元素作比较，交换位置(大的放后面)

 // 冒泡法:相邻元素作比较，交换位置(小的在前面)
        var arr1 = [4, 3, 2, 1, 5, 6, 7, 9, 8, 0];

        //外层控制多少趟
        for (var i = 0; i < arr1.length; i++) {
            //内层控制每趟走多少次，每趟次数减少1（内层循环次数减少1）
            for (var j = 0; j < arr1.length - i; j++) {
                if (arr1[j] > arr1[j + 1]) {
                    var temp = arr1[j];
                    arr1[j] = arr1[j + 1];
                    arr1[j + 1] = temp;
                }
            }
        }
        console.log(arr1);
        //----------控制台输出------------
        //(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 快速排序法

一、先选择一个基准数，数组中的其它数据分别和这个基准数进行比较，
二、将小于基准数的数字放入一个数组中，将大于基准数的数字放入另一个数组中
三、重复这个过程 （利用递归函数重复）

 // 快速排序：算法比较快   又被称为：分治法 或 冒泡排序增强版

        //     一、先选择一个基准数，数组中的其它数据分别和这个基准数进行比较，
        //     二、将小于基准数的数字放入一个数组中，将大于基准数的数字放入另一个数组中
        //     三、重复这个过程
        var arr = [3, 4, 1, 2, 5, 43, 123, 4, 42, 6];
        // 递归函数
        function fn(arr) {
            // 函数的终止条件
            if (arr.length <= 1) {
                return arr;
            }
            // 获取基数的索引   
            var index = Math.floor(arr.length / 2);
            //保存基数	arr.splice(index, 1)返回的是一个数组，取第0个
            var numValue = arr.splice(index, 1)[0];
            // 两个新数组保存
            var left = [],
                right = [];
            //根据基数对剩余数组进行分类
            for (var i = 0; i < arr.length; i++) {
                if (numValue > arr[i]) {
                    left.push(arr[i]);
                } else {
                    right.push(arr[i]);
                }
            }
            // 返回值 递归函数  左边的数组拼接上基数和右边的数组
            return fn(left).concat(numValue, fn(right));
        }
        var arr1 = fn(arr);
        console.log(arr1);

数组去重

 // 1.遍历整个数组，拿每一个数，去跟其他数依次比较
        var arr = [1, 2, 3, 4, 4, 4, 2, 3, 1, 6];
        //控制做比较的数 控制趟数
        for (var i = 0; i < arr.length; i++) {
            //拿外层的数，跟其他数依次比较 拿i去比较j
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[i] === arr[j]) {
                    //删除j
                    arr.splice(j, 1);
                    //解决删除j后，数组长度发生变化，
                    j--;
                }
            }
        }
        console.log(arr);

函数的递归

 //计算10的阶乘
        // var s = 1;
        // for (var i = 10; i > 0; i--) {
        //     s *= i;
        // }
        // console.log(s);

        //递归函数
        function fn(n) {
            if (n == 1) {
                return 1;
            }
            return n * fn(n - 1);
        }

        var num = fn(10);
        console.log(num);
        /*
            分析递归函数执行过程：
                n=10
                    10*fn(9)
                n=9
                    9*fn(8)         10*9*fn(8)
                n=8
                    8*fn(7)         10*9*8*fn(7)

                ...                 10*9*8*...*3*fn(2)
                n=2 
                    2*fn(1)          10*9*8*...*3*2*fn(1)
                n=1
                    1               10*9*8*...*3*2*1
        */