特点

后进先出（Last In First Out）

链栈

栈的链接存储结构成为链栈，利用链表实现，链表中的每一个元素由两部分信息组成，一部分是存储其本身的信息（数据域），一部分是存储一个指示其直接后继的信息，即直接后继的存储位置（指针域）

对于链式栈，无栈满的问题，空间可以扩充，插入与删除仅在栈顶处执行，链式栈的栈顶在链头。

入栈操作：插入一个新元素node，只能在链接在栈顶处，指针域指向原栈顶元素(node.next = top;)，栈顶指针top再指向这个新元素(top = node)
出栈操作：只能删除栈顶元素，删除时，栈顶指针指向原来栈顶元素的指针域。node = top; top = top.next; return node.data;

class Node {
    constructor(element) {
        this.element = element;
        this.next = null;
    }
}
/**
 * 属性：
 * length:栈的长度
 * top:栈顶指针
 *
 * 方法：
 * push:入栈
 * pop:出栈
 * peek:读栈顶数据元素
 * toSting:遍历栈将每个节点值转换为字符串，并返回结果
 * isEmpty:判断栈是否为空
 * size:栈的数据元素个数
 * clear:清除栈数据
 */
class LinkStack {
    constructor() {
        this.length = 0;
        this.top = null; // 栈顶指针
    }
    push(element) {
        let curNode;
        let node = new Node(element);
        //如果栈顶是null则新元素节点直接作为栈顶
        if (!this.top) {
            this.top = node;
        } else {
            // 将新元素节点取代栈顶，并且指向的节点是原来栈顶元素节点
            curNode = this.top;
            node.next = curNode;
            this.top = node; // 插入的新元素为栈顶
        }
        this.length++;
    }
    pop() {
        let curNode = this.top;
        if (this.top === null) {
            return null;
        }
        let element = curNode.element;
        this.top = curNode.next; // 栈顶指针指向原来栈顶元素的指针域
        this.length--;
        return element;
    }
    peek() {
        if (this.top === null) {
            return null;
        }
        return this.top.element;
    }
    toString() {
        let str = "";
        let curNode = this.top;
        while (curNode) {
            str += curNode.element + ",";
            curNode = curNode.next;
        }
        str = str.slice(0, str.length - 1);
        return str;
    }
    isEmpty() {
        return this.top === null;
    }
    size() {
        return this.length;
    }
    clear() {
        this.top = null;
        this.length = 0;
    }
}
const linkStack = new LinkStack();
let size = linkStack.size();
console.log("size:", size);
let isEmpty = linkStack.isEmpty();
console.log("isEmpty:", isEmpty);
let peek = linkStack.peek();
console.log("读取栈顶:", peek);
let pop = linkStack.pop();
console.log(pop, "出栈");
let toString = linkStack.toString();
console.log("toString:", toString);
linkStack.push("A");
linkStack.push("B");
linkStack.push("C");
linkStack.push("D");
toString = linkStack.toString();
console.log("toString:", toString);
pop = linkStack.pop();
console.log(pop, "出栈");
pop = linkStack.pop();
console.log(pop, "出栈");
pop = linkStack.pop();
console.log(pop, "出栈");
toString = linkStack.toString();
console.log("toString:", toString);
peek = linkStack.peek();
console.log("读取栈顶:", peek);
size = linkStack.size();
console.log("size:", size);

顺序栈

栈，又叫堆栈,比列表高效，因为栈内的元素只能通过列表的一端访问，称为栈顶，数据只能在栈顶添加或删除，遵循先入后出(LIFO，last-in-first-out) 的原则，普遍运用于计算机的方方面面

顺序栈：利用一组地址连续的存储单元一次存放自栈底到栈顶的数据元素，把数组中下标为0的一端作为栈底对栈的操作主要有两种，一是将一个元素压入栈，push方法，另一个就是将栈顶元素出栈，pop方法。

/**
 属性：
 stackArray:存储栈数据
 方法：
 pop:出栈，删除栈顶元素,并且返回该值
 push:入栈，在栈顶将新元素入栈
 peek:查看当前栈顶元素,仅仅是查看，并不删除
 isEmpty:判断是否为空
 size:查看当前栈元素的总数
 clear:清空栈内元素
 toString:遍历栈查看所有元素
 */
class ArraySatck {
    constructor() {
        this.datas = [];
    }
    isEmpty() {
        return this.datas.length === 0;
    }
    size() {
        return this.datas.length;
    }
    push(item) {
        this.datas.push(item);
    }
    pop() {
        if (this.isEmpty()) {
            return null;
        }
        return this.datas.pop(); // 原生js数组pop方法删除最后一个元素并且返回
    }
    peek() {
        if (this.isEmpty()) {
            return null;
        }
        return this.datas[this.size() - 1];
    }
    clear() {
        this.datas = [];
    }
    toString() {
        return this.datas.toString();
    }
}
const arraySatck = new ArraySatck();
let isEmp = arraySatck.isEmpty();
console.log("是否为空", isEmp);
length = arraySatck.size();
console.log("栈长度", length);
let pop = arraySatck.pop();
console.log(pop + "出栈");
let peek = arraySatck.peek();
console.log("查看栈顶", peek);
let str = arraySatck.toString();
console.log("toSting", str);
arraySatck.push("A");
arraySatck.push("B");
arraySatck.push("C");
arraySatck.push("D");
arraySatck.push("E");
isEmp = arraySatck.isEmpty();
console.log("是否为空", isEmp);
length = arraySatck.size();
console.log(length);
pop = arraySatck.pop();
console.log(pop + "出栈");
pop = arraySatck.pop();
console.log(pop + "出栈");
peek = arraySatck.peek();
console.log("查看栈顶", peek);
str = arraySatck.toString();
console.log("toSting", str);
arraySatck.clear();
str = arraySatck.toString();
console.log("after clear toSting", str);
let arr = arraySatck.datas;
console.log("datas", arr);