【数据结构】4，树的基本概念及基本操作

8，树

树结构通常由一个父结点和若干子结点构成。它的查询和增删效率都非常高。任何一颗多叉树都能转换为二叉树的形式，所以研究二叉树不失一般性。

• 二叉树：每个结点最多只能有2个结点；

• 满二叉树：所有叶子结点都在同一层；

• 完全二叉树：所有叶子结点都与对应的满二叉树中编号1-n的结点一一对应；

二叉树的遍历方式：（父节点的输出顺序就能确定遍历的方式）

• 前序遍历：先输出父节点，再前序遍历左子树和右子数；

• 中序遍历：先中序遍历左子树，然后输出父节点，再中序遍历右子数；

• 后序遍历：先后序遍历右子树，然后后序遍历左子数，再输出父节点；

其中，遍历方式又有递归和迭代两种方式。使用DFS算法实现前中后序遍历；BFS算法实现层序遍历。

8.1，二叉树及相关操作

结点组成：仅有一个根节点：MyNode root

public class TreeNode {
    int val;
  	TreeNode left;
  	TreeNode right;
  	TreeNode() {}
  	TreeNode(int val) { this.val = val; }
  	TreeNode(int val, TreeNode left, TreeNode right) {
    		this.val = val;
    		this.left = left;
    		this.right = right;
  	}
}

遍历的实现：介绍先序遍历，中后序遍历类似。

    /**
     * 结点方法：先序遍历
     */
    public void preTraverse(){
        //先输出当前结点
        System.out.println(this);
        //递归遍历左子树
        if(this.getLeft()!=null){
            this.left.preTraverse();
        }
        //递归遍历右子树
        if(this.getRight()!=null){
            this.right.preTraverse();
        }
    }

	 /**
     * 二叉树方法：先序遍历
     */
    public void preTraverse(){
        if(root!=null){
            root.preTraverse();
        }else {
            System.out.println("二叉树为空！无法遍历！");
        }
    }

迭代法遍历：

 /**
     * 统一一下
     * @param root
     * @return
     */
    //前序
    public static List<Integer> preOrder(TreeNode root){
         List<Integer> list = new ArrayList();
         Stack<TreeNode> stack = new Stack();
         TreeNode cur = root;
         while(cur!=null || !stack.isEmpty()){
             //一直往左压入栈
             while(cur!=null){
                 list.add(cur.val);
                 stack.push(cur);
                 cur = cur.left;
             }
             //弹一个出来从
             cur = stack.pop();
             cur = cur.right;
         }
         return list;
    }

    //中序
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root == null){
            return new ArrayList();
        }
        List<Integer> list = new ArrayList();
        Stack<TreeNode> stack = new Stack();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur!=null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            list.add(cur.val);
            cur = cur.right;
        }
        return list;
    }


    //后序遍历，非递归
    public static List<Integer> postOrder(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
        TreeNode cur = root;
        TreeNode p = null;//用来记录上一节点
        while(!stack.isEmpty() || cur != null){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.peek();
//            后序遍历的过程中在遍历完左子树跟右子树cur都会回到根结点。所以当前不管是从左子树还是右子树回到根结点都不应该再操作了，应该退回上层。
//            如果是从右边再返回根结点，应该回到上层。
            //主要就是判断出来的是不是右子树，是的话就可以把根节点=加入到list了
            if(cur.right == null || cur.right == p){
                list.add(cur.val);
                stack.pop();
                p = cur;
                cur = null;
            }else{
                cur = cur.right;
            }

        }
        return list;
}

二叉树的层序遍历：

 public List<List<Integer>> levelOrder(TreeNode root) {
        // BFS算法
        List<List<Integer>> res = new ArrayList();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList();
        // 队列中存放节点
        queue.offer(root);
        // 控制纵向
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList();
            for(int i=0;i<size;i++){
                TreeNode curr = queue.poll();
                list.add(curr.val);
                if(curr.left!=null){
                    queue.add(curr.left);
                }
                if(curr.right!=null){
                    queue.add(curr.right);
                }
            }
            res.add(list);
        }
        return res;
    }

查找的实现：

/**
     * 中序查找指定结点
     * @param no
     * @return
     */
    public MyNode inOrderFind(int no){
        MyNode node = null;
        //递归遍历左子树
        if(this.left!=null){
            node = this.left.inOrderFind(no);
        }
        //左遍历结束后，查看是否找到,不为空即找到
        if(node!=null){
            return node;
        }
        if(this.no==no){
            return this;
        }
        //否则右序遍历
        if(this.right!=null){
            node = this.right.inOrderFind(no);
        }
        return node;
    }
/**
     * 中序查找
     * @param no
     * @return
     */
    public MyNode inOrderFind(int no){
        if(root!=null){
            return root.inOrderFind(no);
        }else {
            return null;
        }
    }

删除结点的实现：

约定：删除的结点为叶子结点则直接删除，非叶子结点则删除该结点及其所有子节点。

/**
     * 删除结点
     * @param no
     */
    public void deleteNode(int no) {
        if (root != null) {
            //如果当前结点为待删除结点，直接删除
            if (root.getNo() == no) {
                root=null;
                return;
            }
            root.deleteNode(no);
        }else {
            System.out.println("二叉树为空！不能删除！");
        }
    }
/**
     * 删除结点
     * 思路：找到当前结点的子结点是否为需要删除结点，是，直接置空，否则，向左递归删除，然后向右递归
     * @param no
     */
    public void deleteNode(int no){
        if(this.left!=null && this.left.no==no){
            this.left=null;
            return;
        }
        if(this.right!=null&& this.right.no==no){
            this.right=null;
            return;
        }
        if(this.left!= null){
            this.left.deleteNode(no);
        }
        if(this.right!= null){
            this.right.deleteNode(no);
        }
    }