面試算法知識(shí)梳理(10) - 二叉查找樹(shù)

面試算法代碼知識(shí)梳理系列

面試算法知識(shí)梳理(1) - 排序算法
面試算法知識(shí)梳理(2) - 字符串算法第一部分
面試算法知識(shí)梳理(3) - 字符串算法第二部分
面試算法知識(shí)梳理(4) - 數(shù)組第一部分
面試算法知識(shí)梳理(5) - 數(shù)組第二部分
面試算法知識(shí)梳理(6) - 數(shù)組第三部分
面試算法知識(shí)梳理(7) - 數(shù)組第四部分
面試算法知識(shí)梳理(8) - 二分查找算法及其變型
面試算法知識(shí)梳理(9) - 鏈表算法第一部分
面試算法知識(shí)梳理(10) - 二叉查找樹(shù)
面試算法知識(shí)梳理(11) - 二叉樹(shù)算法第一部分
面試算法知識(shí)梳理(12) - 二叉樹(shù)算法第二部分
面試算法知識(shí)梳理(13) - 二叉樹(shù)算法第三部分

一、概述

二叉查找樹(shù) 又稱(chēng)為 二叉搜索樹(shù)，它是一棵空樹(shù)，或者是具有下列性質(zhì)的 二叉樹(shù)

  • 若左子樹(shù)不空，則左子樹(shù)上所有結(jié)點(diǎn)的值均小于或等于它的結(jié)點(diǎn)
  • 若右子樹(shù)不空，則右子樹(shù)上所有結(jié)點(diǎn)的值均大于或等于它的根結(jié)點(diǎn)的值
  • 左、右子樹(shù)也分別為二叉查找樹(shù)

下面我們就來(lái)一起梳理一下和二叉查找樹(shù)相關(guān)的知識(shí)點(diǎn)：

  • 建立二叉查找樹(shù)
  • 刪除二叉查找樹(shù)中指定元素
  • 非遞歸遍歷二叉查找樹(shù)（先序遍歷、中序遍歷、后序遍歷）

二、代碼實(shí)現(xiàn)

2.1 建立二叉查找樹(shù)

二叉查找樹(shù)的表示

二叉查找樹(shù)可以用Tree來(lái)表示，它包含一個(gè)root變量，用于存放這棵樹(shù)的根結(jié)點(diǎn)，size表示樹(shù)中元素的個(gè)數(shù)，每個(gè)結(jié)點(diǎn)Node包含以下的變量：

  • parent：指向其父結(jié)點(diǎn)
  • left、right：分別指向它的左孩子和右孩子
  • value：該結(jié)點(diǎn)存儲(chǔ)的值

代碼實(shí)現(xiàn)

下面我們輸入一個(gè)數(shù)組p，通過(guò)它建立一個(gè)二叉查找樹(shù)，并通過(guò) 遞歸中序遍歷 的方式打印出樹(shù)中的元素，按照二叉查找樹(shù)的定義，最后輸出的結(jié)果必然是遞增排序的。

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;
        //待插入結(jié)點(diǎn)的父結(jié)點(diǎn)，如果遍歷完為空，說(shuō)明此時(shí)是一個(gè)空樹(shù)。
        Node pNode = null;
        //新的結(jié)點(diǎn)。
        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;
    }
    
    //遞歸的方式中序打印二叉查找樹(shù)，最后輸出的順序必然是遞增的。
    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);
    }
}

運(yùn)行結(jié)果

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

2.2 刪除二叉查找樹(shù)中指定元素

在二叉查找樹(shù)中刪除某個(gè)元素，其核心思想就是 找到待刪除結(jié)點(diǎn)的父結(jié)點(diǎn)，并將該父結(jié)點(diǎn)的left或right指向 待刪除結(jié)點(diǎn)的孩子結(jié)點(diǎn)

  • 如果待刪除結(jié)點(diǎn)只有一個(gè)孩子結(jié)點(diǎn)，那么用 該孩子結(jié)點(diǎn)替換待刪除結(jié)點(diǎn) 即可。
  • 如果待刪除結(jié)點(diǎn)有兩個(gè)孩子結(jié)點(diǎn)，那么就需要進(jìn)行如下幾步操作：
    • 第一步：找到 待刪除結(jié)點(diǎn)的右子樹(shù)的最小結(jié)點(diǎn) 作為替換結(jié)點(diǎn)，如果該結(jié)點(diǎn)不是右子樹(shù)的根節(jié)點(diǎn)，那么還需要 先用最小結(jié)點(diǎn)的右結(jié)點(diǎn)來(lái)替換最小結(jié)點(diǎn)
    • 第二步：用第一步找到的結(jié)點(diǎn)替換待刪除結(jié)點(diǎn)
    • 第三步：將待刪除結(jié)點(diǎn)的左子樹(shù)的根節(jié)點(diǎn)嫁接到替換結(jié)點(diǎn) 上。
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;
        //待插入結(jié)點(diǎn)的父結(jié)點(diǎn)，如果遍歷完為空，說(shuō)明此時(shí)是一個(gè)空樹(shù)。
        Node pNode = null;
        //新的結(jié)點(diǎn)。
        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;
            }
        }
    }

    //遞歸的方式中序打印二叉查找樹(shù)，最后輸出的順序必然是遞增的。
    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);
    }
}

運(yùn)行結(jié)果

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

2.3 非遞歸遍歷方式

解決思路

對(duì)于二叉樹(shù)的遞歸遍歷，相信大家已經(jīng)很熟悉了，這里演示的是如何通過(guò)“棧”來(lái)實(shí)現(xiàn)二叉樹(shù)的非遞歸遍歷：

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;
        //待插入結(jié)點(diǎn)的父結(jié)點(diǎn)，如果遍歷完為空，說(shuō)明此時(shí)是一個(gè)空樹(shù)。
        Node pNode = null;
        //新的結(jié)點(diǎn)。
        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];
            //如果沒(méi)有孩子結(jié)點(diǎn)。
            boolean hasNoChild = (curNode.left == null && curNode.right == null);
            //如果它的左孩子或者右孩子已經(jīng)被訪問(wèn)過(guò)。
            boolean hasVisit = preNode == curNode.left || preNode == curNode.right;
            if (hasNoChild || hasVisit) {
                System.out.println(curNode.value);
                p[index] = null;
                index--;
                preNode = curNode;
            } else {
                //左孩子先入棧，保證右孩子先被訪問(wèn)。
                if (curNode.left != null) {
                    index++;
                    p[index] = curNode.left;
                } 
                if (curNode.right != null) {
                    index++;
                    p[index] = curNode.right;
                }
            }
        }
    }
    
    //遞歸的方式中序打印二叉查找樹(shù)，最后輸出的順序必然是遞增的。
    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);
    }
}

運(yùn)行結(jié)果

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

更多文章，歡迎訪問(wèn)我的 Android 知識(shí)梳理系列：

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書(shū)系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。