數據結構 玩轉數據結構 6-6 二分搜索樹的前序遍歷

0　　　　課程地址

https://coding.imooc.com/lesson/207.html#mid=13459

 

1　　　　重點關注

1.1　　　　什麼是前序遍歷

遍歷，就是把二叉樹所有節點遍歷一遍，前序遍歷，就是先遍歷節點，再遍歷左節點，再遍歷右節點。

 

2　　　　課程內容

 

3　　　　Coding

3.1　　　　前序遍歷

• 關鍵代碼

        System.out.println(node.e);//1
        preOrder(node.left);
        preOrder(node.right);

 

• 全量代碼

package com.company;

public class BST2<E extends Comparable> {

    //1     內部類
    private class Node{
        //二叉樹特有屬性
        private Node left,right;
        private E e;
        private Node(E e){
            this.e = e;
            this.left = null;
            this.right = null;
        }
    }

    private int size;
    private Node root;

    public BST2(){
        this.size = 0;
        this.root = null;
    }

    /**
     * 定義基本方法 getSize
     * @author weidoudou
     * @date 2022/11/3 12:57
     * @return int
     **/
    public int getSize(){
        return size;
    }

    /**
     *查詢是否爲空
     * @author weidoudou
     * @date 2022/11/3 12:58
     * @return boolean
     **/
    public boolean isEmpty(){
        return size == 0;
    }

    //2     循環添加元素,把null也看作節點
    public void add(E e){
        root = add(e,root);
    }

    //3     遞歸，添加元素
    public Node add(E e,Node root){
        //3.1   終止條件
        if(root==null){
            size++;
            return new Node(e);
        }

        //3.2   遞歸
        //3.2.1 遞歸左孩子
        if(e.compareTo(root.e)<0){
            root.left = add(e,root.left);
        }

        //3.2.2 遞歸右孩子
        if(e.compareTo(root.e)>0){
            root.right = add(e,root.right);
        }

        //點睛之筆
        return root;
    }

    /**
     * 二分搜索樹 是否包含元素e
     * @author weidoudou
     * @date 2022/11/4 9:55
     * @param e 請添加參數描述
     * @return boolean
     **/
    public boolean contains(E e){
        return contains(e,root);
    }

    /**
     * 二分搜索樹查詢 遞歸
     * @author weidoudou
     * @date 2022/11/4 9:57
     * @param e 請添加參數描述
     * @param  node 請添加參數描述
     * @return boolean
     **/
    private boolean contains(E e,Node node){
        //終止條件
        if(node == null){
            return false;
        }
        if(e.compareTo(node.e)==0){
            return true;
        }

        //遞歸條件
        if(e.compareTo(node.e)<0){
            return contains(e,node.left);
        }else{
            return contains(e,node.right);
        }

    }


}

 

• 測試類：

public class Main {

    public static void main(String[] args) {
        BST2<Integer> bst2 = new BST2<>();
        int [] nums = {5,3,6,8,4,2};
        for(int i = 0;i<nums.length;i++){
            bst2.add(nums[i]);
        }

        System.out.println(bst2.preOrder());
        System.out.println(bst2);


    }

 

 

• 測試結果：

5
3
2
4
6
8
false
5
==3
====2
======null
======null
====4
======null
======null
==6
====null
====8
======null
======null


Process finished with exit code 0

 

 

 

3.2　　　　二叉樹深度打印

/**
     * 基於前序遍歷完成toString打印
     * @author weidoudou
     * @date 2022/11/5 15:20
     * @return java.lang.String
     **/
    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer();
        generate(root,0);
        return sb.toString();
    }

    private void generate(Node node, int depth){
        generate(depth);
        //1     終止條件
        if(node==null){
            System.out.println("null");
            return;
        }

        //2     遞歸條件
        System.out.println(node.e);
        depth++;
        generate(node.left,depth);
        generate(node.right,depth);
    }

    private void generate(int depth){
        for(int i = 0;i<depth;i++){
            System.out.print("==");
        }
    }