JavaScript数组及排序

数组的创建

数组：有序的值的集合。通常来讲，数组中的元素类型均保持一致。
数组的创建有字面量和构造函数两种方式。
1、字面量：[]里面的值为数组元素；如果[]为空时，就创建一个空数组

var arr=[1,2,33];
console.log(typeof arr);  //object

console.log(arr[0]);      //取到第一个元素
console.log(arr.length);  //取到数组的长度
console.log(arr[arr.length-1]); //取到数组中的最后一个元素，无论数组中有多少个值
console.log(arr[arr.length]);   //如果索引下标越界，则取到undefined

var arr1[9] = 10;
console.log(arr1,arr1.length);
//第十个数是100，前九个数根据浏览器的不同，显示empty或undefined

2、构造函数：
没有参数时，创建一个空数组；
一个参数时，表示数组的长度，元素都为empty；
多个参数时，表示数组的每一项元素

var arr2 = new Array();
console.log(arr2);  //输出空数组 []

var arr3 = new Array(2);
console.log(arr3);  //输出空数组 [empty * 2]

var arr4 = new Array(2,3,4);
console.log(arr4);  //输出数组 [2,3,4]

数组的操作

1、push / pop / unshift / shift

var arr = [11,22,33];
var a = arr.push(1,2,45);
console.log(a,arr);  // 6 [11,22,33,1,2,45]
//push把参数增加到数组的尾部，可有多个参数
//返回值为增加后的数组长度

var a = arr.pop();
console.log(a,arr);  // 45 [11,22,33,1,2]
//pop从数组的尾部中删除元素，函数没有参数
//返回值为删除的元素值

var a = arr.unshift(100,200);
console.log(a,arr);  // 7 [100,200,11,22,33,1,2]
//unshift与push类似，只是把参数增加到数组的头部
//返回值为增加后的数组的长度

var a = a.shift();
console.log(a,arr);  //100 [200,11,22,33,1,2]
//shift与pop类似，只是从数组的头部中删除元素，函数没有参数
//返回值为删除的元素值

2、slice / splice

var arr = [11,22,33,44,55];
var a = arr.slice(2,4);
console.log(a,arr); //[33,44] [11,22,33,44,55]
//slice 一个参数：表示从该参数对应的索引位开始截取，直到数组结束
//slice 两个参数：表示从第一个参数对应的索引值开始截取，直到第二个参数对应的索引值（不包括第二个索引值）
注：slice不会改变原数组

var a = arr.splice(1,2,200);
console.log(a,arr); //[22,33] [11,200,44,55]
//splice 一个参数：表示从该参数对应的索引位开始截取，直到数组结束
//splice 两个参数：第一个参数表示开始截取的索引位，第二个参数表示截取数组的长度
//splice 三个及以上参数：前两个参数含义与上面一致
//       第三个及以后的参数表示从截取的地方重新添加的元素值
注：splice会改变原数组

3、reverse / sort

var arr = [8,5,7,111,2];
arr.reverse();
console.log(arr); // [2,111,7,5,8]
//reverse 反转函数，把数组元素从头到尾颠倒位置

arr.sort(function(a,b){
	return a - b;
})
console.log(arr); // [2,5,7,8,111]
//sort 排序函数，如果只写arr.sort() 是按位比较，不符合我们习惯的排序规则
//使用上述的arr.sort(function(){
//	return a - b;
//})
//是从小到大进行排序
//如果需要从大到小进行排序，return b - a;

4、join

// 将数组中的每个元素拼接在一起，拼接为字符串
// join不改变原数组的值
var a = arr.join("----");
console.log(a);
//2----5----7----8----111

5、concat

//两个数组进行拼接，结果仍是一维数组
//返回值为拼接的新数组
//注：concat不改变原数组的值
var a = arr.concat([123,456]);
console.log(a,arr); // [2,5,7,8,111,123,456] [2,5,7,8,111]

对象数组和二维数组

数组中元素类型为对象的数组称为对象数组。

var persons = [{name:"join",age:20},{name:"join1",age:22}];
//如何取到join1？
console.log(persons[1].name); // join1

数组中元素类型仍为数组的数组称为二维数组。

var arr = [[1,2],[3,4]];
//如何取到4？
console.log(arr[1][1]); //4

for-in循环

//for-in通常用来遍历对象，（遍历数组通常使用for循环，根据索引值遍历）

//对象 属性值
var obj = {a:1,b:2};
for(var i in obj){
	// i 是 属性名字符串 a b
	console.log(i);
	// 正确输出1 2 ,相当于obj["a"] obj["b"]
	console.log(obj[i]);
}

冒泡排序 选择排序

冒泡排序：数组中的值两两进行比较，如果第一个值比第二个大，交换位置。
  每一轮能排出该轮中最大的数

var arr1 = [12,5,8,3,15];
function bubbleSort(arr){
	//每一轮都能确定一个最大的数
				
	//外层循环控制比较的轮数
	for(var i=0;i<arr.length-1;i++){
		//内层循环控制每轮比较的次数
		for(var j=0;j<arr.length-1-i;j++){
			//比较
			//如果前面的数大于后面的数,交换位置
			if(arr[j]>arr[j+1]){
				var temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}				
	}		
	return arr;
}
			
console.log(bubbleSort(arr1));

选择排序：假设每一轮中的第一个值为最小值。
  设置minIndex存放最小值的索引。
  如果有比minIndex值更小的,改变minIndex指向。
  一轮之后,能比较出该轮的最小值,让最小值和该轮的第一个值交换位置。

function selectSort(arr){
	for(var i =0; i<arr.length-1; i++){
		var minIndex = i;
		for(var j=i+1;j<arr.length;j++){
			if(arr[minIndex] > arr[j]){
				minIndex = j;
			}
		}
		var temp = arr[i];
		arr[i] = arr[minIndex];
		arr[minIndex] = temp;
	}
	return arr;
}
console.log(selectSort(arr1));

函数的值传递和引用传递

var a = 10;
function foo(b){
	b = 20;
}
foo(a);
console.log(a); // a的值仍是10
			
var arr =[10];
function foo1(brr){
	brr.push(20);
	// 一旦重新赋值,就和arr没有关系了,重新指向了一个新的地址
	brr = [];
	brr.push(30);
}
foo1(arr);
console.log(arr); // [10,20] 数组是引用类型，实参传形参，传递的是地址

数组去重的五种方式

1、从第一个数开始，依次与该数之后的数组元素进行比较，如果相等，则删除之后的数组元素，数组会发生变化。

function norepeat(arr){
	for(var i=0 ; i<arr.length-1 ; i++){
		for(var j=i+1; j<arr.length; j++){
			if(arr[j] === arr[i]){
				arr.splice(j,1);
				// 删除数组之后,原数组发生改变,j正常累加,会有遗漏
				// j--抵消一下
				j--;
			}
		}
	}
	return arr;
}

2、把数组进行sort排序，从左向右比较相邻的两个数，如果相等，则删除后面的数组元素。

function norepeat1(arr){
	arr.sort();
	for(var i=0;i<arr.length-1;i++){
		if(arr[i] === arr[i+1]){
			arr.splice(i+1,1);
			i--;
		}
	}
	return arr;
}

3、结合数组和对象来实现数组去重。数组中的元素看做对象的属性，对象如果访问一个不存在的属性，默认取到undefined。

function norepeat2(arr){
	var newArr = [];//newArr数组为了放不重复的数组元素
	var obj = {};   //首先创建一个空对象,没有属性
				
	//for循环,遍历arr数组
	for(var i = 0 ; i<arr.length ;i++){
		// 对象如果访问一个不存在的属性,默认取到undefined
		if(obj[arr[i]] === undefined){   //如果对象中不存在属性名为arr[i]的属性
			// 给obj对象添加属性名为arr[i]的属性并赋值,赋值可为任意数
			// 目的主要是给obj对象添加属性名
			obj[arr[i]] = 1;
			//说明之前obj对象中没有arr[i]属性,即arr[i]这个数在数组之前没有出现过
			// 添加到newArr数组中
			newArr.push(arr[i]);
		}
	}
	return newArr;
}

4、通过数组的indexOf(item)，返回item在数组中的索引值进行判断，如果元素item未存在数组中，返回值为-1

var arr = [1,2,3,1,2,3,1,2,2,4];
function norepeat(arr){
	var newArr = [];
	for(var i=0; i<arr.length ; i++){
		// indexOf(item) 返回item在数组中的索引,无就返回-1
		if(newArr.indexOf(arr[i]) == -1){
			newArr.push(arr[i]);
		}		
	}
	return newArr;
}
console.log(norepeat(arr));

5、ES6新增方法

let arr = [1,1,2,5,2];
let set = new Set(arr);
let arr1 = [...set];
console.log(arr1);

案例

有一个从小到大排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

function ascSort(arr,num){
	arr.push(num);
	arr.sort(function(a,b){
		return a-b;
	})
	return arr;
}
			
function ascSort1(arr,num){
	for(var i=0;i<arr.length;i++){
		if(num <= arr[i]){
		    // 在索引值i处，添加num元素
			arr.splice(i,0,num);
			return arr;
		}
	}
	arr.push(num);
	return arr;
}