1. 冒泡排序
// 1.外层循环-1
// 2.内层循环-1又-i
// 3.内循环相邻个比较大小
// 4.邻里交互位置
//交互位置
// 0 1
// var arr = [11, 22];
// var temp = arr[0];//备份了一份 11
// arr[0] = arr[1];
// arr[1] = temp
// var temp = arr[1];
// arr[1] = arr[0];
// arr[0] = temp;
// [6, 5, 7, 4, 3]; //i=0
// 1轮
// [5, 6, 7, 4, 3]; 1趟
// [5, 6, 7, 4, 3]; 2趟
// [5, 6, 4, 7, 3];
// [5, 6, 4, 3, 7]; //出现了最大的 7
// 2轮
// [5, 6, 4, 3]; //出现了最大的 7
// [5, 4, 6, 3];
// [5, 4, 3, 6]; //出现了最大的 6,7
// [4, 5, 3]; //出现了最大的 6,7
// [4, 3, 5];
// [4, 3]; //出现了最大的 5, 6,7
// // [3, 4]; //出现了最大的4, 5, 6,7
// // [11,22]
var arr = [5, 6, 7, 4, 3];
// 2个数,比较1轮,同理,5个数,比较4轮
for (var i = 0; i < arr.length - 1; i++) {
// -1 防止下标越界, j+1 ,容易出现越界
for (var j = 0; j < arr.length - 1 - i; j++) {
// 前一个数和后一个数,比较 是 j 和 j+1
if (arr[j] < arr[j + 1]) {
var temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
console.log(arr);
//1.为什么外循环要-1?
//2.为什么内循环要 -1又减-i;
// -1 防止下标越界, j+1 ,容易出现越界
//3.比较的时候,为什么是j和j+1;
// 前一个数和后一个数,比较
2. 选择排序
// 打擂台,
//台上和台下的比较
var arr = [5, 6, 7, 4, 3];
//外出循环是台上
for (var i = 0; i < arr.length - 1; i++) {
// 认为 第一个上台的人,能够赢
var win = i;
//内层循环,是台下
for (var j = i + 1; j < arr.length; j++) {
if (arr[win] < arr[j]) {
win = j;//改win的值
}
}
//交互位置
if (win != i) {
var temp = arr[win];
arr[win] = arr[i];
arr[i] = temp;
}
}
console.log(arr);
3. 快速排序
// [4,8,3] //3/2=1.5 取整-->1
//[5, 6, 7, 4, 3];
//1.定义个方法,输入一个数组
//2.如果数组的长度小于2,就返回输入的数组 (小于2个,没办法比较)
//3.如果是大于等于2,找出下标,遇到不能被整除,向下取整
//4.通过中间下标,得到中间数,并且要从原来数组扣出来
//5.准备2个空数组,左边和右边的空数组
//6.大于中间数 放置 右边数组,否则放置左边数组
//7. 递归进行继续拆,拆到只有1个数的数组,就不拆
// 进行合并 左边数组+中间+右边数组
//1.定义个方法,输入一个数组
function quickSort(arr) {
// 2.如果数组的长度小于2,就返回输入的数组 (小于2个,没办法比较)
if (arr.length < 2) {//临界点
return arr; //返回数组
}
//3.如果是大于等于2,找出下标,遇到不能被整除,向下取整
var middleIndex = parseInt(arr.length / 2);
//4.通过中间下标,得到中间数,并且要从原来数组'扣'出来
var middleVal = arr.splice(middleIndex, 1)
//5.准备2个空数组,左边和右边的空数组
var left = [], right = [];
//6.大于中间数 放置 右边数组,否则放置左边数组
for (var i = 0; i < arr.length; i++) {
if (arr[i] > middleVal) {
right.push(arr[i])
} else {
left.push(arr[i]);
}
}
//7. 递归进行继续拆,拆到只有1个数的数组,就不拆
// 进行合并 左边数组+中间+右边数组
return quickSort(left).concat(middleVal, quickSort(right))
}
4. 高阶函数
// es3
// pop,push,shift,unshift,sort,reverse(),concat(),join,slice,splice
// es5 高阶函数
// forEach,map,some,ervey,filter,reduce ,indexof
// es6
// find,findIndex,includes
//1.forEach,只能做遍历,没有返回值
// 不能被中断
// 可以制造异常,结合 try..catch 中断
var arr = [11, 22, 33, 44, 55];
try {
arr.forEach(function (item, index, aaa) {
console.log(item, index, aaa);
if (index == 2) {
throw new Error("制造异常")
}
})
} catch (error) {
}
console.log("11111");
//2.map 能做遍历,返回一个新的数组
// 新数组的内容,由回调函数决定
var arr = [11, 22, 33, 44, 55];
var res = arr.map(function (item, index, arr) {
return item * 10
});
console.log(res);
console.log(arr);
//3.some 只要有1个满足,就返回true
// 在遍历过程中,条件满足,就中断遍历
var arr = [11, 22, 33, 44, 55];
var res = arr.some(function (item) {
console.log(item);
return item == 99
});
console.log(res);
//4. ervery 所有的满足条件,才会返回true,默认返回false
var arr = [11, 22, 33, 44, 55];
var res = arr.every(function (item) {
return item > 10
});
console.log(res);
//5.filter过滤 返回新的数组,数组的内容由回调函数的条件决定
var arr = [11, 22, 33, 44, 55];
var res = arr.filter(function (item) {
return item > 30;
})
console.log(res);
//6.find (ES6)
// 通过条件,查找某一项,如果存在,就返回这一项
var arr = [
{ id: 1, name: "刘德华", age: 20 },
{ id: 2, name: "蔡徐坤", age: 21 },
{ id: 3, name: "吴彦祖", age: 23 },
{ id: 4, name: "彭于晏", age: 24 }];
var res = arr.find(function (item, index) {
return item.id == 4
});
console.log(res);
//7.findIndex (es6)
// 返回满足条件某一项的下标
var arr = [
{ id: 1, name: "刘德华", age: 20 },
{ id: 2, name: "蔡徐坤", age: 21 },
{ id: 3, name: "吴彦祖", age: 23 },
{ id: 4, name: "彭于晏", age: 24 }];
var index = arr.findIndex(function (item) {
return item.id == 3
})
console.log(index);
//8.indexOf
// 找到了返回下标,找不到返回-1
// 它有2个参数,第2个参数默认是从0开始,也可以指定开始位置
var arr = [11, 22, 33, 44, 55];
console.log(arr.indexOf(22, 2)); //22的下标是1
//9.lastIndexOf
var arr = [11, 22, 33, 44, 55, 22, 88, 22, 77];
console.log(arr.lastIndexOf(22, 3));//用得少
//10.includes
var arr = [11, 22, 33, 44, 55, 22, 88, 22, 77];
console.log(arr.includes(100));
// find,findIndex,indexOf,lastIndexOf,includes
//10.reduce
// typescript
var arr = [11, 22, 33, 44, 55];
//现在的reduce只传入了一个参数 回调函数
//pre是上一次回调函数的返回值,没就是undefined
// arr.reduce(function (pre, cur, index, arr) {
// console.log(pre, cur);
// })
// reduce有2个参数,第1个参数是回调函数,第2参数给pre的初始值
var arr = [11, 22, 34, 44, 55];
// arr.reduce(function (pre, cur) {
// console.log(pre, cur);
// return 1
// }, 100)
// arr.reduce(function (pre, cur) {
// console.log(pre, cur);
// return 1
// })
var res = arr.reduce(function (pre, cur) {
// pre 11 cur 22 -->33
// pre 33 cur 34 -->67
// pre 67 cur 44 -->111
// pre 111 cur 55 --> 166
return pre + cur; //这个return决定了下一轮循环pre的值
});
console.log(res); //166
//数组去重
var arr = [1, 5, 7, 2, 5, 7, 1, 2, 5, 8, 6];
function notRepeat(list) {
var newArr = [];//新的空数组
for (var i = 0; i < list.length; i++) {
//把每一项放到空数组,在放到空数组之前,问 是否已存在,
//如果存在,就不添加
// if (newArr.indexOf(list[i]) == -1) {
// newArr.push(list[i])
// }
// includes 找到了返回true,找不到返回false
if (!newArr.includes(list[i])) {
newArr.push(list[i])
}
}
return newArr;
}
console.log(notRepeat(arr));
//es3
//1.pop()
//2.push()
//3.shift()
//4.unshift();
//5.sort();
//6.reverse()
//7.slice()
//8.splice()
//9.concat()
//10.join
//es5
//11.forEach()
//12.map()
//13.some()
//14.every()
//15.filter()
//16.reduce()
//es6
//17.find()
//18.findIndex()
//19.includes()
//20.indexOf()
6. 数组的练习
// 1, 求数组中所有元素的和
var arr = [11, 22, 33, 44, 55];
var result = 0;//用于统计结果
for (var i = 0; i < arr.length; i++) {
result += arr[i];
}
console.log(result);
// 2, 让数组中的元素交换位置（重要）
var arr = [11, 22];
var temp = arr[0];// 11
arr[0] = arr[1]; // [22,22];
arr[1] = temp;
console.log(arr);
// 3, 求数组的最大数和最小数（重要）
var arr = [3, 7, 5, 2, 8, 6];
//假设第1个事最大的
var max = arr[0];
var min = arr[0];//假设第一个是最小的
for (var i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
if (min > arr[i]) {
min = arr[i]
}
}
console.log(max);
console.log(min);
// 4, 求数组的最小数的下标（重要）
var arr = [3, 7, 5, 2, 8, 6];
var min = arr[0];//假设第一个是最小的
var minIndex = 0;
for (var i = 1; i < arr.length; i++) {
if (min > arr[i]) {
min = arr[i];
minIndex = i;
}
}
console.log(minIndex);
// 1, 不改变原数组, 取出数组[3,2,4,5,8,6,3,9]中的[5,8,6].
var arr = [3, 2, 4, 5, 8, 6, 3, 9]; // 3 6
console.log(arr.slice(3, 6));
// 2, 在数组[1,2,3,4,6,7,8]中对应的位置插入5, 变成[1,2,3,4,5,6,7,8]
var arr = [1, 2, 3, 4, 6, 7, 8];
arr.splice(4, 0, 5)
console.log(arr);
// 3, 将数组 ["我","是","一","只","笨","鸟"] 改成
// ["我","是","一","只","聪","明","鸟"], 并打印出: "我是一只聪明鸟"
var arr = ["我", "是", "一", "只", "笨", "鸟"];
arr.splice(4, 1, "聪", "明");
console.log(arr.join(""));
// 4, 删除数组[20,23,21,34,54,55,32]中的倒数第二个和倒数第三个元素
var arr = [20, 23, 21, 34, 54, 55, 32];
arr.splice(4, 2);
console.log(arr);
// 1, 将数组[1, 5, 6, 3, 2, 8, 9, 4] 降序排序
var arr = [1, 5, 6, 3, 2, 8, 9, 4];
arr.sort(function (a, b) {
return a - b;
})
console.log(arr);
// 2, 请将数组[1,46,74,3,5,5]中的元素右移1位
var arr = [1, 46, 74, 3, 5, 5]
arr.unshift(arr.pop());
console.log(arr);
// 3, 插数:在数组[1,46,74,3,5,5]的下标为2的位置插入一个数字8，
// 结果为[1,46,8,74,3,5,5]
var arr = [1, 46, 74, 3, 5, 5];
arr.splice(2, 0, 8);
console.log(arr);
回顾:
1.数组的方法
pop() 删除最后一位,返回被删除的元素
push() 往最后位置添加(1个或多个),返回数组的新长度
shift() 删除数组的第一位,返回被删除的元素
unshift() 往数组的第一位添加(1个或多个)元素,返回数组的新长度
sort() 它是默认根据ASCII码,进行排序 (10以上的数字,无法准确的排序)
给它一个回调函数(callback), a-b 升序,b-a 降序
reverse() 倒序
concat() 合并数组
slice() 截取,不会改变原来数组
splice() 删除,插入,替换
join() 根据指定格式返回字符串,默认是以"逗号"隔开
能够实现浅拷贝的方法
slice(),concat()
for和for..in
for是根据数组的长度,决定遍历的次数
for..in,根据数组的成员,来决定次数
