冒泡排序 选择排序 数组
一.冒泡排序
核心原理
循环遍历数组
当前单元和下一个单元进行数据比较
按照从小到大排序
应该是当前单元小于下一个单元
如果当前单元大于下一个单元
将交换两个单元存储的数据
一次循环结束会将一个最大值存储到数组末位
多次循环遍历完成整个数组中数值的排序
案例:
var arr=[10,20,30,40,50];
var n=11;
arr.push(n);
//冒泡排序
for(var k =0; k<arr.length; k++){
for(var i=0; i<arr.length-1-k; k++){
if(arr[i]>arr[i+1]){
var temp=arr[i]
arr[i]=arr[i+1]
arr[i+1]=temp
}
}
}
console.log('冒泡排序结束后的arr',arr);
二.选择排序
核心原理
每次使用变量存储起始循环单元的索引下标
使用变量中存储的索引下标对应的数据数值
和之后的其他单元的数据数值进行比较
如果之后循环单元数据数值小于变量中存储索引下标对应数据数值
变量存储循环单元的索引下标
循环结束 变量中存储本次循环 存储最小值单元的索引下标
如果变量存储的索引下标不是起始单元的索引下标
交换两个单元存储的数据数值
每次循环会将最小值存储到数组的起始位置
多次循环完成整个数组的排序
案例:
for(var k=0; k < arr.length; k++){
for(var i =k+1; i<arr.length; i++){
if(arr[minIndex]>arr[i]){
minIndex=i
}
}
//交换真实最小的值 与下标0的值
var temp=arr[k]
arr[k]=arr[minIndex]
arr[minIndex]=temp
}
console.log('选择排序结束后的arr:',arr)
三、数组
1.概念:存储数据的集合
2.理解:
- 其他数据类型一个变量中只能存储一个数据单元
- 在数组中可以同时存储多个数据单元
3.语法
-
字面量: var 变量=[数据1,数据2,数据3...];
-
内置构造函数: var 变量 = [new Array(数据1,数据2, 数据3);
属性 下标 在定义数组时 JavaScript程序 自动定义的从0开始的连续整数 如果下标是 数值类型 称为 索引下标 在 JavaScript中 下标只支持是数值类型的索引下标 在 其他计算机语言中 数组的下标可以是字符串类型 称为 关联下标 通过 索引下标 使用 []语法 操作 数组中的数据单元 length 数组的长度 也就是 数组中单元个数 语法 数组.length 索引下标是从0开始的连续整数 数组索引下标的范围是 0 至 数组.length-1 数据存储的数据类型 在 JavaScript语言中 数组中可以存储任意 JavaScript支持的数据类型 一个数组中 可以 存储不同类型的数据 数组中存储函数 var arr = [100,200,300,function(){} ]; 一般情况下 数组中 不会存储函数 数组[索引下标] 获取的是 数组单元中存储的内存地址 数组[索引下标]() 是 调用执行 数组中存储的函数
2、数组的操作
1、首位新增：
数组.unshift( 数据1 , 数据2 ... );
在数组的首位新增数据单元,一次可以新增一个单元 或者 多个单元
多个单元之间使用逗号间隔
执行结果返回值：新增单元之后 新数组的长度
2、末位新增：
数组.push( 数据1 , 数据2 ... );
在数组的末位新增数据单元
次可以新增一个单元 或者 多个单元
多个单元之间使用逗号间隔
执行结果返回值：新增单元之后新数组的长度
3、首位删除:
数组.shift();
一次只能删除一个单元
执行结果返回值：删除单元存储的数据数值
4、末位删除:
数组.pop();
一次只能删除一个单元
执行结果返回值：删除单元存储的数据数值
案例：
<script>
var arr = [100,200,300,400,500];
// 首位新增
var res1 = arr.unshift( '北京' , '上海' );
console.log( res1 );
// 末位新增
var res2 = arr.push('贵阳' , '武汉');
console.log( res2 );
// 首位删除
// 删除首位单元 也就是 删除第一个单元
// 第一个单元中存储的数据是 '北京'
var res3 = arr.shift();
console.log( res3 );
var res4 = arr.pop();
console.log( res4 );
console.log( arr );
</script>
5、数组删除指定单元
数组.splice( 参数1 , 参数2 , [ 其他所有参数 ] );
参数1 删除起始位置的索引下标
参数2 删除数组单元的个数 必须是连续的数组单元
其他所有参数 在删除位置替换写入的新内容
可以一次替换写入一个单元 可以 提替换写入多个单元
执行结果返回值 是 删除单元数据 组成的新数组
案例：
<script>
var arr = [100,200,300,400,500,600,700,800,900];
// // 如果要删除 300 400 500 三个单元
// // 是 从 索引下标是 2 的位置开始 删除 3个单元
// // 执行结果返回值 是 删除的 300 400 500 组成的新数组
// var res1 = arr.splice( 2 , 3 );
// console.log( res1 );
// 如果删除 500 600 替换 写入 新内容
var res2 = arr.splice( 4 , 2 , '北京' , '上海' , '广州' , '重庆' , '贵阳' );
console.log( res2 );
console.log( arr );
</script>
6、数组数据的查询
数组.indexOf( 数值数据 )
查询 指定数据 在数组中 第一次 出现的位置
如果有符合的数据 返回值 是 存储数据单元的索引下标
如果没有符合的数据 返回值 是 -1
数组.lastIndexOf( 数值数据 )
查询 指定数据 在数组中 最后一次 出现的位置
如果有符合的数据 返回值 是 存储数据单元的索引下标
如果没有符合的数据 返回值 是 -1
案例：
<script>
var arr = [ 1,2,3,1,2,3,4,1,2,3,4,5,1,2,3,4,5,6,1,2,3,4,5,6,7 ];
console.log( arr );
// 查询 数值1 在数组中第一次出现的位置
// 如果有符合的数据 返回值 是 存储数据单元的索引下标
var res1 = arr.indexOf( 1 );
console.log( res1 );
var res2 = arr.indexOf( 4 );
console.log( res2 );
// 查询 数值1 在数组中最后一次出现的位置
// 如果有符合的数据 返回值 是 存储数据单元的索引下标
var res3 = arr.lastIndexOf( 1 );
console.log( res3 );
// 查询 字符a 在数组中出现的位置
// 没有匹配的数据 返回值 是 -1
// 执行结果是 -1 也就是 意味着 数组中没有存储这个数据
var res4 = arr.indexOf( 'a' );
var res5 = arr.lastIndexOf( 'a' );
console.log( res4 );
console.log( res5 );
</script>
7、数组的去重
数组去重的12种方法: blog.csdn.net/weixin_4631…
实际项目中推荐使用使用 set数据类型方法
数组去重方法1 indexOf
数组中默认是可以存储重复数据
实际项目中 数组中不能存储重复数据
不需要去除数组中重复的数据
去重的基本原理
创建一个新的空数组
将原始数组数据 写入新数组中
写入时执行判断，要写入的数据 新数组中没有 再执行写入操作
案例：
<script>
var arr = [1,2,3,1,2,3,4,1,2,3,4,5,1,2,3,4,5,6,1,2,3,4,5,6,7];
console.log( arr );
// indexOf / lastIndexOf 方法
// 创建一个空数组
var newArr = [] ;
// // 将 原始数组的数据 写入新数组
// // 需要循环遍历 原始数组的每一个单元
// for( var i = 0 ; i <= arr.length-1 ; i++ ){
// // i 是 原始数组arr的索引下标
// // arr[i] 是 原始数组arr中 数据单元存储的数据数值
// // console.log( arr[i] );
// // 将 原始数组的数据数值 也就是arr[i] 写入 新数组中
// // 为了确数据的顺序相同 使用 末位新增数据语法
// // 执行判断 新数组中 没有 要写入的数据 再执行写入操作
// // 在 新数组中 查询 要写入的数据 arr[i]
// // 如果 查询结果是 -1 证明 新数组中没有要写入的数据 arr[i]
// // 可以 执行写入操作
// if( newArr.indexOf( arr[i] ) === -1 ){
// // 在 新数组中 查询 要写入的 数据 arr[i]
// // 如果查询结果是 -1 也就是 新数组中没有要写入的原始数组数据arr[i];
// // 执行 末位新增数据操作
// newArr.push( arr[i] );
// }
// }
8、数组的截取
数组的截取方法
从数组中 截取 部分数据单元 组成新数组
截取函数的执行结果 返回值 是 截取的新数组
! 不会改变 原始数组中 存储的数据内容
语法
var 变量 = 数组.slice( 参数1 , 参数2 );
执行结果返回值 是 截取原始数组内容 组成的新数组
参数1 截取起始位置的索引下标
参数2 截取结束位置的索引下标
! 截取结果不包括结束位置的数据数值
案例：
<script>
var arr = [100,200,300,400,500,600,700,800,900];
// // 数组的删除操作 执行结果返回值 是 删除的数组单元组成的新数组
// // 但是会改变原始数组中存储的内容
// var res1 = arr.splice( 2 , 4 );
// console.log( res1 );
// 从 索引下标是 2 的单元开始截取
// 截取至 索引下标是 6 的单元 结束
// 截取 结果 是 索引下标 是 2 3 4 5 的 4个单元的数据
// 没有 结束位置 索引下标是6的单元的数据
var res2 = arr.slice( 2 , 6 );
console.log( res2 );
console.log( arr );
</script>
9、数组反转
<script>
/*
数组的反转
将 原始数组内容都反向排序
数组.reverse()
*/
var arr = [100,200,300,400,500];
arr.reverse();
console.log( arr );
</script>
10、数组排序
数组的排序方法：
数组.sort();
按照 首字符的大小排序
数组.sort(function( 参数1 , 参数2 ){ return 参数1 - 参数2 })
小 到 大 排序
数组.sort(function( 参数1 , 参数2 ){ return 参数2 - 参数1 })
从 大 到 小 排序
案例：
<script>
var arr = [312,432,456,567,897,234,123,6543,7865,434,1234,213,465,43,]
// 首字符排序
arr.sort();
// 小 -- 大
arr.sort( function( a , b ){ return a - b });
// 大 -- 小
arr.sort( function( num1 , num2 ){ return num2 - num1 });
console.log( arr );
</script>
11、数组拼接
<script>
/*
数组的拼接操作
将两个数值的数据 拼接成 一个数组
不会改变原始数组的内容
执行结果返回值是 两个数值拼接的结果
var 变量 = 原始数组.concat( 数组1 , 数组2 .... );
可以将 一个或者多个数值的数据 拼接到一个数组中
*/
var arr = [100,200,300];
var arr1 = [400,500,600];
var arr2 = [700,800,900];
var res = arr.concat( arr1 , arr2 );
console.log( arr );
console.log( res );
</script>
12、数组字符串转换
数组 --- 字符串
var 变量 = 数组.join();
将数组数据拼接为字符串
以 逗号 为间隔符号
var 变量 = 数组.join('间隔符号');
将数组数据拼接为字符串
以 设定的符号 为间隔符号
var 变量 = 数组.join('');
将数组数据拼接为字符串
以 设定参数是 空字符串 没有 间隔内容
字符串 --- 数组
var 变量 = 字符串.split();
案例：
<script>
// var arr = [100,200,300,400,500,600];
// // 没有定义参数 默认以逗号为间隔符号
// // 获取数组中每一个数据单元的数值 拼接为 字符串
// var res1 = arr.join();
// console.log( res1 );
// // 以设定的符号 为间隔符号
// // 获取数组中每一个数据单元的数值 拼接为 字符串
// var res2 = arr.join('-');
// console.log( res2 );
// // 设定空字符串 没有 间隔内容
// // 获取数组中每一个数据单元的数值 拼接为 字符串
// var res3 = arr.join('');
// console.log( res3 );
var str = 'abc-abc-abc-abc-abc';
// 将字符串转化为数组
// 没有设定参数 整个字符串作为一个整体存储到数组中
var res1 = str.split();
console.log( res1 );
// 将字符串转化为数组
// 以设定的 间隔符号 作为依据 将字符串分割
// 分割结果中 不包括 分割符号
// 也就是 设定 '-' 分割结果中 没有 '-'
// 字符串 'abc-abc-abc-abc-abc'
// 按照 - 减号 进行分割 结果是 abc abc abc abc abc
var res2 = str.split('-');
console.log( res2 );
// 使用 空字符串 作为 分割符号 每一个字符都是一个数组单元
var res3 = str.split('');
console.log( res3 );
</script>
数组的复杂查询
1, 数组的简单查询
数组.indexOf( 数据 )
数组.lastIndexOf( 数据 )
返回 索引下标 / -1
数据只能是 基本数据类型
// indexOf
var arr = [1,25,,5,2,,8,3,4,7,6,]
console.log('原始数组: ', arr)
var num = arr.indexOf(4, 5)
console.log('indexOf 后的 arr: ', arr)
console.log('indexOf 的返回值: ', num)
// lastIndexOf
var num = arr.lastIndexOf(4, 4)
console.log('lastIndexOf 后的 arr: ', arr)
console.log('lastIndexOf 的返回值: ', num)
