学习JavaScript数据结构与算法 — 树

2

定义

树同散列表一样,是一种非顺序数据结构。现实中树的例子有家谱、公司组织架构图及其它树形结构关系。
树由一系列节点构成,每个节点都有一个父节点(除根节点外)以及零个或多个子节点,如图:

clipboard.png

树中的每一个元素叫作节点,最顶部的节点叫作根节点。至少有一个子节点的节点称为内部节点(如图中的7、9、15、13、20),没有子节点的节点称为外部节点或叶节点(如图中的3、 6、 8、 10、 12、 14等)。一个节点可以包括祖先及后代,祖先包括父节点、祖父节点等,后代包括子节点、孙节点等。一个节点及其后代可以组成一个子树(如图中的13、12、14)。节点的深度指节点祖先节点的数量(如图中的节点6的深度为3)。树的高度指树中节点深度的最大值。上图中,节点中的数字称为键。

  • 二叉树:二叉树指节点最多只能包含两个子节点的树,即左侧子节点与右侧子节点。二叉树有利于高效地插入、查找、删除节点。

  • 二叉搜索树:二叉搜索树是二叉树的一种,它的左侧节点的值必须大于右侧节点的值,上图就是一个二叉搜索树。优化的二叉搜索树包括AVL树、红黑树(待完成)等

方法

  • insert(key):向树中插入一个新的键。

  • search(key):在树中查找一个键,如果节点存在,则返回true;如果不存在,则返回false。

  • inOrderTraverse:通过中序遍历方式遍历所有节点。

  • preOrderTraverse:通过先序遍历方式遍历所有节点。

  • postOrderTraverse:通过后序遍历方式遍历所有节点。

  • min:返回树中最小的值/键。

  • max:返回树中最大的值/键。

  • remove(key):从树中移除某个键。

实现

首选实现二叉查找树类的骨架

// 二叉查找树类
function BinarySearchTree() {
    // 用于实例化节点的类
    var Node = function(key){
        this.key = key; // 节点的健值
        this.left = null; // 指向左节点的指针
        this.right = null; // 指向右节点的指针
    };
    var root = null; // 将根节点置为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){
    // 如果插入节点的键值小于当前节点的键值
    // (第一次执行insertNode函数时,当前节点就是根节点)
    if (newNode.key < node.key){
        if (node.left === null){
            // 如果当前节点的左子节点为空,就直接在该左子节点处插入
            node.left = newNode;
        } else {
            // 如果左子节点不为空,需要继续执行insertNode函数,
            // 将要插入的节点与左子节点的后代继续比较,直到找到能够插入的位置
            insertNode(node.left, newNode);
        }
    } else {
        // 如果插入节点的键值大于当前节点的键值
        // 处理过程类似,只是insertNode函数继续比较的是右子节点
        if (node.right === null){
            node.right = newNode;
        } else {
            insertNode(node.right, newNode);
        }
    }
}

在下图的树中插入健值为6的节点,过程如下:

clipboard.png

树的遍历

树的遍历指访问树的每一个节点,并对节点做一定操作。遍历树主要有三种方式:中序、先序、后序。

中序遍历

中序遍历严格按照从小到大的方式遍历树,也就是优先访问左子节点,相当于对树进行了排序。

this.inOrderTraverse = function(callback){
    // callback用于对遍历到的节点做操作
    inOrderTraverseNode(root, callback);
};
var inOrderTraverseNode = function (node, callback) {
    // 遍历到node为null为止
    if (node !== null) {
        // 优先遍历左边节点,保证从小到大遍历
        inOrderTraverseNode(node.left, callback);
        // 处理当前的节点
        callback(node.key);
        // 遍历右侧节点
        inOrderTraverseNode(node.right, callback);
    }
};

对下图的树做中序遍历,并输出各个节点的键值:

tree.inOrderTraverse(function(value){
        console.log(value);
});

依次输出:3 5 6 7 8 9 10 11 12 13 14 15 18 20 25,
遍历过程如图:

clipboard.png

先序遍历

先序遍历先访问节点本身,再遍历其后代节点,最后遍历其兄弟节点。它的一种应用是打印一个结构化的文档。

this.preOrderTraverse = function(callback){
    // 同样的,callback用于对遍历到的节点做操作
    preOrderTraverseNode(root, callback);
};
var preOrderTraverseNode = function (node, callback) {
    // 遍历到node为null为止
    if (node !== null) {
        callback(node.key); // 先处理当前节点
        preOrderTraverseNode(node.left, callback); // 再继续遍历左子节点
        preOrderTraverseNode(node.right, callback); // 最后遍历右子节点
    }
};

用先序遍历遍历下图所示的树,并打印节点键值,输出结果:11 7 5 3 6 9 8 10 15 13 12 14 20 18 25,
遍历过程如图:

clipboard.png

后序遍历

后序遍历先访问节点的后代节点,再访问节点本身。它的一种应用是计算一个目录和它的子目录中所有文件的大小。

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}
    }
};

可以看到,中序、先序、后序遍历的实现方式几乎一模一样,只是{1}、{2}、{3}行代码的执行顺序不同。
对下图的树进行后序遍历,并打印键值:3 6 5 8 10 9 7 12 14 13 18 25 20 15 11,
遍历过程如图:

clipboard.png

树的搜索

搜索最小值

在二叉搜索树里,不管是整个树还是其子树,最小值一定在树最左侧的最底层。因此给定一颗树或其子树,只需要一直向左节点遍历到底就行了。

this.min = function(node) {
    // min方法允许传入子树
    node = node || root;
    // 一直遍历左侧子节点,直到底部
    while (node && node.left !== null) {
        node = node.left;
    }
    return node;
};

搜索最大值

搜索最大值与搜索最小值类似,只是沿着树的右侧遍历。

this.max = function(node) {
    // min方法允许传入子树
    node = node || root;
    // 一直遍历左侧子节点,直到底部
    while (node && node.right !== null) {
        node = node.right;
    }
    return node;
};

搜索特定值

搜索特定值的处理与插入值的处理类似。遍历树,将要搜索的值与遍历到的节点比较,如果前者大于后者,则递归遍历右侧子节点,反之,则递归遍历左侧子节点。

this.search = function(key, node){
    // 同样的,search方法允许在子树中查找值
    node = node || root;
    return searchNode(key, node);
};
var searchNode = function(key, node){
    // 如果node是null,说明树中没有要查找的值,返回false
    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 node;
    }
};

移除节点

移除节点,首先要在树中查找到要移除的节点,再判断该节点是否有子节点、有一个子节点或者有两个子节点,最后分别处理。

this.remove = function(key, node){
    // 同样的,允许仅在子树中删除节点
    node = node || root;
    removeNode(key, node);
};
var removeNode = function (node, key) {
    // 找到要删除的节点
    var delete_node = this.search(node, key);
    // 如果node不存在,直接返回
    if (node === false) {
        return null;
    }
    // 第一种情况,该节点没有子节点
    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 = this.min(node.right);
    // 替换
    node.key = aux.key;
    // 删除最小值
    node.right = removeNode(node.right, aux.key);
    return node;
}

第三种情况的处理过程,如下图所示。当要删除的节点有两个子节点时,为了不破坏树的结构,删除后要替补上来的节点的键值大小必须在已删除节点的左、右子节点的键值之间,且替补上来的节点不应该有子节点,否则会产生一个节点有多个字节点的情况,因此,找右侧子树的最小值替换上来。同理,找左侧子树的最大值替换上来也可以。
clipboard.png


如果觉得我的文章对你有用,请随意赞赏

你可能感兴趣的

夜尽天明 · 7月16日

楼主你好,你那个移除节点那个方法写错了,我验证过了,会报错,应该是这样的 :

this.remove = function(key, node) {
    // 同样的,允许仅在子树中删除节点
    node = node || root;
    return removeNode(key, node);
};
var self = this;
var removeNode = function(key, node) {
    // console.log('node :', node);
    // 如果 node 不存在,直接返回
    if (node === false) {
        return null;
    }

    // 找到要删除的节点
    node = self.search(key, node);

    // 第一种情况,该节点没有子节点
    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 = self.min(node.right);
    // 替换
    node.key = aux.key;
    // 删除最小值
    node.right = removeNode(aux.key, node.right);
    return node;
};

回复

0

谢谢指正 我修改下

whale 作者 · 7月16日
载入中...