JS实现常用数据结构

js实现树

function BinarySearchTree() {
    var Node = function (key) { //{1}
        this.key = key;
        this.left = null;
        this.right = null;
    };
    var root = null; //{2}
    // 插入
    this.insert = function (key) {
        var newNode = new Node(key); //{1}
        if (root === null) { //{2}
            root = newNode;
        } else {
            insertNode(root, newNode); //{3}
        }
    };
    var insertNode = function (node, newNode) {
        if (newNode.key < node.key) { //{4}
            if (node.left === null) { //{5}
                node.left = newNode; //{6}
            } else {
                insertNode(node.left, newNode); //{7}
            }
        } else {
            if (node.right === null) { //{8}
                node.right = newNode; //{9}
            } else {
                insertNode(node.right, newNode); //{10}
            }
        }
    };
    // 中序遍历
    this.inOrderTraverse = function (callback) {
        inOrderTraverseNode(root, callback); //{1}
    };
    var inOrderTraverseNode = function (node, callback) {
        if (node !== null) { //{2}
            inOrderTraverseNode(node.left, callback); //{3}
            callback(node.key); //{4}
            inOrderTraverseNode(node.right, callback); //{5}
        }
    };
    // 先序遍历
    this.preOrderTraverse = function (callback) {
        preOrderTraverseNode(root, callback);
    };
    var preOrderTraverseNode = function (node, callback) {
        if (node !== null) {
            callback(node.key); //{1}
            preOrderTraverseNode(node.left, callback); //{2}
            preOrderTraverseNode(node.right, callback); //{3}
        }
    };
    // 后序遍历
    this.postOrderTraverse = function (callback) {
        postOrderTraverseNode(root, callback);
    };
    var postOrderTraverseNode = function (node, callback) {
        if (node !== null) {
            postOrderTraverseNode(node.left, callback); //{1}
            postOrderTraverseNode(node.right, callback); //{2}
            callback(node.key); //{3}
        }
    };
    // 搜索最大值
    this.min = function () {
        return minNode(root); //{1}
    };
    var minNode = function (node) {
        if (node) {
            while (node && node.left !== null) { //{2}
                node = node.left; //{3}
            }
            return node.key;
        }
        return null; //{4}
    };
    // 搜索最小值
    this.max = function () {
        return maxNode(root);
    };
    var maxNode = function (node) {
        if (node) {
            while (node && node.right !== null) { //{5}
                node = node.right;
            }
            return node.key;
        }
        return null;
    };
    // 搜索特定值
    this.search = function (key) {
        return searchNode(root, key); //{1}
    };
    var searchNode = function (node, key) {
        if (node === null) { //{2}
            return false;
        }
        if (key < node.key) { //{3}
            return searchNode(node.left, key); //{4}
        } else if (key > node.key) { //{5}
            return searchNode(node.right, key); //{6}
        } else {
            return true; //{7}
        }
    };
    // 移除一个节点
    var removeNode = function (node, key) {
        if (node === null) { //{2}
            return null;
        }
        if (key < node.key) { //{3}
            node.left = removeNode(node.left, key); //{4}
            return node; //{5}
        } else if (key > node.key) { //{6}
            node.right = removeNode(node.right, key); //{7}
            return node; //{8}
        } else { //键等于node.key
            //第一种情况——一个叶节点
            if (node.left === null && node.right === null) { //{9}
                node = null; //{10}
                return node; //{11}
            }
            //第二种情况——一个只有一个子节点的节点
            if (node.left === null) { //{12}
                node = node.right; //{13}
                return node; //{14}
            } else if (node.right === null) { //{15}
                node = node.left; //{16}
                return node; //{17}
            }
            //第三种情况——一个有两个子节点的节点
            var aux = findMinNode(node.right); //{18}
            node.key = aux.key; //{19}
            node.right = removeNode(node.right, aux.key); //{20}
            return node; //{21}
        }
    };
    // 获取树最大深度
    this.maxDepth = function () {
        return maxDep(root);
    }
    var maxDep = function (tree) {
        if (tree === null) {
            return 0;
        }
        return 1 + Math.max(maxDep(tree.left), maxDep(tree.right));
    }
}

var tree = new BinarySearchTree();

tree.insert(10)
tree.insert(15)
tree.insert(5)
tree.insert(2)
tree.insert(7)
tree.insert(13)
tree.insert(17)

tree.postOrderTraverse((v) => {
    console.log(v)
})

console.log('----------')
console.log(tree.max())
console.log(tree.min())
console.log(tree.search(8))
console.log(tree.search(7))
console.log(tree.maxDepth())

JS实现链表

function LinkedList() {
    //辅助类：表示要加入链表的项
    let node = function (element) {
        this.element = element;
        this.next = null;//这个节点的下一个节点暂时为空
    };

    let length = 0;
    let head = null;

    this.append = function append(element) {
        let node = new Node(element);//1
        let current;//2
        //3
        if (head === null) {
            head = node
        } else {
            current = head
            while (current.next) {
                current = current.next
            }
            current.next = node
        }
        length++;//4
    };
    this.insert = function insert(position, element) {
        if (position >= 0 && position <= length) {
            //当position为length时，表示在尾节点处添加，包含了append方法
            let node = new Node(element);
            let current = head;
            let previous;//当前节点的前一个节点，在position处添加节点，就是在previos和current之间添加
            if (position = 0) {
                node.next = head;
                head = node;
            } else {
                for (let i = 0; i < position; i++) {
                    pervious = current;
                    current = current.next;
                }
                pervious.next = node;
                node.next = current;
            }
            length++;
            return true;
        } else {
            return false;
        }
    };//在指定的位置添加节点
    this.remove = function (element) {
    };//将指定的节点删除掉
    this.removeAt = function (position) {
    };//将指定位置的节点删除
    this.searchElement = function (element) {
    };//查找指定元素的位置
    this.searchPosition = function (position) {
    };//查找指定位置的元素
}