数组:
- 存放一些数据的集合
- 也是引用数据类型(复杂数据类型)
- 数组内部是存放一些数据的, 数据的类型没有限制
- 但是在开发的时候一般需要将一个数组内的数据类型限制为一个
- 比如: 纯字符串数组, 纯数字数组, 纯对象数组
- 数组/对象/函数
创建数组
- 字面量的方式创建
var arr1 = [true, undefined, null, 999, 578, 'QF999']
console.log(arr1)
- 内置构造函数的方式创建
var arr2 = new Array()
console.log(arr2)
//创建一个有长度的数组
var arr3 = new Array(5)
console.log(arr3)
//创建一个有内容的数组
var arr4 = new Array(500, 100, 200, 300, 'QF001', 'QF666')
console.log(arr4)
数组的长度
- 数组的长度不并固定, 取决于数组内部有多少个元素
- 查看方式:
- 打印数据, 在控制台展开数组, 找到最后的length
- 打印 数组名.length
- 当 数组的 长度 === 0 代表当前数组为空数组
var arr = [1, 2, 3, 4, 5] console.log(arr) console.log(arr.length) - 数组的索引(下标)
- 有什么用?
- 表明 数组 的这个位置上 有什么内容
- 注意:下标是固定的, 永远是 0 1 2 3 4 5 ....但是下标对应的内容, 不是固定的
var arr = [1, 2, 3, 4, 5]
// 下标: 0 1 2 3 4
- 数组的遍历
/**
* 数组遍历
* 需求: 拿到数组各个位置上的值
*/
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2]
// 下标 0 1 2 3 4 5 6 7 8 9
// console.log(arr[0])
// console.log(arr[1])
// console.log(arr[2])
// for (var i = 0; i <= arr.length - 1;) {
for (var i = 0; i < arr.length; i++) {
// console.log(i)
console.log(arr[i])
}
冒泡排序
- 算法/设计模式
- 这两个不是一个东西, 但是都是为了解决某一类问题的最佳解法
//优化 3, 去掉多余的无用对比
for (var j = 0; j < arr.length - 1; j++) {
console.log('当前是第 ', j + 1, ' 次循环, 此时变量 j ===', j)
for (var i = 0; i < arr.length - 1 - j; i++) {
console.log('此时对比的是: ', arr[i], arr[i + 1])
if (arr[i] > arr[i + 1]) {
var temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
}
}
console.log
选择排序
/**
* 选择排序
*/
var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
// 0 1 2 3 4 5 6 7 8
/**
* 第几次循环 假设谁是最小值 和谁交换 内层循环从 ? 开始
*
* k === 0 1 0 0 1
* k === 1 2 1 1 2
* k === 2 3 2 2 3
*/
for (var k = 0; k < arr.length; k++) {
// 1. 假设 k 是最小值的下标, 保存在 minIndex
var minIndex = k
// 2. 循环会帮我们找到真实最小值的下标, 并保存在变量 minIndex
for (var i = k + 1; i < arr.length; i++) {
if (arr[minIndex] > arr[i]) {
minIndex = i
}
}
// 3. 交换 真实最小值(下标 minIndex) 和 假设最小值 (k) 的位置
var temp = arr[k]
arr[k] = arr[minIndex]
arr[minIndex] = temp
}
console.log('排序后: ', arr)
//假设这是我们第 11111111111111111111111111111 轮 选择排序
// 1. 假设 下标0 是最小的值
var minIndex = 0
// 2. 循环遍历数组, 找到真实最小的值对应的下标
for (var i = 1; i < arr.length; i++) {
if (arr[minIndex] > arr[i]) {
minIndex = i
}
}
// 上述循环执行完毕后, 我们一定会得到最小值对应的下标
// console.log(minIndex)
// 3. 将 真实最小值(下标minIndex)和假设最小值(下标0)做一个交换
var temp = arr[0]
arr[0] = arr[minIndex]
arr[minIndex] = temp
console.log('第 11111111111111111111111111111 轮 选择排序后: ', arr)
// 假设这是我们第 22222222222222222222222222222222 轮 选择排序
// 1. 假设 下标1 是最小的值 (因为 第一轮结束后, 下标0 真的是最小值)
var minIndex = 1
// 2. 循环遍历数组, 找到真实最小的值对应的下标
for (var i = 2; i < arr.length; i++) {
if (arr[minIndex] > arr[i]) {
minIndex = i
}
}
// 上述循环执行完毕后, 我们一定会得到最小值对应的下标
// console.log(minIndex)
// 3. 将 真实最小值(下标minIndex)和假设最小值(下标1)做一个交换
var temp = arr[1]
arr[1] = arr[minIndex]
arr[minIndex] = temp
console.log('第 22222222222222222222222222222222 轮 选择排序后: ', arr)
// 假设这是我们第 333333333333333333333333333333333333333 轮 选择排序
// 1. 假设 下标2 是最小的值 (因为 前两轮结束后, 下标0 和 下标1 真的是最小值)
var minIndex = 2
// 2. 循环遍历数组, 找到真实最小的值对应的下标
for (var i = 3; i < arr.length; i++) {
if (arr[minIndex] > arr[i]) {
minIndex = i
}
}
// 上述循环执行完毕后, 我们一定会得到最小值对应的下标
// console.log(minIndex)
// 3. 将 真实最小值(下标minIndex)和假设最小值(下标2)做一个交换
var temp = arr[2]
arr[2] = arr[minIndex]
arr[minIndex] = temp
console.log('第 333333333333333333333333333333333333333 轮 选择排序后: ', arr)
``
