树的深度优先与广度优先遍历

来源：互联网发布：tensorflow c api 编辑：程序博客网时间：2024/05/16 10:35

原题出自百度的笔试：

简述树的深度优先及广度优先遍历算法,并说明非递归实现。

当时我看到这个题目的时候，已经完全记不得非递归算法该怎么实现了，后来查阅了一下，要用到两个辅助的数据结构：

深度优先遍历--->栈；

广度优先遍历--->队列；

这里以二叉树为例来实现。

Java代码  
import java.util.ArrayDeque;  
  
public class BinaryTree {  
    static class TreeNode{  
        int value;  
        TreeNode left;  
        TreeNode right;  
          
        public TreeNode(int value){  
            this.value=value;  
        }  
    }  
      
    TreeNode root;  
      
    public BinaryTree(int[] array){  
        root=makeBinaryTreeByArray(array,1);  
    }  
  
    /** 
     * 采用递归的方式创建一颗二叉树 
     * 传入的是二叉树的数组表示法 
     * 构造后是二叉树的二叉链表表示法 
     */  
    public static TreeNode makeBinaryTreeByArray(int[] array,int index){  
        if(index<array.length){  
            int value=array[index];  
            if(value!=0){  
                TreeNode t=new TreeNode(value);  
                array[index]=0;  
                t.left=makeBinaryTreeByArray(array,index*2);  
                t.right=makeBinaryTreeByArray(array,index*2+1);  
                return t;  
            }  
        }  
        return null;  
    }  
      
    /** 
     * 深度优先遍历，相当于先根遍历 
     * 采用非递归实现 
     * 需要辅助数据结构：栈 
     */  
    public void depthOrderTraversal(){  
        if(root==null){  
            System.out.println("empty tree");  
            return;  
        }         
        ArrayDeque<TreeNode> stack=new ArrayDeque<TreeNode>();  
        stack.push(root);         
        while(stack.isEmpty()==false){  
            TreeNode node=stack.pop();  
            System.out.print(node.value+"    ");  
            if(node.right!=null){  
                stack.push(node.right);  
            }  
            if(node.left!=null){  
                stack.push(node.left);  
            }             
        }  
        System.out.print("\n");  
    }  
  
    /** 
     * 广度优先遍历 
     * 采用非递归实现 
     * 需要辅助数据结构：队列 
     */  
    public void levelOrderTraversal(){  
        if(root==null){  
            System.out.println("empty tree");  
            return;  
        }  
        ArrayDeque<TreeNode> queue=new ArrayDeque<TreeNode>();  
        queue.add(root);  
        while(queue.isEmpty()==false){  
            TreeNode node=queue.remove();  
            System.out.print(node.value+"    ");  
            if(node.left!=null){  
                queue.add(node.left);  
            }  
            if(node.right!=null){  
                queue.add(node.right);  
            }  
        }  
        System.out.print("\n");  
    }  
      
    /**  
     *                  13 
     *                 /  \ 
     *               65    5 
     *              /  \    \ 
     *             97  25   37 
     *            /    /\   / 
     *           22   4 28 32 
     */  
    public static void main(String[] args) {  
        int[] arr={0,13,65,5,97,25,0,37,22,0,4,28,0,0,32,0};  
        BinaryTree tree=new BinaryTree(arr);  
        tree.depthOrderTraversal();  
        tree.levelOrderTraversal();  
    }  
}  

0 0