基本数据结构之二叉树

C语言实现二叉树的遍历

二叉树结点的定义

/*
    先序，中序，后序的遍历时间复杂度为O(n)，每个结点只访问一次。

    层序的时间复杂度最差为O(n^2)，当二叉树基本平衡时，时间复杂度为O(n)

    n为结点个数
*/

typedef int tree_node_element;
/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的结点数据结构
 *  
 */
typedef struct binary_tree_node
{
    binary_tree_node* left; //左孩子
    binary_tree_node* right; //右孩子
    tree_node_element element; //数据节点

    //构造函数
    binary_tree_node(tree_node_element x) : element(x), left(NULL), right(NULL) {}
}binary_tree_node;

二叉树递归遍历

/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的前序遍历，递归 根-左-右
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return 无返回
 *  
 */
void pre_order_r(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    if (root == NULL)
        return;
    visit(root);
    pre_order_r(root->left, visit);
    pre_order_r(root->right, visit);
}

/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的中序遍历 ，递归版 左-根-右
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return 无
 *  
 */
void in_order_r(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    if (root == NULL)
        return;
    in_order_r(root->left, visit);
    visit(root);
    in_order_r(root->right, visit);
}
/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的后序遍历 ，递归版 左-右-根
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return 无
 *  
 */
void post_order_r(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    if (root == NULL)
        return;
    post_order_r(root->left, visit);
    post_order_r(root->right, visit);
    visit(root);
}

二叉树的非递归遍历

/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的前序遍历，非递归版 -- 使用栈完成，递归的本质也是栈
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return
 *  
 */
void pre_order(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    const binary_tree_node *temp = root;
    std::stack<const binary_tree_node*> avgSatck;

    //首先根节点入栈
    if (temp != NULL)
        avgSatck.push(temp);
    while (!avgSatck.empty())
    {
        temp = avgSatck.top(); //在这里改变temp
        avgSatck.pop(); 
        visit(temp); //第一步打印出根节点之后，栈是空的。

        if (temp->right != NULL)
            avgSatck.push(temp->right);

        if (temp->left != NULL)
            avgSatck.push(temp->left);
    }
}

/**
* @author 韦轩
* @time 2015/07/11
* @brief 二叉树的中序遍历，非递归版 -- 使用栈完成，递归的本质也是栈
* @param root根节点
* @param visit 访问根节点的函数指针
* @return
*
*/
void in_order(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    const binary_tree_node *temp;
    std::stack<const binary_tree_node*> avgSatck;
    temp = root;
    while (!avgSatck.empty() || temp != NULL)
    {
        if (temp != NULL)
        {
            avgSatck.push(temp);
            temp = temp->left;
        }
        else
        {
            temp = avgSatck.top();
            avgSatck.pop();
            visit(temp);
            temp = temp->right;
        }
    }
}

/**
* @author 韦轩
* @time 2015/07/11
* @brief 二叉树的后序遍历，非递归版 -- 使用栈完成，递归的本质也是栈
* @param root根节点
* @param visit 访问根节点的函数指针
* @return
*
*/
void post_order(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    const binary_tree_node *temp1,*temp2;
    std::stack<const binary_tree_node*> avgSatck;
    temp1 = root;

    do 
    {
        while (temp1 != NULL)
        {
            avgSatck.push(temp1);
            temp1 = temp1->left;
        }
        temp2 = NULL;
        while (!avgSatck.empty())
        {
            temp1 = avgSatck.top();
            avgSatck.pop();

            if (temp1->right == temp2)
            {
                visit(temp1);
                temp2 = temp1;
            }
            else
            {
                avgSatck.push(temp1);
                temp1 = temp1->right;
                break;
            }
        }
    } while (!avgSatck.empty());
}

二叉树的层次遍历

层次遍历个非递归的前序遍历代码一样，只不过要将辅助的存储结构改为队列

/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的层次遍历 和前序遍历一模一样，不过改用队列存储
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return
 *  
 */
void level_order(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    const binary_tree_node *temp = root;
    std::queue<const binary_tree_node*> avgQueue;

    if (temp != NULL)
        avgQueue.push(temp);
    while (!avgQueue.empty())
    {
        temp = avgQueue.front();
        avgQueue.pop();
        visit(temp);

        if (temp->left != NULL)
            avgQueue.push(temp->left);
        if (temp->right != NULL)
            avgQueue.push(temp->right);
    }
}

完整的工程

#include <iostream>
#include <stack>
#include <queue>
#include <math.h>

/*
    先序，中序，后序的遍历时间复杂度为O(n)，每个结点只访问一次。

    层序的时间复杂度最差为O(n^2)，当二叉树基本平衡时，时间复杂度为O(n)

    n为结点个数
*/

typedef int tree_node_element;
/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的结点数据结构
 *  
 */
typedef struct binary_tree_node
{
    binary_tree_node* left; //左孩子
    binary_tree_node* right; //右孩子
    tree_node_element element; //数据节点

    //构造函数
    binary_tree_node(tree_node_element x) : element(x), left(NULL), right(NULL) {}
}binary_tree_node;

/* 二叉树的遍历，包括递归和非递归版本 */

/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的前序遍历，递归 根-左-右
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return 无返回
 *  
 */
void pre_order_r(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    if (root == NULL)
        return;
    visit(root);
    pre_order_r(root->left, visit);
    pre_order_r(root->right, visit);
}

/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的中序遍历 ，递归版 左-根-右
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return 无
 *  
 */
void in_order_r(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    if (root == NULL)
        return;
    in_order_r(root->left, visit);
    visit(root);
    in_order_r(root->right, visit);
}
/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的后序遍历 ，递归版 左-右-根
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return 无
 *  
 */
void post_order_r(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    if (root == NULL)
        return;
    post_order_r(root->left, visit);
    post_order_r(root->right, visit);
    visit(root);
}

/*二叉树遍历的非递归版*/

/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的前序遍历，非递归版 -- 使用栈完成，递归的本质也是栈
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return
 *  
 */
void pre_order(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    const binary_tree_node *temp = root;
    std::stack<const binary_tree_node*> avgSatck;

    //首先根节点入栈
    if (temp != NULL)
        avgSatck.push(temp);
    while (!avgSatck.empty())
    {
        temp = avgSatck.top(); //在这里改变temp
        avgSatck.pop(); 
        visit(temp); //第一步打印出根节点之后，栈是空的。

        if (temp->right != NULL)
            avgSatck.push(temp->right);

        if (temp->left != NULL)
            avgSatck.push(temp->left);
    }
}

/**
* @author 韦轩
* @time 2015/07/11
* @brief 二叉树的中序遍历，非递归版 -- 使用栈完成，递归的本质也是栈
* @param root根节点
* @param visit 访问根节点的函数指针
* @return
*
*/
void in_order(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    const binary_tree_node *temp;
    std::stack<const binary_tree_node*> avgSatck;
    temp = root;
    while (!avgSatck.empty() || temp != NULL)
    {
        if (temp != NULL)
        {
            avgSatck.push(temp);
            temp = temp->left;
        }
        else
        {
            temp = avgSatck.top();
            avgSatck.pop();
            visit(temp);
            temp = temp->right;
        }
    }
}

/**
* @author 韦轩
* @time 2015/07/11
* @brief 二叉树的后序遍历，非递归版 -- 使用栈完成，递归的本质也是栈
* @param root根节点
* @param visit 访问根节点的函数指针
* @return
*
*/
void post_order(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    const binary_tree_node *temp1,*temp2;
    std::stack<const binary_tree_node*> avgSatck;
    temp1 = root;

    do 
    {
        while (temp1 != NULL)
        {
            avgSatck.push(temp1);
            temp1 = temp1->left;
        }
        temp2 = NULL;
        while (!avgSatck.empty())
        {
            temp1 = avgSatck.top();
            avgSatck.pop();

            if (temp1->right == temp2)
            {
                visit(temp1);
                temp2 = temp1;
            }
            else
            {
                avgSatck.push(temp1);
                temp1 = temp1->right;
                break;
            }
        }
    } while (!avgSatck.empty());
}

/**
 * @author 韦轩
 * @time 2015/07/11
 * @brief 二叉树的层次遍历 和前序遍历一模一样，不过改用队列存储
 * @param root根节点
 * @param visit 访问根节点的函数指针
 * @return
 *  
 */
void level_order(const binary_tree_node *root, int(*visit)(const binary_tree_node*))
{
    const binary_tree_node *temp = root;
    std::queue<const binary_tree_node*> avgQueue;

    if (temp != NULL)
        avgQueue.push(temp);
    while (!avgQueue.empty())
    {
        temp = avgQueue.front();
        avgQueue.pop();
        visit(temp);

        if (temp->left != NULL)
            avgQueue.push(temp->left);
        if (temp->right != NULL)
            avgQueue.push(temp->right);
    }
}

/**
 * @author 韦轩
 * @time 2015/07/12
 * @brief 实现二叉树的高度
 * @param 
 * @return 高度
 *  
 */
int getHeight(const binary_tree_node *root)
{
    if (root == NULL)
        return 0;
    return getHeight(root->left)>getHeight(root->right) ? getHeight(root->left) : getHeight(root->right) + 1;
}
/**
 * @author 韦轩
 * @time 2015/07/12
 * @brief  visit 函数
 *  
 */
int visit(const binary_tree_node* node)
{
    if (node != NULL)
    {
        printf_s("%d ", node->element);
        return node->element;
    }
}

int  main()
{
    binary_tree_node root(1);
    binary_tree_node n1(2);
    binary_tree_node n2(3);
    binary_tree_node n3(4);
    binary_tree_node n4(5);
    binary_tree_node n5(6);
    binary_tree_node n6(7);

    binary_tree_node* proot = &root;
    binary_tree_node* pn1 = &n1;
    binary_tree_node* pn2 = &n2;
    binary_tree_node* pn3 = &n3;
    binary_tree_node* pn4 = &n4;
    binary_tree_node* pn5 = &n5;
    binary_tree_node* pn6 = &n6;

    proot->left = pn1;
    proot->right = pn2;

    pn1->left = pn3;
    pn1->right = pn4;

    pn2->left = pn5;
    pn2->right = pn6;

    pn3->left = NULL;
    pn3->right = NULL;

    pn4->left = NULL;
    pn4->right = NULL;

    pn5->left = NULL;
    pn5->right = NULL;

    pn6->left = NULL;
    pn6->right = NULL;


    pre_order_r(proot, visit);
    puts("\n");
    pre_order(proot, visit);
    puts("\n");
    in_order_r(proot, visit);
    puts("\n");
    in_order(proot, visit);
    puts("\n");

    post_order_r(proot, visit);
    puts("\n");

    post_order(proot, visit);
    puts("\n");

    level_order(proot,visit);
    puts("\n");

    int h = getHeight(proot);

    return 0;
}

二叉树的特点

三种遍历算法中，基本的结点都只访问一次，时间复杂度是O(n)，同时，空间复杂度也是O(n)
层次遍历的时间复杂度和二叉树的平衡有关，极端情况下，时间复杂度是O(N^2),平衡二叉树的时间复杂度是O(n)