数据结构
数据结构主要是数据的一个存储和逻辑结构的体现，只要能存储数据的一个结构我们就叫做数据结构。
划分
- 存储结构（存储对应的数据的）:顺序存储结构，链式存储结构，索引存储结构，散列结构
- 逻辑结构（逻辑的体现）：分为线性结构和非线性结构
- 算法
存储结构的相关的内容
线性结构（有顺序）
- 数组 （顺序表，主要通过索引下标来进行访问（排序））
- 栈 （先进后出）
- 队列 （先进先出）
非线性结构 （没有顺序）
- 链表 （单向链表 双向链表）
- 图 （有向图 无向图）
- 树 （二叉树）
- hash表 散列表（hashcode来进行编码）
- ...
所有的存储结构 必须具备增删改查的方法
数组
概述：
数组是一种线性的数据结构，他可以存储对应的数据，一般通过对应的索引下标进行数据的访问。在一般情况下我们在数组里面存储的数据类型是一致的。（数组也可以存储不同数据类型的数据）
数组的声明（引用数据类型）
使用[ ] 来声明
//第一种声明
var array = [1, 2, 3] //数据里面存储的数据采用,分割
console.log(typeof array) //object 数组是引用数据类型
console.log(array)使用new Array关键词声明
//第二种声明方式 采用new关键词 反是采用new 关键词构建的都是引用数据类型
var array = new Array() //没有指定长度的数组
//当你传递一个参数的时候 就是构建对应的长度的数组
var array1 = new Array(10) //new 后面的方法的首字母要大写 指定长度为10的数组
console.log(array1);
//当你传递多个参数的时候 就是将对应的参数放入对应的数组内
var array2 = new Array(1,2,3,4)
console.log(array2);数组的特性
- 下标 从0开始到length-1 可以通过[下标] 来访问对应的数组里面的值
- length 长度（数组里面的值的个数），length重新修改是可行的（改大会进行扩容操作，改小会进行删除操作）
var arr = [1,2,3,4,5]
//通过下标访问 下标从0开始
console.log(arr[0])//访问第一个元素
arr[3] = 18
console.log(arr)
//可以做到 自动扩容
arr[10] = 20
console.log(arr)
//通过length来访问对应的长度
console.log(arr.length)
//length可以赋值 大于会进行扩容操作 小于的时候会进行删除操作
arr.length = 2
console.log(arr)
console.log(arr.length)数组的遍历
传统for循环进行遍历
var array = new Array()
for(var i=0;i<array.length;i++){
console.log(array[i])
}for in 遍历（一般用于遍历对象）es5新增的
//使用es5新增的for in循环 （for in循环是为了遍历对象 数组也是一个对象）
//for in遍历的是下标（对象的key）
for(var index in arr){
// console.log(index)
console.log(arr[index])
}for of 遍历（专门遍历数组，不能遍历对象）es6新增的
//在for in基础上进行改版的 for of （专门遍历数组的）es6
//for of不能遍历对象 只能遍历数组（伪数组）
for(var value of arr){
console.log(value)//值
}for in 和 for of的区别：
- for in 是用于遍历对象的，他遍历的是对象的key（es5）
- for of 是用于遍历数组的 他遍历的是数组的值（es6）
数组的相关方法
所有的存储空间都具备增删改查的方法
添加（add push save set...）删除 (delete (删除直接回收) remove（删除完还在内存中） pop...)
push添加到后面（返回新的长度）
//添加方法 会改变原本的数组
//添加方法 会返回添加后的长度
// push方法 添加元素到末尾
var arr = [1,2]
var v = arr.push(3,4) //在末尾追加3 4
console.log(v);
console.log(arr.length); //4
console.log(arr); //[1,2,3,4]pop删除最后一个（返回删除的元素）
var arr = [1,2]
var deleteItem = arr.pop()
console.log(deleteItem)
console.log(arr)//[1]shift删除第一个（返回删除的元素）
//shift和unshift
var arr = [1,2]
var deleteItem = arr.shift
console.log(deleteItem)
console.log(arr)
unshift添加到第一个（返回新的长度）
// unshift 添加到开头
var m = arr.unshift(5,6,7)
console.log(m);
console.log(arr.length); //7
console.log(arr); //[5,6,7,1,2,3,4]修改（replace set...）
覆盖
//他的修改就是重新賦值 数组没有修改方法
arr[2] = 0 //修改當前第三個元素 下标为2的元素先删再加 splice
var arr = [1, 2, 3]
// 从下标为1的位置删除，删除一个，插入一个4和5
arr.splice(1, 1, 4, 5) //
console.log(arr)splice的删除的操作
var arr = [1, 2, 3, 4]
//省略个数 删到最后（包含下标1）
arr.splice(1)
console.log(arr)
var arr = [1, 2, 3, 4]
//从下标1开始 删除俩个（包含下标1）
arr.splice(1,2)
console.log(arr)splice的添加
//添加
var arr = [1,2,3,4]
arr.splice(2,0,5)
console.log(arr)查询相关的方法（select query find search..）
indexOf 根据传入的值查询第一次出现的下标（查询索引indexOf传入对应的元素 有就返回对应的下标 没有返回-1）
var arr1 = [1,2,3,1]
//默认查询 从开头查到结尾 返回的是第一个查找到的下标
console.log(arr1.indexOf(1));//0
//根据对应的值返回下标 找不到返回-1
console.log(arr1.indexOf(4));//-1
//indexOf可以规定开头查找的位置
console.log(arr1.indexOf(1,1));//返回3简单实现indexOf
var arr = [2, 4, 6, 8,4]
//模拟实现indexOf
function myIndexOf(value,start) {
if (value == undefined) {
throw new Error('参数未传递')
}
//如果没有传递start 那么应该为默认值0
if(start == undefined){
start = 0
}
//开始查询
for (var i=start;i<arr.length;i++) {
if (arr[i] == value) {
return i
}
}
return -1
}
console.log( myIndexOf(4))lastIndexOf （从右到左） 找到第一个 没有找到返回-1
//从后往前找 找到第一个 默认是从最后开始
console.log(arr1.lastIndexOf(1));//3
//根据对应的值返回下标 找不到返回-1
console.log(arr1.lastIndexOf(4));//-1
//lastIndexOf可以规定开头查找的位置 从下标1开始
console.log(arr1.lastIndexOf(1,1));//返回0
console.log(arr1.lastIndexOf(3,1));//返回-1简单实现
//模拟实现indexOf
function myLastIndexOf(value, start) {
if (value == undefined) {
throw new Error('参数未传递')
}
//如果没有传递start 那么应该为默认值0
if (start == undefined) {
start = arr.length
}else if(typeof start != 'number'){
throw new Error('参数类型不正确')
}
//开始查询
for (var i = start; i >= 0; i--) {
if (arr[i] == value) {
return i
}
}
return -1
}
console.log(myLastIndexOf(4))
console.log(myLastIndexOf(4,3))以上方法都会对于原本的数组影响
不会改变原数组的方法（一定有返回值）
数组的拼接concat方法
var arr1 = [1, 2]
var arr2 = [3, 4]
//数组的concat方法传入的参数为数组
var concatArr = arr1.concat(arr2)
console.log(arr1) //[1,2]
console.log(arr2) //[3,4]
console.log(concatArr) //[1,2,3,4]
//可以传入数组也可以传入对应的值
var concatArr = arr1.concat(3,4)
console.log(concatArr)截取 （slice sub..）
截取 slice （不会影响原本的数组 返回新的数组）
var arr = [1, 2, 3, 4, 5, 6]
//传入一个开始下标 结束的下标（默认没有传入结束的下标截取到末尾）不包含结束的下标
var sliceArr = arr.slice(4,5)//[5]
console.log(sliceArr, arr)join将对应的数组转为字符串
var arr = [1, 2, 3, 4, 5]
//join如果不传参默认使用,来进行分割每个元素 如果传入参数那么使用参数来分割
var str = arr.join('a')//传入的参数一定是字符串
console.log(str)位置变换的相关方法
sort排序
//排序的相关方法
var arr = [2,3,5,10,4,6]
//默认情况下 sort方法是按照ascii码排序
// arr.sort()
//高阶函数用法 将函数作为参数的函数叫做高阶函数
var newArr = arr.sort(function(a,b){
return a-b //正序 b-a就是倒序
})
console.log(arr)
console.log(newArr)
console.log(newArr == arr)reverse反转
//反转方法
var arr1 = arr.reverse()
console.log(arr)
console.log(arr1 == arr)排序算法（常见的排序算法的时间复杂度 O(n2)）
1.冒泡排序（俩俩（相邻的俩个）相比 位置交换）O(n^2)
function bubleSort(arr){
//轮数
for(var i=0;i<arr.length-1;i++){
//比较的次数
for(var j=1;j<arr.length-i;j++){
//俩俩比较
if(arr[j]<arr[j-1]){
var temp = arr[j]
arr[j] = arr[j-1]
arr[j-1] = temp
}
}
}
return arr
}2.选择排序 （选择一个值 跟所有的值进行比较 然后这个值不是开始的 就换位置）O(n^2)
function selectorSort(arr){
for(var i=0;i<arr.length-1;i++){
//指定max为当前遍历的下标
var max = i
//max要跟其他的所有未排序比较
for(var j=i+1;j<arr.length;j++){
if(arr[max]<arr[j]){
max=j
}
}
//如果最大值不是原本的下标位置就需要交换位置了
if(max!=i){
var temp = arr[max]
arr[max] = arr[i]
arr[i] = temp
}
}
return arr
}3.快速排序（冒泡排序的进阶 二分法）O(nlogn)
function quikSort(arr) {
//如果你的数组长度只有一个 或者没有就直接返回这个数组
if (arr.length <= 1) {
return arr
}
//中间值取第一个
var mid = arr[0]
//左右的容器
var left = [],
right = []
//循环比较
for (var i = 1; i < arr.length; i++) {
arr[i] > mid ? right.push(arr[i]) : left.push(arr[i])
}
//递归调用无限取中间值
return quikSort(left).concat(mid).concat(quikSort(right))
}4.插入排序
5.希尔排序（插入排序的进阶）
6.堆排序
7.桶排序
8.基数排序
9.归并排序（大数据排序）
....
扫一扫
2800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
