标签：arr 下标 log 数组 var console

数据结构

数据结构顾名思义 就数据的结构 （逻辑结构 存储结构 算法）

存储结构 （数据存储的结构方式）

线性结构

　　数组（顺序表）
　　队列
　　栈
　　堆
　　链表

非线性结构

　　树
　　图
　　hash（散列表）

注：只要是能存数据的容器 就必须具备增删改查的方法

数组

数组概述：数组固定一类数据的组合（一般情况下我们数组里面的数据类型一致）（多个数据）

数组的声明（引用数据类型）

1.使用[] 声明数组

//里面的数据以,进行分隔
var arr = [1,2,3]

2.使用new 关键词进行声明 （对象）

var arr = new Array(10) //里面参数指定对应的长度 如果你没有写 表示长度为0
var arr2 = new Array(1,2,3,4) //当前数组里面的数据有 1 2 3 4,arr2的值和指向的地址是同一个，但和arr不相同(存放变量的栈的地址不一样)

a.length属性来访问对应的长度（也可以进行设置）

var arr = new Array()
//通过length来访问数组的长度
console.log(arr.length);
arr.length = 11 //设置对应的长度
console.log(arr);

b.下标访问

console.log(arr[0])//获取数组第一个元素
console.log(arr[arr.length-1])//获取数组最后一个元素（数组是从0开始数，所以数组长度减一，就是最后一位元素）
//允许使用字符串进行获取元素
console.log(arr['0']); //获取数组第一个元素

c.数组的赋值

arr[0] = 10
console.log(arr[0]) //10
// 给数组里面的元素随机给值 Math.random
var arr = new Array()
for(var i=0;i<10;i++){
arr[i] = Math.random() //随机取0-1的小数 包含0 不包含1的（但不可能绝对的随机，每个数的概率是不可能一样）
}
console.log(arr);

数组遍历

传统的for循环遍历

var arr = [1,2,3,45,12]
//利用顺序表的特点 有序的进行遍历
for(var i=0;i<arr.length;i++){
console.log(arr[i])
}

for in遍历 (使用范围：对象 ，通过下标进行遍历 ，迭代器（next）来实现的 )

var arr = [1,2,3,45]
for(var index in arr){ //index表示的为下标
console.log(arr[index])
}

for of进行遍历（使用范围：数组 ，迭代器（next）来实现的）

//使用for of遍历(只能遍历数组)
for(var value of arr){ //value表示的是数组里元素
console.log(value)
}

数组的方法

数组是一个存储结构（具备增删改查的操作）

添加 (单词： add push append..)

栈方法 （先进后出 后进先出）push 入栈 pop出栈操作

 ABCDE如果要出去，E先出去；如果要添加F，要加在E上面；

会影响原本数组的方法：

push方法（添加到数组最后一个）

var arr = [1]
arr.push(10) //参数为要添加的元素
console.log(arr) //[1,10]

unshift方法（添加到数组第一个）

var arr = [1]
arr.unshift(10) //参数为要添加的元素
console.log(arr) //[10,1]

删除 (delete(硬删) remove(软删)..)

栈方法

pop方法(删除最后面)

var arr = [1,2,3]
arr.pop() //下标不写的（写了也没用）
console.log(arr) //[1,2]

队列方法 ：先进先出

 

 

 

 

shift方法（删除第一个）

var arr = [1,2,3]
arr.shift() //下标不用写，写了也没用
console.log(arr) //[2,3]

修改 （replace替换 update 更新）

反转 reverse（将最后一个变到第一个 一个个对应的换位置）

//改变原本的数组
var arr = [1,2,3,4,8]
var arr1 = arr.reverse(); //返回一个数组 这个数组就是反转后的数组
arr1.unshift(10) //返回的反转后的数组其实就我们原本的数组
console.log(arr) //反转后的结果 [8,4,3,2,1]
console.log(Object.is(arr1,arr));//true

排序 sort方法

//sort方法排序 //默认情况下他是根据第一个字符的ACSII码进行排序 (ACSII码排序)，如果第一个一样，就比第二个，一直比下去...（如果一样，两个数就不分前后，效果都一样）
var arr2 = [15,20,11,4,5]
arr2.sort() //返回一个数组 这个数组是排序好的数组 他跟上面一样 就是返回的这个数组其实就是原本的数组
console.log(arr2);
// sort 其实是一个高阶函数 高阶函数就是里面用函数做为参数的函数
var arr3 = [15,20,11,4,5]
arr3.sort(function(a,b){
//1 和 -1来进行大小区分和排序规则
return b-a //a-b是正序 b-a就倒序
})
console.log(arr3);

不影响原本数组的方法：

concat方法（连接）

//不会影响原本数组的方法 返回新的数组
var arr = [1,2,3,4]
var arr1 = [1,2,3,4]
var arr2 = [1,2,3,4]
var arr3 = [1,2,3,4]
// concat 连接 把多个数组变成一个数组 返回 ...扩展运算符 打开数组取出里面的值(...证明可以写任意个）？表示可写可不写var newArr = arr.concat(arr1,arr2,arr3)
console.log(newArr);

slice方法 （截取）

splice 方法 （删除）
// slice 切片 把一个数组里面东西提出 返回的新的数组
var sliceArr = arr.slice()//全切
console.log(sliceArr);
var sliceArr1 = arr.slice(0)//从0开始切到最后 如果下标不存在返回一个空数组
console.log(sliceArr1);
var sliceArr2 = arr.slice(2,3)//包含结束的下标 包含开始的下标
console.log(sliceArr2);

splice方法 （删除）

//splice会影响之前的数组 删除 截取 插入
var arr = [12,13,45]
//参数 开始位置 删除的个数(可以写可以不写 数组的length) 返回一个新的数组
// var newArr = arr.splice(0) //从开始删
// console.log(newArr);
console.log(arr);
var newArr = arr.splice(1,2) //从开始删
console.log(newArr);
//获取删除的内容 其实就截取里面的内容(不足是会改变之前的数组)

排序算法

1.冒泡排序 (最基础的排序) O(n^2)

//冒泡排序核心点 俩个for循环嵌套 第一个躺数 相当于length-1 第二个每躺比较是递减
//相邻的俩个相比 j和j+1相比
function bubble(arr){
//遍历数组
for(var i=1;i<arr.length;i++){
//判断对应的没有比较的值
for(var j=0;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 selecter(arr){
//遍历数组
for(var i=0;i<arr.length;i++){
var min = i //记录最小下标 默认当前的i
for(var j=i+1;j<arr.length;j++){ //遍历后面的内容
//如果当前值比最小值还小
if(arr[j]<arr[min]){
//记录一下这个下标
min = j
}
}
//判断当前最小下标是否为开始的默认下标 不是就换位置
if(min!=i){
//换位置
var temp = arr[min]
arr[min] = arr[i]
arr[i] = temp
}
}
return arr
}

3.快速排序 （在数据量不多最快的 冒泡排序的进阶）二分排序   时间复杂度：O(nLogn)

1.方式一

function quick(arr) {             if(arr.length<=1) {                 return arr             }             var left=[],right=[],mid=arr[0]             for(var i=1;i<arr.length;i++) {                 arr[i]>mid?right.push(arr[i]):left.push(arr[i])  //三目运算判断             }             return quick(left).concat([mid],quick(right))         }         var arr1 = [21,11,33,66]         console.log(quick(arr1)) // 11,21,33,66

2.方式二

function quick1(arr) {
            if(arr.length<=1) { //判断数组个数是否大于1，如果只有一个，就不用进行排序了
                return arr  //直接返回arr
            }
            var left = [],right = [],mid = arr[0]  //声明两个空数组容器来接收数组元素，把arr[i]赋值给判断条件mid
            // 遍历数组
            for(var i=1;i<arr.length;i++) {
                if(arr[i]<=mid) {  //判断小于mid的元素
                    left.push(arr[i]) //添加到left数组
                }else{
                    right.push(arr[i]) //添加到right数组
                }
            }
            return quick1(left).concat([mid],quick1(right))  //最后将left，mid，right三个数组连接起来
        } 
        var arr2 = [31,11,33,66]
        console.log(quick1(arr2)) //[11,31,33,66]

 

标签：arr,下标,log,数组,var,console
来源： https://www.cnblogs.com/b1ngo-ming/p/16535312.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。