圖論思考之路徑優化——深度/廣度優先遍歷

文章目錄


參考博客

評論:LinkList換成arrayDeque會更好,然後二叉Tree的建立有沒有更優的呢?

概念定義:

深度優先遍歷:深度優先遍歷是圖論中的經典算法。其利用了深度優先搜索算法可以產生目標圖的相應拓撲排序表,採用拓撲排序表可以解決很多相關的圖論問題,如最大路徑問題等等。

根據深度優先遍歷的特點我們利用Java集合類的棧Stack先進後出的特點來實現。我用二叉樹來進行深度優先搜索。
在這裏插入圖片描述
深度優先搜索的步驟爲:

(1)、首先節點 1 進棧,節點1在棧頂;

(2)、然後節點1出棧,訪問節點1,節點1的孩子節點3進棧,節點2進棧;

(3)、節點2在棧頂,然後節點2出棧,訪問節點2

(4)、節點2的孩子節點5進棧,節點4進棧

(5)、節點4在棧頂,節點4出棧,訪問節點4,

(6)、節點4左右孩子爲空,然後節點5在棧頂,節點5出棧,訪問節點5;

(7)、節點5左右孩子爲空,然後節點3在站頂,節點3出棧,訪問節點3;

(8)、節點3的孩子節點7進棧,節點6進棧

(9)、節點6在棧頂,節點6出棧,訪問節點6;

(10)、節點6的孩子爲空,這個時候節點7在棧頂,節點7出棧,訪問節點7

(11)、節點7的左右孩子爲空,此時棧爲空,遍歷結束。

廣度優先遍歷:廣度優先遍歷是連通圖的一種遍歷策略,因爲它的思想是從一個頂點V0開始,輻射狀地優先遍歷其周圍較廣的區域故得名。

根據廣度優先遍歷的特點我們利用Java數據結構隊列Queue來實現。

廣度優先搜索的步驟爲:

(1)、節點1進隊,節點1出隊,訪問節點1

(2)、節點1的孩子節點2進隊,節點3進隊。

(3)、節點2出隊,訪問節點2,節點2的孩子節點4進隊,節點5進隊;

(4)、節點3出隊,訪問節點3,節點3的孩子節點6進隊,節點7進隊;

(5)、節點4出隊,訪問節點4,節點4沒有孩子節點。

(6)、節點5出隊,訪問節點5,節點5沒有孩子節點。

(7)、節點6出隊,訪問節點6,節點6沒有孩子節點。

(8)、節點7出隊,訪問節點7,節點7沒有孩子節點,結束。

代碼:

二叉樹的基礎代碼:

/**
 * 二叉樹數據結構
 * 
 *
 */
public class TreeNode {
	int data;
	TreeNode leftNode;
	TreeNode rightNode;
	public TreeNode() {
		
	}
	public TreeNode(int d) {
		data=d;
	}
	
	public TreeNode(TreeNode left,TreeNode right,int d) {
		leftNode=left;
		rightNode=right;
		data=d;
	}
	
}

廣度優先和深度優先遍歷算法實現代碼:

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
 
/**
 * 深度優先遍歷
 * 
 *
 */
public class DeepFirstSort {
	public static void main(String[] args) {
		TreeNode head=new TreeNode(1);
		TreeNode second=new TreeNode(2);
		TreeNode three=new TreeNode(3);
		TreeNode four=new TreeNode(4);
		TreeNode five=new TreeNode(5);
		TreeNode six=new TreeNode(6);
		TreeNode seven=new TreeNode(7);
		head.rightNode=three;
		head.leftNode=second;
		second.rightNode=five;
		second.leftNode=four;
		three.rightNode=seven;
		three.leftNode=six;
		System.out.print("廣度優先遍歷結果:");
		new DeepFirstSort().BroadFirstSearch(head);
		System.out.println();
		System.out.print("深度優先遍歷結果:");
		new DeepFirstSort().depthFirstSearch(head);
	}
	
	//廣度優先遍歷是使用隊列實現的
	public void BroadFirstSearch(TreeNode nodeHead) {
		if(nodeHead==null) {
			return;
		}
		Queue<TreeNode> myQueue=new LinkedList<>();
		myQueue.add(nodeHead);
		while(!myQueue.isEmpty()) {
			TreeNode node=myQueue.poll();
			System.out.print(node.data+" ");
			if(null!=node.leftNode) {
				myQueue.add(node.leftNode);    //深度優先遍歷,我們在這裏採用每一行從左到右遍歷
			}
			if(null!=node.rightNode) {
				myQueue.add(node.rightNode);
			}
			
		}
	}
	
	//深度優先遍歷
	public void depthFirstSearch(TreeNode nodeHead) {
		if(nodeHead==null) {
			return;
		}
		Stack<TreeNode> myStack=new Stack<>();
		myStack.add(nodeHead);
		while(!myStack.isEmpty()) {
			TreeNode node=myStack.pop();    //彈出棧頂元素
			System.out.print(node.data+" ");
			if(node.rightNode!=null) {
				myStack.push(node.rightNode);    //深度優先遍歷,先遍歷左邊,後遍歷右邊,棧先進後出
			}
			if(node.leftNode!=null) {
				myStack.push(node.leftNode);
			}
		}
		
	}
 
}
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章