面试算法知识梳理(10) - 二叉查找树

面试算法代码知识梳理系列

面试算法知识梳理(1) - 排序算法
面试算法知识梳理(2) - 字符串算法第一部分
面试算法知识梳理(3) - 字符串算法第二部分
面试算法知识梳理(4) - 数组第一部分
面试算法知识梳理(5) - 数组第二部分
面试算法知识梳理(6) - 数组第三部分
面试算法知识梳理(7) - 数组第四部分
面试算法知识梳理(8) - 二分查找算法及其变型
面试算法知识梳理(9) - 链表算法第一部分
面试算法知识梳理(10) - 二叉查找树
面试算法知识梳理(11) - 二叉树算法第一部分
面试算法知识梳理(12) - 二叉树算法第二部分
面试算法知识梳理(13) - 二叉树算法第三部分


一、概述

二叉查找树 又称为 二叉搜索树,它是一棵空树,或者是具有下列性质的 二叉树

  • 若左子树不空,则左子树上所有结点的值均小于或等于它的结点
  • 若右子树不空,则右子树上所有结点的值均大于或等于它的根结点的值
  • 左、右子树也分别为二叉查找树

下面我们就来一起梳理一下和二叉查找树相关的知识点:

  • 建立二叉查找树
  • 删除二叉查找树中指定元素
  • 非递归遍历二叉查找树(先序遍历、中序遍历、后序遍历)

二、代码实现

2.1 建立二叉查找树

二叉查找树的表示

二叉查找树可以用Tree来表示,它包含一个root变量,用于存放这棵树的根结点,size表示树中元素的个数,每个结点Node包含以下的变量:

  • parent:指向其父结点
  • leftright:分别指向它的左孩子和右孩子
  • value:该结点存储的值

代码实现

下面我们输入一个数组p,通过它建立一个二叉查找树,并通过 递归中序遍历 的方式打印出树中的元素,按照二叉查找树的定义,最后输出的结果必然是递增排序的。

class Untitled {
    
    static class Tree {
        int size;
        Node root;
    }
    
    static class Node {
        Node parent;
        Node left;
        Node right;
        int value;
    }
    
    static void insertNode(Tree tree, int value) {
        if (tree == null) {
            return;
        }
        Node tNode = tree.root;
        //待插入结点的父结点,如果遍历完为空,说明此时是一个空树。
        Node pNode = null;
        //新的结点。
        Node nNode = new Node();
        nNode.value = value;
        while (tNode != null) {
            pNode = tNode;
            if (tNode.value > value) {
                tNode = tNode.left;
            } else {
                tNode = tNode.right;
            }
        }
        nNode.parent = pNode;
        if (pNode == null) {
            tree.root = nNode;
        } else if (pNode.value > value) {
            pNode.left = nNode;
        } else {
            pNode.right = nNode;
        }
        tree.size++;
    }
    
    static Tree createBinTree(int p[], int len) {
        Tree tree = new Tree();
        for (int i=0; i<len; i++) {
            int value = p[i];
            insertNode(tree, value);
        }
        return tree;
    }
    
    //递归的方式中序打印二叉查找树,最后输出的顺序必然是递增的。
    static void printInOrder(Node node) {
        if (node == null) {
            return;
        }
        printInOrder(node.left);
        System.out.println(node.value);
        printInOrder(node.right);
    }
    
    public static void main(String[] args) {
        int p[] = {4,5,6,1,2,3};
        Tree tree = createBinTree(p, p.length);
        printInOrder(tree.root);
    }
}

运行结果

>> 1
>> 2
>> 3
>> 4
>> 5
>> 6

2.2 删除二叉查找树中指定元素

在二叉查找树中删除某个元素,其核心思想就是 找到待删除结点的父结点,并将该父结点的leftright指向 待删除结点的孩子结点

  • 如果待删除结点只有一个孩子结点,那么用 该孩子结点替换待删除结点 即可。
  • 如果待删除结点有两个孩子结点,那么就需要进行如下几步操作:
    • 第一步:找到 待删除结点的右子树的最小结点 作为替换结点,如果该结点不是右子树的根节点,那么还需要 先用最小结点的右结点来替换最小结点
    • 第二步:用第一步找到的结点替换待删除结点
    • 第三步:将待删除结点的左子树的根节点嫁接到替换结点 上。
class Untitled {

    static class Tree {
        int size;
        Node root;
    }

    static class Node {
        Node parent;
        Node left;
        Node right;
        int value;
    }

    static void insertNode(Tree tree, int value) {
        if (tree == null) {
            return;
        }
        Node tNode = tree.root;
        //待插入结点的父结点,如果遍历完为空,说明此时是一个空树。
        Node pNode = null;
        //新的结点。
        Node nNode = new Node();
        nNode.value = value;
        while (tNode != null) {
            pNode = tNode;
            if (tNode.value > value) {
                tNode = tNode.left;
            } else {
                tNode = tNode.right;
            }
        }
        nNode.parent = pNode;
        if (pNode == null) {
            tree.root = nNode;
        } else if (pNode.value > value) {
            pNode.left = nNode;
        } else {
            pNode.right = nNode;
        }
        tree.size++;
    }

    static Tree createBinTree(int p[], int len) {
        Tree tree = new Tree();
        for (int i=0; i<len; i++) {
            int value = p[i];
            insertNode(tree, value);
        }
        return tree;
    }

    static Node searchNode(Tree tree, int value) {
        if (tree == null) {
            return null;
        }
        Node find = null;
        Node node = tree.root;
        while (node != null) {
            if (node.value > value) {
                node = node.left;
            } else if (node.value < value) {
                node = node.right;
            } else {
                find = node;
                break;
            }
        }
        return find;
    }

    static Node minNode(Node node) {
        while (node != null && node.left != null) {
            node = node.left;
        }
        return node;
    }

    static void transPlant(Tree tree, Node deleteNode, Node replaceNode) {
        if (deleteNode.parent == null) {
            tree.root = replaceNode;
        } else if (deleteNode.parent.left == deleteNode) {
            deleteNode.parent.left = replaceNode;
        } else if (deleteNode.parent.right == deleteNode) {
            deleteNode.parent.right = replaceNode;
        }
        if (replaceNode != null) {
            replaceNode.parent = deleteNode.parent;
        }
    }

    static void deleteNode(Tree tree, int value) {
        if (tree == null) {
            return;
        }
        Node deleteNode = searchNode(tree, value);
        if (deleteNode != null) {
            if (deleteNode.left == null) {
                transPlant(tree, deleteNode, deleteNode.right);
            } else if (deleteNode.right == null) {
                transPlant(tree, deleteNode, deleteNode.left);
            } else {
                Node replaceNode = minNode(deleteNode.right);
                if (replaceNode != deleteNode.right) {
                    transPlant(tree, replaceNode, replaceNode.right);
                    deleteNode.right.parent = replaceNode;
                    replaceNode.right = deleteNode.right;
                }
                transPlant(tree, deleteNode, replaceNode);
                deleteNode.left.parent = replaceNode;
                replaceNode.left = deleteNode.left;
            }
        }
    }

    //递归的方式中序打印二叉查找树,最后输出的顺序必然是递增的。
    static void printInOrder(Node node) {
        if (node == null) {
            return;
        }
        printInOrder(node.left);
        System.out.println(node.value);
        printInOrder(node.right);
    }

    public static void main(String[] args) {
        int p[] = {3,5,6,1,2,4};
        Tree tree = createBinTree(p, p.length);
        deleteNode(tree, 3);
        printInOrder(tree.root);
    }
}

运行结果

>> 1
>> 2
>> 4
>> 5
>> 6

2.3 非递归遍历方式

解决思路

对于二叉树的递归遍历,相信大家已经很熟悉了,这里演示的是如何通过“栈”来实现二叉树的非递归遍历:

class Untitled {

    static class Tree {
        int size;
        Node root;
    }

    static class Node {
        Node parent;
        Node left;
        Node right;
        int value;
    }

    static void insertNode(Tree tree, int value) {
        if (tree == null) {
            return;
        }
        Node tNode = tree.root;
        //待插入结点的父结点,如果遍历完为空,说明此时是一个空树。
        Node pNode = null;
        //新的结点。
        Node nNode = new Node();
        nNode.value = value;
        while (tNode != null) {
            pNode = tNode;
            if (tNode.value > value) {
                tNode = tNode.left;
            } else {
                tNode = tNode.right;
            }
        }
        nNode.parent = pNode;
        if (pNode == null) {
            tree.root = nNode;
        } else if (pNode.value > value) {
            pNode.left = nNode;
        } else {
            pNode.right = nNode;
        }
        tree.size++;
    }

    static Tree createBinTree(int p[], int len) {
        Tree tree = new Tree();
        for (int i=0; i<len; i++) {
            int value = p[i];
            insertNode(tree, value);
        }
        return tree;
    }
    
    //先序遍历。
    static void printPreOrder(Tree tree) {
        Node p[] = new Node[tree.size];
        int index = -1;
        Node node = tree.root;
        while (node != null || index >= 0) {
            while (node != null) {
                int value = node.value;
                System.out.println(node.value);
                index++;
                p[index] = node;
                node = node.left;
            }
            if (index >= 0) {
                node = p[index];
                p[index] = null;
                index--;
            }
            node = node.right;
        }
    }
    
    //中序遍历。
    static void printInOrder(Tree tree) {
        Node p[] = new Node[tree.size];
        int index = -1;
        Node node = tree.root;
        while (node != null || index >= 0) {
            while (node != null) {
                int value = node.value;
                index++;
                p[index] = node;
                node = node.left;
            }
            if (index >= 0) {
                node = p[index];
                System.out.println(node.value);
                p[index] = null;
                index--;
            
            }
            node = node.right;
        }
    }
    
    //后序遍历。
    static void printPostOrder(Tree tree) {
        Node p[] = new Node[tree.size];
        int index = 0;
        Node curNode = tree.root;
        Node preNode = null;
        p[index] = curNode;
        while (index >= 0) {
            curNode = p[index];
            //如果没有孩子结点。
            boolean hasNoChild = (curNode.left == null && curNode.right == null);
            //如果它的左孩子或者右孩子已经被访问过。
            boolean hasVisit = preNode == curNode.left || preNode == curNode.right;
            if (hasNoChild || hasVisit) {
                System.out.println(curNode.value);
                p[index] = null;
                index--;
                preNode = curNode;
            } else {
                //左孩子先入栈,保证右孩子先被访问。
                if (curNode.left != null) {
                    index++;
                    p[index] = curNode.left;
                } 
                if (curNode.right != null) {
                    index++;
                    p[index] = curNode.right;
                }
            }
        }
    }
    
    //递归的方式中序打印二叉查找树,最后输出的顺序必然是递增的。
    static void printInOrder(Node node) {
        if (node == null) {
            return;
        }
        printInOrder(node.left);
        System.out.println(node.value);
        printInOrder(node.right);
    }

    public static void main(String[] args) {
        int p[] = {3,5,6,1,2,4};
        Tree tree = createBinTree(p, p.length);
        System.out.println("- 先序遍历 - ");
        printPreOrder(tree);
        System.out.println("- 中序遍历 - ");
        printInOrder(tree);
        System.out.println("- 后序遍历 - ");
        printPostOrder(tree);
    }
}

运行结果

- 先序遍历 - 
3
1
2
5
4
6
- 中序遍历 - 
1
2
3
4
5
6
- 后序遍历 - 
6
4
5
2
1
3

更多文章,欢迎访问我的 Android 知识梳理系列:

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 151,511评论 1 330
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 64,495评论 1 273
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 101,595评论 0 225
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,558评论 0 190
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,715评论 3 270
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,672评论 1 192
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 31,112评论 2 291
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,837评论 0 181
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,417评论 0 228
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,928评论 2 232
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,316评论 1 242
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,773评论 2 234
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,253评论 3 220
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,827评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,440评论 0 180
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,523评论 2 249
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,583评论 2 249