【数据结构】深度优先和广度优先比较

深度优先和广度优先比较
区别：

1） 二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。

2） 深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下：

先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。
中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树。
后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。
广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。

3）深度优先搜素算法：不全部保留结点，占用空间少；有回溯操作(即有入栈、出栈操作)，运行速度慢。

      广度优先搜索算法：保留全部结点，占用空间大； 无回溯操作(即无入栈、出栈操作)，运行速度快。

      通常 深度优先搜索法不全部保留结点，扩展完的结点从数据库中弹出删去，这样，一般在数据库中存储的结点数就是深度值，因此它占用空间较少。

所以，当搜索树的结点较多，用其它方法易产生内存溢出时，深度优先搜索不失为一种有效的求解方法。

      广度优先搜索算法，一般需存储产生的所有结点，占用的存储空间要比深度优先搜索大得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。

但广度优先搜索法一般无回溯操作，即入栈和出栈的操作，所以运行速度比深度优先搜索要快些

深度优先：

前序遍历：35,20,15,16,29,28,30,40,50,45,55

中序遍历：15,16,20,28,29,30,35,40,45,50,55

后序遍历：16,15,28,30,29,20,45,55,50,40,35

广度优先遍历：35 20 40 15 29 50 16 28 30 45 55

代码：

复制代码
package www.hhy;

import java.beans.beancontext.BeanContextChild;
import java.util.*;
class Binarytree {

 class TreeNode{
     int value;
     TreeNode left;
     TreeNode right;

     public TreeNode(int value) {
         this.value = value;
     }
 }


 //用递归创建二叉树
 public int i = 0;
 TreeNode creatTesttree(String s){
     TreeNode root = null;
     if (s.charAt(i)!='#') {
         root = new TreeNode(s.charAt(i));
         i++;
         root.left = creatTesttree(s);
         root.right = creatTesttree(s);
     }
     else{
         i++;
     }
     return  root;
 }


 //二叉树的前序遍历递归
 void binaryTreePrevOrder(TreeNode root){
     if(root==null){
         return;
     }
     System.out.println(root.value+" ");
     binaryTreePrevOrder(root.left);
     binaryTreePrevOrder(root.right);
 }


 //二叉树的中序遍历递归
 void binaryTreeInOrder(TreeNode root){
     if(root==null){
         return;
     }
     binaryTreeInOrder(root.left);
     System.out.println(root.value+" ");
     binaryTreeInOrder(root.right);

 }

 //二叉树的后续遍历递归
 void binaryTreePostOrder(TreeNode root){
     if(root==null){
         return;
     }
     binaryTreePostOrder(root.left);
     binaryTreePostOrder(root.right);
     System.out.println(root.value+" ");
 }

//层序遍历
void binaryTreeLevelOrder(TreeNode root,int level){
if(root null||level<1){
return;
}
if(level1){

             System.out.print(root.value+" ");


     }

     binaryTreeLevelOrder(root.left,level-1);
     binaryTreeLevelOrder(root.right,level-1);
 }

 void BTreeLevelOrder(TreeNode root)
 {
     if (root == null)
         return;
     int dep = getHeight(root);
     for (int i = 1; i <= dep; i++)
     {
        binaryTreeLevelOrder(root,i);
     }

 }



 //二叉树的层序遍历 非递归
 void binaryTreeLevelOrder(TreeNode root) {
     Queue<TreeNode> queue = new LinkedList<>();
     if(root != null) {
         queue.offer(root);
         //LinkedList  offer  add
     }
     while (!queue.isEmpty()) {
         //1、拿到队头的元素 把队头元素的左右子树入队
         TreeNode cur = queue.poll();
         System.out.print(cur.value+" ");
         //2、不为空的时候才能入队
         if(cur.left != null) {
             queue.offer(cur.left);
         }
         if(cur.right != null) {
             queue.offer(cur.right);
         }
     }
 }

 //二叉树的前序遍历非递归
 void binaryTreePrevOrderNonR(TreeNode root){
     Stack<TreeNode> stack = new Stack<>();
     TreeNode cur = root;
     TreeNode top = null;
     while (cur != null || !stack.empty()) {
         while (cur != null) {
             stack.push(cur);
             System.out.print(cur.value + " ");
             cur = cur.left;
         }
         top = stack.pop();
         cur = top.right;
     }
     System.out.println();
 }
 //二叉树的中序遍历非递归
 void binaryTreeInOrderNonR(TreeNode root){
     Stack<TreeNode> stack = new Stack<>();
     TreeNode cur = root;
     TreeNode top = null;
     while (cur != null || !stack.empty()) {
         while (cur != null) {
             stack.push(cur);
             cur = cur.left;
         }
         top = stack.pop();
         System.out.print(top.value+" ");
         cur = top.right;
     }
     System.out.println();
 }
 //二叉树的后序遍历非递归
 void binaryTreePostOrderNonR(TreeNode root) {
     Stack<TreeNode> stack = new Stack<>();
     TreeNode cur = root;
     TreeNode prev = null;
     while (cur != null || !stack.empty()) {
         while (cur != null) {
             stack.push(cur);
             cur = cur.left;
         }
         cur = stack.peek();//L  D
         //cur.right == prev 代表的是 cur的右边已经打印过了
         if(cur.right == null || cur.right == prev) {
             stack.pop();
             System.out.println(cur.value);
             prev = cur;
             cur = null;
         }else {
             cur = cur.right;
         }
     }
 }


 //二叉树的节点个数递归
 int getSize(TreeNode root){
     if(root==null){
         return 0;
     }
     return  getSize(root.left)+getSize(root.right)+1;
 }


 //二叉树的叶子节点的个数递归
 int getLeafSize(TreeNode root){
     if(root==null){
         return  0;
     }
     if(root.left==null && root.right==null){
         return 1;
     }
     return getLeafSize(root.left)+getLeafSize(root.right);

 }


 //二叉树得到第K层结点的个数

 int getKlevelSize(TreeNode root ,int k){
     if(root==null){
         return 0;
     }

      if(k == 1){
         return 1;
     }
     return  getKlevelSize(root.left,k-1)+getKlevelSize(root.right,k-1);
 }
 //二叉树查找并返回该结点递归
 // 查找，依次在二叉树的 根、左子树、
 // 右子树 中查找 value，如果找到，返回结点，否则返回 null
 TreeNode find(TreeNode root, int value){
     if(root == null) {
         return null;
     }
     if(root.value == value){
         return root;
     }
     TreeNode ret = find(root.left,value);
     if(ret != null) {
         return ret;
     }
     ret =  find(root.right,value);
     if(ret != null) {
         return ret;
     }
     return null;
 }







 //二叉树的高度
 int getHeight(TreeNode root){
     if(root==null){
         return 0;
     }
     int leftHeight = getHeight(root.left);
     int rightHeight = getHeight(root.right);
     return leftHeight>rightHeight ? leftHeight+1:rightHeight+1;
 }



 //判断一个树是不是完全二叉树
 public int binaryTreeComplete(TreeNode root) {
     Queue<TreeNode> queue = new LinkedList<TreeNode>();
     if(root != null) {
         queue.add(root);//offer
     }
     while(!queue.isEmpty()) {
         TreeNode cur = queue.peek();
         queue.poll();
         if(cur != null) {
             queue.add(cur.left);
             queue.add(cur.right);
         }else {
             break;
         }
     }
     while(!queue.isEmpty()) {
         TreeNode cur = queue.peek();
         if (cur != null){
             //说明不是满二叉树
             return -1;
         }else{
             queue.poll();
         }
     }
     return 0;//代表是完全二叉树
 }



 //检查两棵树是否是相同的，如果两棵树结构相同，并且在结点上的值相同，那么这两棵树是相同返回true
 public  boolean isSameTree(TreeNode p,TreeNode q){
     if((p==null&&q!=null)||(p!=null&&q==null)){
return false;


     }
     if(p==null && q==null){
         return  true;

     }
     if(p.value!=q.value){
         return  false;
     }
     return isSameTree(p.left,q.left)&&isSameTree(p.right,q.left);
 }


 //检查是否为子树
 public boolean isSubTree(TreeNode s,TreeNode t){
     if(s==null||t==null){
         return  false;
     }
     if(isSameTree(s,t)){
         return true;
     }
     else if (isSubTree(s.left,t)){
         return  true;

     }
     else if(isSubTree(s.right,t)){
         return true;
     }
     else{
         return false;
     }
 }

 //1.判断是否为平衡二叉树，左右子树的高度之差不超过 "1"(大根本身是平衡二叉树，左右子树也必须是平衡二叉树)
 // 时间复杂度为n^2
 //2.求复杂度为O(n)的解法
 public boolean isBanlanced(TreeNode root){
     if(root==null){
         return  true;
     }
     else{
         int leftHeight = getHeight(root.left);
         int rightHeight = getHeight(root.right);
         return Math.abs(leftHeight-rightHeight)<2
                 &&isBanlanced(root.left)
                 &&isBanlanced(root.right);
     }
 }



 //判断是否为对称二叉树
 public boolean isSymmetric(TreeNode root){
     if(root==null){
         return true;
     }
     return  isSymmetric(root.left,root.right);
 }

 public boolean isSymmetric(TreeNode lefttree,TreeNode righttree){
     if((lefttree==null && righttree!=null)||(lefttree!=null && righttree ==null)){
         return  false;
     }
     if(lefttree == null && righttree == null){
         return  true;
     }
     return lefttree.value == righttree.value && isSymmetric(lefttree.left,righttree.right)
             && isSymmetric(lefttree.right,righttree.left);
 }




  //二叉树创建字符串 非递归写法
 public String tree2str(TreeNode t){
     StringBuilder sb = new StringBuilder();
     tree2strchild(t,sb);
     return  sb.toString();

 }
 public void tree2strchild(TreeNode t ,StringBuilder sb){
     if (t==null){
         return;
     }
     sb.append(t.value);
     if (t.left!=null){
         sb.append("(");
         tree2strchild(t.left,sb);
         sb.append(")");
     }
     else {
         if (t.right==null){

         }
     }
 }

//二叉树字符串 递归写法
public String CreateStr(TreeNode t){
if(t==null){
return “”;

     }
     if(t.left==null&&t.right==null){
         return t.value+"";
     }
     if(t.left==null){
         return t.value+"()"+"("+CreateStr(t.right)+")";
     }
     if(t.right==null){
         return t.value+"("+CreateStr(t.left)+")";
     }

     return t.value+"("+CreateStr(t.left)+")"+"("+CreateStr(t.right)+")";

 }



     public int rob(TreeNode root) {
         if (root == null) return 0;
         return Math.max(robOK(root), robNG(root));
     }

     private int robOK(TreeNode root) {
         if (root == null) return 0;
         return root.value + robNG(root.left) + robNG(root.right);
     }

     private int robNG(TreeNode root) {
         if (root == null) return 0;
         return rob(root.left) + rob(root.right);
     }

//二叉树的公共祖先
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if(rootnull){
return null;
}
if(rootp||root==q){
return root;
}
TreeNode leftTree = lowestCommonAncestor(root.left,p,q);
//p||q null
TreeNode rightTree = lowestCommonAncestor(root.right,p,q);
//p||q null
//3
if(leftTree!=null && rightTree!=null){
return root;
}
//左边找到
else if (leftTree!=null ){
return leftTree;
}
//右边找到
else if(rightTree!=null){
return rightTree;
}
//都没找到的情况下
return null;
}

//二叉搜索树，若他的左子树不为空，左子树上的所有节点都小于根节点，
//如果他的右子树不为空，右子树上的所有节点都大于根节点
//最终他的中序排列都是有序结果
//输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。
// 要求不能创建任何新的结点，只能调整树中结点指针的指向。

 TreeNode prev = null;

 public void ConvertChild(TreeNode pCur) {
     if(pCur == null) {
         return ;
     }
     ConvertChild(pCur.left);

     pCur.left = prev;
     if(prev != null)
         prev.right = pCur;

     prev = pCur;

     ConvertChild(pCur.right);
 }

 public TreeNode Convert(TreeNode pRootOfTree) {
     ConvertChild(pRootOfTree);

     TreeNode head = pRootOfTree;

     while(head != null&& head.left != null) {
         head = head.left;
     }
     return head;

 }


 //给定一个二叉树的前序遍历和中序遍历，确定一棵二叉树
 /**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */


 /**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */


     public TreeNode build(int[] preorder, int[] inorder,
                           int inbegin,int inend) {
          int preindex = 0;

         //当前树 根本没有左子树或者是右子树
         if(inbegin > inend) {
             return null;
         }

         //根据前序遍历，确定根节点
         TreeNode root = new TreeNode(preorder[preindex]);
         //在中序遍历里面 找到根节点的下标
         int rootIndex = indexOfInorder(inorder,preorder[preindex],inbegin,
                 inend);
         preindex++;

         root.left = build(preorder,inorder,inbegin,rootIndex-1);

         root.right = build(preorder,inorder,rootIndex+1,inend);

         return root;
     }

     public int indexOfInorder(int[] inorder,int val,int inbegin,int inend) {
         for(int i = inbegin;i <= inend;i++) {
             if(inorder[i] == val) {
                 return i;
             }
         }
         return -1;
     }

     public TreeNode buildTree(int[] preorder, int[] inorder) {
         if(preorder.length == 0 || inorder.length == 0) {
             return null;
         }

         return build(preorder,inorder,0,inorder.length-1);
     }






 //根据一棵树的中序遍历与后序遍历构造二叉树

}

class Test{
public static void main(String[] args) {
Binarytree binarytree =new Binarytree();
Binarytree.TreeNode root =// binarytree.creatTesttree(“ABC##DE#G##F###”);
binarytree.creatTesttree(“AB##C##”);

    binarytree.BTreeLevelOrder(root);
    System.out.println();
    System.out.println("-----------------");
    binarytree.binaryTreePrevOrder(root);


}

}
转自原文