package july.wild.All_Data_Structure_Impl;


import java.util.Stack;

/**使用遞迴一定要有返回值
 * @author 郭賽
 * @Company Huawei
 */
public class TreeNode {
    TreeNode left;
    TreeNode right;
    int data;
    public TreeNode(int data){
        this.data = data;
    }
    public TreeNode(){

    }

    TreeNode insertTreeNode(
 
int data,TreeNode root){

        if(root == null) {
            return new TreeNode(data);//新建節點
        }
        if(data < root.data)
            root.left =  insertTreeNode(data,root.left);
        else if(data > root.data)
            root.right =  insertTreeNode(data,root.right);
        else
 

            ;   //如果插入的數字和樹中的元素相等，什麼都不做
        return root;//讓後來的插入也能從root開始
/*
        if(root == null){
            root = new TreeNode(data);//這裡root.left每次都是賦值新的值
            return root;
        }
        if(data < root.data)
            return insertTreeNode(data,root.left);//這樣並沒有給root.left賦值，root.left節點不存在
        else if(data > root.data)
            return insertTreeNode(data,root.right);
 
*/

    }

    TreeNode findMin(TreeNode root){
        if(root == null)
            return null;
        else if(root.left == null)
            return root;
        return findMin(root.left);

    }
    TreeNode findMax(TreeNode root){
        if(root == null)
            return null;
        else if(root.right == null)
            return root;
        return findMax(root.right);
    }

    TreeNode deleteNode(TreeNode root,int data){//刪除節點
        if(root == null)    //樹為空，直接返回
            return null;
        if(data < root.data)
            root.left =  deleteNode(root.left,data);
        else if(data > root.data)
            root.right =  deleteNode(root.right,data);
        else if(root.right != null &&root.left != null) {
                int element = findMin(root.right).data;
                root.data = element;
                deleteNode(root.right,element);
            }
        else if(root.right != null)
            root = root.right;
        else
            root = root.left;
        return root;
    }

    void firstPrint(TreeNode root){//先序遍歷使用遞迴
        if(root == null)
            return;
        else {
            System.out.println(root.data);
            firstPrint(root.left);
            firstPrint(root.right);
        }
    }

    void firstPrintImpl_stack(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();//宣告一個堆疊
        while(root != null || !stack.isEmpty()) {
            while (root != null) {
                System.out.println(root.data);//先序
                stack.push(root);
                root = root.left;
            }
            if(!stack.isEmpty()){//棧不為空
                root = stack.pop();
                root = root.right;
            }
        }
    }

    void secondPrint(TreeNode root){//遞迴中序遍歷
        if(root != null){
            secondPrint(root.left);
            System.out.println(root.data);
            secondPrint(root.right);
        }
        else
            return;//結束一次遞迴

    }

    void secondPrintImpl_stack(TreeNode root) {//中序遍歷stack實現
        Stack<TreeNode> stack = new Stack<>();
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.left;//迭代到最左邊

            }
            if(!stack.isEmpty()) {
                root = stack.pop();
                System.out.println(root.data);
                root = root.right;
            }
        }
    }

    /**
     * 後序遍歷的堆疊實現,實現錯誤了，需要新增一個flag用作設定當前節點是否被列印了
     * @param root
     */
    void lastPrintImpl_stack(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            if(!stack.isEmpty()){
                root = stack.pop();
                if(root.right != null){//如果當前節點的右節點不為空
                    stack.push(root);
                    root = root.right;
                }else {
                    System.out.println(root.data);
                    root = null;
                    //如果右節點為空，直接輸出當前節點
                }
            }
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(5);
        for (int i = 0; i < 9; i++) {
            root.insertTreeNode(i,root);
        }
        while(root != null){
            System.out.println(root.data);
            root = root.left;
        }
       /* System.out.println(root.findMin(root).data);
        System.out.println(root.findMax(root).data);
        System.out.println("=================");
        root.firstPrint(root);
        System.out.println("============");
        System.out.println(root.insertTreeNode(4,root).data);
        root.firstPrint(root);*/
      /* root.firstPrint(root);
       System.out.println("=====================");
       root.firstPrintImpl_stack(root);
       *//*root.deleteNode(root,3);//這樣值傳遞不會改變root的值，將root的指標傳遞給deleteNode函式，然後通過指標訪問tree
       root.firstPrint(root);*//*
       System.out.println("中序遍歷的結果");
       //root.secondPrint(root);
       root.secondPrintImpl_stack(root);*/
        System.out.println("後序遍歷的結果");
        //root.lastPrintImpl_stack(root);
    }
}