Tip

计算机基础不管是什么语言、什么开发岗位都是必须要了解的知识，本文主要是通过 JS 来实现一些常用的数据结构，很简单。

本文插图引用：啊哈！算法 ，由于是总结性文章，所以会不定时地修改并更新，欢迎关注！

Stack 栈

堆栈（stack），也可以直接称为栈，它是一种后进先出的数据结构，并且限定了只能在一段进行插入和删除操作。

如上图所示，假设我们有一个球桶，并且桶的直径只能允许一个球通过。如果按照 2 1 3 的顺序把球放入桶中，然后要将球从桶中取出，取出的顺序就是 3 1 2，先放入桶中的球被后取出，这就是 栈 插入和删除的原理。

我们接触过的算法书基本也都是用c语言实现这个数据结构，它的特殊之处在于只能允许链接串列或者阵列的一端（top）进行 插入数据（push）和 输出数据（pop）的运算。那么如果要用 JS 来实现它又该怎么操作呢？

// 栈可以用一维数组或连结串列的形式来完成

class Stack {
    constructor() {
        this.data = []
        this.top = 0
    }
    // 入栈
    push() {
        const args = [...arguments]
        args.forEach(arg => this.data[this.top++] = arg)
        return this.top
    }
    // 出栈
    pop() {
        if(this.top === 0) {
            throw new Error('The stack is already empty!')
        }
        const popData = this.data[--this.top]
        this.data = this.data.slice(0, -1)
        return popData
    }
    // 获取栈内元素的个数
    length() {
        return this.top
    }
    //  判断栈是否为空
    isEmpty() {
        return this.top === 0
    }
    // 获取栈顶元素
    goTop() {
        return this.data[this.top-1]
    }
    // 清空栈
    clear() {
        this.top = 0
        return this.data = []
    }
}

通过 面向对象 的思想就可以抽象出一个 栈 的对象，实例化：

const stack = new Stack()

stack.push(1, 2)
stack.push(3, 4, 5)
console.log(stack.data)
// [ 1, 2, 3, 4, 5 ]
console.log(stack.length())
// 5
console.log(stack.goTop())
// 5
console.log(stack.pop())
// 5
console.log(stack.pop())
// 4
console.log(stack.goTop())
// 3
console.log(stack.data)
// [ 1, 2, 3 ]

stack.clear()
console.log(stack.data)
// []

在 啊哈！算法 描述 栈 的应用时，举了一个求回文数的例子，我们也用 JS 来把它实现一波：

const isPalindrome = function(words) {
    const stack = new Stack()
    let copy = ''
    words = words.toString()

    words.split('').forEach(word => stack.push(word))

    while(stack.length() > 0) {
        copy += stack.pop()
    }
    return copy === words
}

console.log(isPalindrome('123ada321'))
// true
console.log(isPalindrome(1234321))
// true
console.log(isPalindrome('addaw'))
// false

Linked List 链表

在存储一大波数的时候，我们通常使用的是数组，但有时候数组显得不够灵活，比如：有一串已经从小到大排好序的数 2 3 5 8 9 10 18 26 32。现需要往这串数中插入 6 使其得到的新序列仍符合从小到大排列。

如上图所示，如果使用数组来实现的话，则需要将 8 和 8 后面的 数都依次往后挪一位，这样操作显然很耽误时间，如果使用 链表 则会快很多：

链表（Linked List）是一种常见的数据结构。它是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针。和图中一样，如果需要在 8 前面插入一个 6，直接插入就行了，而无需再将 8 及后面的数都依次往后挪一位。

那么问题来了，如何使用 JS 实现 链表呢？还是运用 面向对象 的思想：

// 抽象节点类
function Node(el) {
    this.el = el
    this.next = null
}

// 抽象链表类
class LinkedList {
    constructor() {
        this.head = new Node('head')
    }
    // 查找数据
    find(item) {
        let curr = this.head
        while(curr.el !== item) {
            curr = curr.next
        }
        return curr
    }
    // 查找前一个节点
    findPre(item) {
        if(item === 'head') {
            throw new Error('Now is head!')
        }
        let curr = this.head
        while(curr.next && curr.next.el !== item) {
            curr = curr.next
        }
        return curr
    }
    // 在 item 后插入节点
    insert(newEl, item) {
        let newNode = new Node(newEl)
        let curr = this.find(item)
        newNode.next = curr.next
        curr.next = newNode
    }
    // 删除节点
    remove(item) {
        let pre = this.findPre(item)
        if(pre.next !== null) {
            pre.next = pre.next.next
        }
    }
    // 显示链表中所有元素
    display() {
        let curr = this.head
        while(curr.next !== null) {
            console.log(curr.next.el)
            curr = curr.next
        }
    }
}

实例化：

const list = new LinkedList()
list.insert('0', 'head')
list.insert('1', '0')
list.insert('2', '1')
list.insert('3', '2')
console.log(list.findPre('1'))
// Node { el: '0', next: Node { el: '1', next: Node { el: '2', next: [Object] } } }
list.remove('1')
console.log(list)
// LinkedList { head: Node { el: 'head', next: Node { el: '0', next: [Object] } } }
console.log(list.display())
// 0 2 3

Binary tree 二叉树

二叉树（binary tree）是一种特殊的树。二叉树 的特点是每个结点最多有两个儿子，左边的叫做左儿子，右边的叫做右儿子，或者说每个结点最多有两棵子树。更加严格的递归定义是：二叉树 要么为空，要么由根结点、左子树和右子树组成，而左子树和右子树分别是一棵 二叉树。

和前两个例子一样，通过类的抽象来实现 二叉树：

// 抽象节点类
function Node(key) {
    this.key = key
    this.left = null
    this.right = null
}
// 插入节点的方法
const insertNode = function(node, newNode) {
    if (newNode.key < node.key) {
        if (node.left === null) {
            node.left = newNode
        } else {
            insertNode(node.left, newNode)
        }
    } else {
        if (node.right === null) {
            node.right = newNode
        } else {
            insertNode(node.right, newNode)
        }
    }
} 
// 抽象二叉树
class BinaryTree {
    constructor() {
        this.root = null
    }
    insert(key) {
        let newNode = new Node(key)
        if(this.root === null) {
            this.root = newNode
        } else {
            insertNode(this.root, newNode)
        }
    }
}

实例化测试一波：

const data = [8, 3, 10, 1, 6, 14, 4, 7, 13]

// 实例化二叉树的数据结构
const binaryTree = new BinaryTree()
// 遍历数据并插入
data.forEach(item => binaryTree.insert(item))
// 打印结果
console.log(binaryTree.root)
/*
Node {
  key: 8,
  left:
   Node {
     key: 3,
     left: Node { key: 1, left: null, right: null },
     right: Node { key: 6, left: [Object], right: [Object] } },
  right:
   Node {
     key: 10,
     left: null,
     right: Node { key: 14, left: [Object], right: null } } }
*/

总结

算法和数据结构是非常重要的一环，之后也会慢慢总结更新，欢迎关注！