JS data structure and algorithm-binary tree (1) basic algorithm

For JavaScript reference only.

Binary search tree and balanced binary tree

Other trees: full binary tree, complete binary tree, perfect binary tree, Huffman tree, binary search tree BST, balanced binary tree AVL
understand: red and black tree is a special binary tree. This tree can be efficiently traversed in order

Basic operation

set up

Create BinarySearchTree class. First, declare its structure:

(Note that BinarySearchTree is a class, and all subsequent functions are defined in the structure body)

function BinarySearchTree() {
    //私有的辅助函数
    var Node = function(key){
        this.key = key;
        this.left = null;
        this.right = null;
    };
    //声明一个私有变量以控制此数据结构的第一个节点。在树中，它不是头节点，而是根元素
    var root = null;
}

insert

this.insert = function(key){
    var newNode = new Node(key);
    if (root === null){
        root = newNode;
    } else {
        insertNode(root,newNode);
    }
};

// 私有的辅助函数
var 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);
        }
    }
};

delete

this.remove = function (key) {
    root = removeNode(root, key);
};

var removeNode = function (node, key) {
    if (node === null) {
        return null;
    }
    if (key < node.key) {
        node.left = removeNode(node.left, key);
        return node;
    } else if (key > node.key) {
        node.right = removeNode(node.right, key);
        return node;
    } else { //键等于node.key
        //第一种情况——一个叶节点
        if (node.left === null && node.right === null) {
            node = null;
            return node;
        }
        //第二种情况——一个只有一个子节点的节点
        if (node.left === null) {
            node = node.right;
            return node;
        } else if (node.right === null) {
            node = node.left;
            return node;
        }
        //第三种情况——一个有两个子节点的节点
        var aux = findMinNode(node.right);
        node.key = aux.key;
        node.right = removeNode(node.right, aux.key);
        return node;
    }
};

Find

this.search = function (key) {
    return searchNode(root, key);
};

var searchNode = function (node, key) {
    if (node === null) {
        return false;
    }
    if (key < node.key) {
        return searchNode(node.left, key);
    } else if (key > node.key) {
        return searchNode(node.right, key);
    } else {
        return true;
    }
};

Find the maximum

this.max = function () {
    return maxNode(root);
};

var maxNode = function (node) {
    if (node) {
        while (node && node.right !== null) {
            node = node.right;
        }
        return node.key;
    }
    return null;
};

Find the minimum

this.min = function () {
    return minNode(root);
};

var minNode = function (node) {
    if (node) {
        while (node && node.left !== null) {
            node = node.left;
        }
        return node.key;
    }
    return null;
};

Traverse

✔ Introduction

this.preOrderTraverse = function (callback) {
    preOrderTraverseNode(root, callback);
};

var preOrderTraverseNode = function (node, callback) {
    if (node !== null) {
        callback(node.key);
        preOrderTraverseNode(node.left, callback);
        preOrderTraverseNode(node.right, callback);
    }
};

✔ Middle order

this.inOrderTraverse = function (callback) {
    inOrderTraverseNode(root, callback);
};

var inOrderTraverseNode = function (node, callback) {
    if (node !== null) {
        inOrderTraverseNode(node.left, callback);
        callback(node.key);
        inOrderTraverseNode(node.right, callback);
    }
};

✔ Later

this.postOrderTraverse = function (callback) {
    postOrderTraverseNode(root, callback);
};

var postOrderTraverseNode = function (node, callback) {
    if (node !== null) {
        postOrderTraverseNode(node.left, callback);
        postOrderTraverseNode(node.right, callback);
        callback(node.key);
    }
};

✔ Depth First (DFS)

In a binary tree, DFS is equivalent to preorder traversal

✔ Breadth first (BFS) / level traversal

It ’s easy to use queues to simulate

this.bfsTraverse = function (callback) {
    bfsTraverseNode(root, callback)
}

var bfsTraverseNode = function (root, callback) {
    var queue = []
    if(root){
        queue.push(root)
    }
    while(queue.length){
        var node = queue.shift()
        callback(node.key)
        if(node.left){
            queue.push(node.left)
        }
        if(node.right){
            queue.push(node.right)
        }
    }
}