树的基本遍历

/** * 求树的高度 * * @author Fangchao 2016年12月4日 */

 

  /**
     * 递归方法
     * 
     * @param root
     * @return
     */
    static int btdep(Node root) {
        if (root == null) {
            return 0;
        }
        int ldep = btdep(root.leftChild);
        int rdep = btdep(root.rightChild);
        if (ldep > rdep) {
            return ldep + 1;
        } else {
            return rdep + 1;
        }
    }


    /**
     * 非递归方法
     * 求每层的个数 树的最大宽度  都可以采用这种思想
     * @param root
     * @return
     */
    static int btdep2(Node root) {
        int front = -1, rear = -1;
        int last = 0, level = 0;
        Node[] queue = new Node[100000];
        if (root == null) {
            return 0;
        }
        queue[++rear]=root;
        Node p;
        while(front<rear){
            p=queue[++front];
            if(p.leftChild!=null){
                queue[++rear]=p.leftChild;
            }
            if(p.rightChild!=null){
                queue[++rear]=p.rightChild;
            }
            if(front==last){
                level++;
                last=rear;
            }
        }
        return level;
    }

 //树的层序遍历

 public static void BFSOrder(BinTree T)
    {
        if(T==null) return ;
        Queue<BinTree> queue = new ArrayDeque<BinTree>();    
        //队列小知识：使用offer和poll优于add和remove之处在于它们返回值可以判断成功与否，而不抛出异常
    
        queue.offer(T);              //算法1：根结点进入队列
        while(!queue.isEmpty())      //算法2：若队列非空，循环执行步骤 3-5，否则执行步骤6
        {
            T=queue.poll();          //算法3：将一个结点出队列，并访问该结点
            System.out.print(T.date);
            if(T.lchild!=null)       //算法4：若该结点的左子树为非空，则将该结点的左孩子结点入队列；
                queue.offer(T.lchild);
            if(T.rchild!=null)       //算法5：若该结点的左子树为非空，则将该结点的右孩子结点入队列；
                queue.offer(T.rchild);    
        }
        //步骤6结束
    }
    

 

/**
* 先序遍历
* 
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
* 
* @param node
*            遍历的节点
*/
public static void preOrderTraverse(Node node) {
if (node == null)
return;
System.out.print(node.data + " ");
preOrderTraverse(node.leftChild);
preOrderTraverse(node.rightChild);
}


/**
* 中序遍历
* 
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
* 
* @param node
*            遍历的节点
*/
public static void inOrderTraverse(Node node) {
if (node == null)
return;
inOrderTraverse(node.leftChild);
System.out.print(node.data + " ");
inOrderTraverse(node.rightChild);
}
}

 

 

 

在上面对二叉树的遍历操作中，使用的是中序遍历，这样遍历出来的数据是增序的。

 

 

层序遍历：若树不为空，则从树的第一层，根节点开始访问，从上而下逐层遍历，在同一层中，按从左到右的

  顺序对结点逐个访问

执行方式： 每一次打印一个结点的时候，如果该结点有子节点，则把该结点的子结点放到一个队列的末尾，

接下来到队列的头部取出最早进入队列的结点，重复前面的打印操作，知道所有的结点都被打印。

//一排一排的遍历 利用队列的特性哟，将根结点入队列 然后然后出入队列，出队列后将其左右孩子结点入队列
//直到队列为空
void SeqTraverse(BiTree tree)
{
    SeqQueue queue = Init_SeqQueue();
    Push_SeqQueue(queue, tree);
    while (!IsEmpty_SeqQueue(queue))
    {
        BiTree root = Pop_SeqQueue(queue);
        printf("%c ", root->data);
        if (root->lchild)
            Push_SeqQueue(queue, root->lchild);
        if(root->rchild)
            Push_SeqQueue(queue, root->rchild);
    }
    printf("\n");