线性表

数组
如：a = [1,2,3,4,5]
a[1],a[2],a[3]方括号表示存储地址的偏移量（通过偏移查询性能最好）

数组的特点：

1. 在物理空间上是连续存储的
2. 底层的数组长度是不可变的
3. 数组的变量，指向了数组的第一个元素的位置

优点：查询性能好。指定查询位置。
缺点：

1. 因为空间必须是连续的，所以如果数组比较大，当系统的空间碎片比较多的时候，容易存不下
2. 因为数组的长度是固定的，所以数组的内容难以被添加和删除。

定义数组的方法：

//数组内容固定的时候，可以使用这种方式来固定
var a = [1,2,3,4,5]
//实例化一个数组，长度固定为5
var arr = new Array(5)

链表

我想传递一个链表，我必须传递链表的根节点
每一个节点，都认为自己是跟节点
链表的特点：

1. 空间上不是连续的
2. 每存一个值，都要多开销一个引用空间

优点：

1. 只要内存足够大，就能存下，不用但是空间碎片问题
2. 链表的添加和删除非常的容易

缺点：

1. 查询速度慢（指的查询某个位置）

2. 链表每个节点都需要创建一个指向next的引用，浪费一些空间。

   但是当节点内数据越多的时候，这部分多开销的内存影响越少。

function Node(value) {
  this.value = value;
  this.next = null;
}
var a = new Node(1);
var b = new Node(2);
var c = new Node(3);
var d = new Node(4);
a.next = b;
b.next = c;
c.next = d;
d.next = null;
console.log(a.value);//1
console.log(a.next.value);//2
console.log(a.next.next.value);//3

链表的遍历

function Node(value){
    this.value = value;
    this.next = null;
}
var node1 = new Node(1)
var node2 = new Node(2)
var node3 = new Node(3)
var node4 = new Node(4)
var node5 = new Node(5)
node1.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;
function bianLink(node){
    while(node !== null){
        console.log(node.value)
        node = node.next;
    }
}
bianLink(node1)

链表的逆置

function Node(value) {
    this.value = value;
    this.next = null;
}
var node1 = new Node(1);
var node2 = new Node(2);
var node3 = new Node(3);
var node4 = new Node(4);
var node5 = new Node(5);
node1.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;
function nizhi(node){
    if(node.next.next == null){//判断是否为倒数第二个节点
        node.next.next = node;
        return node.next;
    }else{
        var result = nizhi(node.next)
        node.next.next = node;
        node.next = null;
        return result;
    }
}
var newNode = nizhi(node1)
function bianLink(node){
    while(node !== null){
        console.log(node.value)
        node = node.next;
    }
}
bianLink(newNode)

细细理解，可以懂了，2022年1月12日，我懂了 ，以后复习要是不懂不要着急，之前你懂的现在你也会懂的！