二叉樹的生成與遍歷

二叉樹的生成

一層一層進行輸入，如果孩子為空則輸入-1

private static TreeNode createTree() {
		// TODO 自動生成的方法存根
		Scanner in = new Scanner(System.in);
		MyQueen queen=new MyQueen();
		String data=in.nextLine();
		TreeNode father=new TreeNode(data);
		TreeNode root;
		TreeNode child;
		queen.offer(father);
		while(true)
		{
			if(queen.isEmpty())
			{
				break;
			}
			root=(TreeNode) queen.peek();
			data=in.nextLine();
			if(!data.equals("-1"))
			{
				child=new TreeNode(data);
				queen.offer(child);
				root.lChild=child;
			}
			data=in.nextLine();
			if(!data.equals("-1"))
			{
				child=new TreeNode(data);
				queen.offer(child);
				root.rChild=child;
			}
			queen.poll();
		}
		return father;
	}
}

樹的主要遍歷方式

• 前序遍歷：根結點 ---> 左子樹 ---> 右子樹

• 中序遍歷：左子樹---> 根結點 ---> 右子樹

• 后序遍歷：左子樹 ---> 右子樹 ---> 根結點

• 層次遍歷(廣度優先遍歷)：一層一層地遍歷

上面二叉樹的遍歷結果

• 前序遍歷：1 2 4 5 7 8 3 6

• 中序遍歷：4 2 7 5 8 1 3 6

• 后序遍歷：4 7 8 5 2 6 3 1

• 層次遍歷：1 2 3 4 5 6 7 8

四種遍歷方式的代碼

/**
	 * 二叉樹的先序遍歷
	 * @param node 根節點
	 */
	public static void preRootTreaverse(TreeNode node)
	{
		if(node==null)
			return;
		System.out.print(node.data+" ");
		preRootTreaverse(node.lChild);
		preRootTreaverse(node.rChild);
	}
	/**
	 * 二叉樹的中序遍歷
	 * @param node 根節點
	 */
	public static void inRootTreaverse(TreeNode node)
	{
		if(node==null)
			return;
		inRootTreaverse(node.lChild);
		System.out.print(node.data+" ");
		inRootTreaverse(node.rChild);
	}
	/**
	 * 二叉樹的后序遍歷
	 * @param node
	 */
	public static void postRootTreaverse(TreeNode node)
	{
		if(node==null)
			return;
		postRootTreaverse(node.lChild);
		postRootTreaverse(node.rChild);
		System.out.print(node.data+" ");
	}
	/**
	 * 二叉樹廣度遍歷
	 * @param root
	 */
	public static void bfs(TreeNode root)
	{
		MyQueen queen=new MyQueen();
		queen.offer(root);
		TreeNode lChirld,rChirld;
		while(!queen.isEmpty())
		{
			root=(TreeNode)queen.peek();
			System.out.print(root.data+" ");
			lChirld=root.lChild;
			if(lChirld!=null)
			{
				queen.offer(lChirld);
			}
			rChirld=root.rChild;
			if(rChirld!=null)
			{
				queen.offer(rChirld);
			}
			queen.poll();
		}
	}

二叉樹葉節點的個數

/**
	 * 廣度遍歷獲得葉節點個數
	 * @param root
	 * @return
	 */
public static int getLeftNum(TreeNode root)
	{
		int count=0;
		int flag=0;
		MyQueen queen=new MyQueen();
		queen.offer(root);
		TreeNode lChirld,rChirld;
		while(!queen.isEmpty())
		{
			root=(TreeNode)queen.peek();
			lChirld=root.lChild;
			if(lChirld!=null)
			{
				queen.offer(lChirld);
			}
			else
			{
				flag+=1;
			}
			rChirld=root.rChild;
			if(rChirld!=null)
			{
				queen.offer(rChirld);
			}
			else
			{
				flag+=1;
			}
			//如果同時沒有左孩子和有孩子 那么葉節點個數加一
			if(flag==2)
			{
				count++;
			}
			//標志還原
			flag=0;
			queen.poll();
		}
		return count;
	}
	/**
	 * 通過深度遍歷獲得葉節點個數
	 * @param node
	 */
	public static void getLeftNum2(TreeNode node)
	{
		if(node.lChild==null&&node.rChild==null)
		{
			nums++;
			return;
		}
		if(node.lChild!=null)
			getLeftNum2(node.lChild);
		if(node.rChild!=null)
			getLeftNum2(node.rChild);
	}

二叉樹根節點的個數

/**
	 * 廣度遍歷獲得根節點個數
	 * @param root
	 * @return
	 */
	public static int getRootNum(TreeNode root)
	{
		int count=0;
		//是否為葉子
		boolean isLeft=true;
		MyQueen queen=new MyQueen();
		queen.offer(root);
		TreeNode lChirld,rChirld;
		while(!queen.isEmpty())
		{
			root=(TreeNode)queen.peek();
			lChirld=root.lChild;
			//左右孩子任意一個不為空 說明為根節點
			if(lChirld!=null)
			{
				queen.offer(lChirld);
				isLeft=false;
			}
			rChirld=root.rChild;
			if(rChirld!=null)
			{
				queen.offer(rChirld);
				isLeft=false;
			}
			if(!isLeft)
			{
				count++;
			}
			isLeft=true;
			queen.poll();
		}
		return count;
	}
	/**
	 * 通過深度遍歷獲得根節點個數
	 * @param node
	 */
	public static void getRootNum2(TreeNode node)
	{
		if(node.lChild==null&&node.rChild==null)
		{
			return;
		}
		else
			nums++;
		if(node.lChild!=null)
			getRootNum2(node.lChild);
		if(node.rChild!=null)
			getRootNum2(node.rChild);
	}

測試代碼

public static void main(String[] args) {
		
		TreeNode father=createTree();
		preRootTreaverse(father);
		System.out.println("先序遍歷");
		inRootTreaverse(father);
		System.out.println("中序遍歷");
		postRootTreaverse(father);
		System.out.println("后序遍歷");
		bfs(father);
		System.out.println("廣度遍歷");
		System.out.println("通過廣度遍歷獲得葉節點個數:"+getLeftNum(father));
		System.out.println("通過廣度遍歷獲得根節點個數:"+getRootNum(father));
		getLeftNum2(father);
		System.out.println("通過深度遍歷獲得葉節點個數:"+nums);
		nums=0;
		getRootNum2(father);
		System.out.println("通過深度遍歷獲得根節點個數:"+nums);
		
	}

輸入數據(構建上面圖的二叉樹)
1
2
3
4
5
-1
6
-1
-1
7
8
-1
-1
-1
-1
-1
-1
輸出結果
4 2 7 5 8 1 3 6 中序遍歷
4 7 8 5 2 6 3 1 后序遍歷
1 2 3 4 5 6 7 8 廣度遍歷
通過廣度遍歷獲得葉節點個數:4
通過廣度遍歷獲得根節點個數:4
通過深度遍歷獲得葉節點個數:4
通過深度遍歷獲得根節點個數:4