評論：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);
}
}
}
}