二叉树的遍历和求二叉树的最长路径

二叉树作为最常碰到和最基础的数据结构，今天来聊一聊二叉树的遍历

二叉树的遍历分为深度优先遍历和广度优先遍历，其中，深度优先遍历又分为先序遍历，中序遍历和后序遍历三种。

先，中，后都是根据根节点而言的 ，即：

先序遍历：根——左——右

中序遍历：左——根——右

后序遍历：左——右——根

一 深度优先遍历递归实现

深度优先遍历递归的逻辑实现比较简单，就不多做解释，代码如下，相信都能看懂

//先序遍历	
public  void preOrderTraverse(TreeNode root) {
	if (root== null)
		return;
	System.out.print(root.val+ " ");
	preOrderTraverse(root.left);
	preOrderTraverse(root.right);
}

//中序遍历
public  void inOrderTraverse(TreeNode root) {
	if (root== null)
		return;
	inOrderTraverse(root.left);
	System.out.print(root.val+ " ");
	inOrderTraverse(root.right);
}

//后序遍历
public  void postOrderTraverse(TreeNode root) {
	if (root== null)
		return;
	postOrderTraverse(root.left);
	postOrderTraverse(root.right);
	System.out.print(root.val+ " ");
}

上面都是递归遍历，下面看一下非递归遍历，非递归遍历需要借助到栈

二  深度优先遍历非递归实现

深度优先遍历的非递归实现需要借助到栈作为辅助，代码如下

    //先序遍历
    public void preOrderTraverse(TreeNode root){
        if(root==null){
            System.out.println("empty tree");
        }else{
            LinkedList stack=new LinkedList();
            TreeNode node=root;
            while(!stack.isEmpty() || node!=null){
                if(node!=null){
                    System.out.print(node.val+" ");
                    stack.push(node);
                    node=node.left;
                }else{
                    TreeNode pNode=stack.pop();
                    node=pNode.right;
                }
            }
        }
    }


    //中序遍历
    public void midOrderTraverse(TreeNode root){
        if(root==null){
            System.out.println("empty tree");
        }else{
            LinkedList stack=new LinkedList();
            TreeNode node=root;
            while(!stack.isEmpty() || node!=null){
                if(node!=null){
                    stack.push(node);
                    node=node.left;
                }else{
                    TreeNode pNode=stack.pop();
                    System.out.print(pNode.val+" ");
                    node=pNode.right;
                }
            }
        }
    }

三  广度优先遍历非递归实现

广度优先遍历主要用到了队列作为辅助，代码如下

/**
     * 广度优先遍历
     * 採用非递归实现
     * 须要辅助数据结构：队列
     */
    public void levelOrderTraversal(Node root){
    	System.out.println("广度优先遍历");
        if(root==null){
            System.out.println("empty tree");
            return;
        }
        ArrayDeque queue=new ArrayDeque();
        queue.add(root);
        while(queue.isEmpty()==false){
        	Node node=queue.remove();
            System.out.print(node.data+ " ");
            if(node.leftChild!=null){
                queue.add(node.leftChild);
            }
            if(node.rightChild!=null){
                queue.add(node.rightChild);
            }
        }
        System.out.print("\n");
    }

四  求二叉树的最长路径递归算法

最长路径即从根节点到其所有叶子节点的路径中，找到那个最长的。

public int getlength(TreeNode root){
    if(root==null){
        return 0;
    }else{
        int left=getlength(root.left);   
        int right=getlength(root.right);
        return Math.max(left,right)+1;
    }
}

五  求二叉树的最长路径非递归算法

求二叉树最长路径的非递归算法其实是和层次遍历的逻辑一样的，算一下该二叉树有多少层就是最长路径，代码如下

    public static int getDepth(TreeNode root){
        if(root==null){
            return 0;
        }else{
            //记录二叉树的高度
           int depth=0;
           //记录遍历到当前层的第几个节点
            int num=0;
            //记录当前层的节点个数
            int count=1;
            LinkedList queue=new LinkedList<>();
            queue.add(root);
            while(!queue.isEmpty()){
                TreeNode node=queue.remove();
                num++;
                if(node.left!=null){
                    queue.add(node.left);
                }
                if(node.right!=null){
                    queue.add(node.right);
                }
                if(num==count){
                    depth++;
                    num=0;
                    count=queue.size();
                }
            }
           return depth;
        }
    }