js数组常用方法和排序算法

数组调用方法

数组中的索引有很多作用，下面是四种作用：

1,通过索引下标,调用数组中,指定单元的数据

    var arr = ['北京','上海','广州','重庆','天津'];
    arr[0] ---> 调用索引下标是 0 ,实际是第一个单元的数据 北京

2,通过索引下标,来修改数组中,存储的单元的数据

    对已存在的索引下标,进行赋值,进行的是重复赋值,会覆盖之前存储的数据
    arr[0] = '武汉';
    console.log(arr);

3,通过索引下标,来新增数组的单元

    对不存在的索引下标,进行赋值,是新增数组单元的操作
    arr[5] = '郑州';        //连续索引 

    arr[100] = '瞎写的';     //间隔索引
	console.log(arr);

4,通过索引下标,来删除数组的单元

	定义数组的length长度属性,通过定义数组的单元个数,来删除数组的单元
    只能是从数组的结尾处开始删除单元,不能从数组的起始开始删除单元
    一般不使用,除非是一定要限制数组长度

    arr.length = 100;
    arr.length = 6
    console.log(arr);

数组常用方法

1.unshift()方法
数组变量.unshift(新增的数据) 在数组的起始位置新增单元
数组变量.unshift(数据1,数据2,数据3…) 可以新增多个单元,之间使用逗号间隔
新增的单元可以是任意JavaScript支持的数据类型


2.push()方法
数组变量.push(新增的数据) 在数组的结束位置新增单元， 比较常用
数组变量.push(数据1,数据2,数据3…) 可以新增多个单元,之间使用逗号间隔
新增的单元可以是任意JavaScript支持的数据类型
push()是最常用的数组方法,用于向数组中添加内容


从数组中删除单元(,也称为 抛出 释放 消除)，不常用
数组.shift(无参数) 只能删除起始的第一个单元 arr.shift();
数组.pop(无参数) 只能删除结束的最后一个单元 arr.pop();

注意: 新增可以是一个或者多个， 删除一次只能一个

    unshift()  push() 新增单元操作,返回值都是新增单元之后,数组新的长度,也就是length属性值
    shift()  pop()  删除单元操作,返回值都是删除单元存储的数据信息
    var arr = [1,2,3,4,5];
    // 定义一个变量,来存储返回值,当然也可以直接输出操作
    // 操作之后,新增单元执行,数组新的长度
    var res1 = arr.unshift('北京');
    var res2 = arr.push('北京');
    console.log(arr);
    console.log(res1);       
    console.log(res2);
	以上返回值就是数组长度
	
    // 删除操作,返回值是删除单元的数据信息
    var res3 = arr.shift();
    console.log(res3);

3.splice()方法

	数组.splice()
    参数1: 删除起始单元的位置---索引下标
    参数2: 从起始单元开始,删除单元个数---删除几个单元
    参数3: 在删除的位置上,插入的新的数据

替换插入的数据,可以是一个,可以是多个,多个单元之间使用逗号间隔
也可以任意JavaScript支持的数据类型

     如果只写一个参数,是从删除位置开始,删除之后所有的单元,包括起始位置单元
     arr.splice(2);

     如果不写参数,没有效果的
     arr.splice();

     写三个参数单元执行效果类似于替换操作
    从索引下标是2,实际是第三个单元开始,删除2个单元(包裹索引2的单元)
    然后替换插入数据 武汉 , 加油
    var res2 = arr.splice(2,2,'武汉','加油');

    console.log(arr);
    console.log(res2);

4.sort()方法

将数组中的数据按照数值大小来进行排序

     数组.sort()  默认按照首位数值排序,不是数值的实际大小
     数组.sort( function(a,b){return a-b} )  按照数值的实际大小排序 --- 从小到大 的固定语法形式
     数组.sort( function(a,b){return b-a} )  按照数值的实际大小排序 --- 从大到小的固定语法形式

     var arr = [3,21,3215432,321321,32,43,5,34,43,23,32543,1234,45,321,14,234,4];
     
      数组的排序方法
      arr.sort();

数组不常用方法

1.reverse()方法

     数组.reverse();

     将数据库中,数组最后的最新的消息,反转到最上方先显示

     var arr = ['北京','上海','广州','重庆','天津'];

     arr.reverse();

     console.log(arr);   输出是 ["天津", "重庆", "广州", "上海", "北京"]

2.join()方法

	  数组和字符串的转化
      数组.join()  不会改变原始数组的内容
      返回值是字符串类型,内容是数组中每个单元存储的数据信息,默认使用逗号间隔
      遵守其他数据类型转化为字符串类型的自动转化原则

    var arr = ['北京','上海','广州','重庆','天津',true,false,100,[1,2,3,4],{name:'张三'},function fun(){}];

    // 默认逗号间隔
    var res1 = arr.join();
    // 设定间隔符号   
    var res2 = arr.join('-');   
    // 没有间隔符号,设定空字符串作为间隔  
    var res3 = arr.join('');  

    // console.log(arr);
    // console.log(res1);
    // console.log(res2);
    // console.log(res3);

3.concat()方法

    数组的拼接
    数组1.concat(数组2)
    将两个数组,拼接为一个数组
    将来两个数组的数据内容进行拼接

    var arr1 = [1,2,3,4,5];
    var arr2 = ['北京','上海','广州','重庆','天津'];

    var arr3 = arr1.concat(arr2);
    console.log(arr3);   输出结果如下：

数组排序算法

1.冒泡排序

原理: 相邻的两个单位,比较存储的数据
如果第一个单元的数据较大,就将两个相邻单元,交换存储数据

 过程: 
     从起始单元开始比较,第一次循环,会选择出一个最大值,放在数组所有单元的最后
     之后,每次循环,都会比较出一个本次循环的最大值,放在当前参与比较单元的最后
     之前已经比较选出的单元,不会参与下一次比较

 优化: 
     1, 单次循环,最后一个单元,通过倒数第二个单元,参与比较
        最后一个单元,就不参与单次循环
     2, 之前比较出的最大值,不再参与下一次的比较

     3, n个单元,只要循环比较n-1次,最后就一个单元时,不要再循环比较

      核心: 交换存储的数据

            两个相邻的单元,比较数据大小,第一个单元数值较大,就交换两个单元存储的数据

代码如下：

2.选择排序
原理：循环的获取最小值所在位置（即索引），然后通过索引交换数据。

过程：默认起始位置为最小值
     从起始位置下一个位置开始,执行循环
     如果有位置上的数值,小于,存储索引位置上的数值
     就存储这个位置的索引值

   循环结束,比较存储的索引,是否是起始位置索引
   如果不是,就交换两个位置上的数值
   会将本次循环的最小值,放置在循环的起始位置上
   再执行多次循环,完成排序

核心 : 找到最小值的索引,与起始位置交换数值
      先找索引 在交换数值

优化 : 1,之前比较的数值不参与一次标记
      2,n个单元,只要比较n-1次

代码如下：

排序方式的优缺点：

		选择排序:
                如果发生大小顺序问题,只是做赋值索引的操作
                等循环完成,执行判断,做一次数据交换
             
     	 冒泡排序:
                每次发生大小顺序问题,都要执行数据交换操作
                执行数据交换的次数,高于选择排序

            冒泡排序执行数据交换的操作比较繁琐,执行次数过多,执行效率低，所以是选择排序执行效率高些

扩展：无论是选择还是冒泡排序，只要改变内层循环中判断语句中的＞或<号就会有两种不同的排序方式（从小到大或从大到小）