(二叉树)谈一谈各类算法和数据结构的c++实现以及相关操作的复杂度（二）

接着上一篇， 上一篇主要说了各种排序算法， 但对几个常用的数据结构还未提及，所以这一篇主要讲二叉树, 二叉树已经包括很多链表的知识了。所有代码都是测试过的, 可以直接撸.

二叉树

这里不举太多数字方面的东西， 我们直接看图， 直观感性的认识满二叉树和完全二叉树：

有一点性质需要牢记：具有n个结点的完全二叉树的最大高度为log2n+1

二叉树的二叉链式存储方案的代码表示：

typedef struct BinaryTreeNode
{
    int data;
    BinaryTreeNode *LeftChild, *RightChild;
    // BTN *LeftChild, *RightChild; // error : BTN doesn't name a typecat
}BTN, *BTN_Ptr;

创建

int create_BT(BTN_Ptr *btp)
{
    int temp_data = 0;
    std::cin >> temp_data;
    if (temp_data == 0)
    {
        *btp = NULL;
        printf("leaf\n");
    }
    else
    {
        if ( !(*btp = (BTN_Ptr)malloc( sizeof(BTN) ) ) ) 
        {
            printf("error : malloc error");
            return -1;
        }
        (*btp)->data = temp_data;
        create_BT(&((*btp)->LeftChild));
        create_BT(&((*btp)->RightChild));
    } 
    return 0;
}

遍历

如上图得到的相应的遍历的序列分别为：

• 先序遍历 ： ABCDEGF
• 中序遍历 ： CBEGDFA
• 后序遍历 ： CGEFDBA

递归遍历

void pre_order_traverse(const BTN_Ptr *btp)
{
    if ( *btp != NULL)
    {
        cout << (*btp)->data << endl;
        pre_order_traverse( &(*btp)->LeftChild );
        pre_order_traverse( &(*btp)->RightChild );
    }
}

void in_order_traverse(const BTN_Ptr *btp)
{
    if ( *btp != NULL)
    {
        in_order_traverse( &(*btp)->LeftChild );
        cout << (*btp)->data << endl;
        in_order_traverse( &(*btp)->RightChild );
    }
}

void post_order_traverse(const BTN_Ptr *btp)
{
    if ( *btp != NULL)
    {
        post_order_traverse( &(*btp)->LeftChild );
        post_order_traverse( &(*btp)->RightChild );
        cout << (*btp)->data << endl;
    }
}

非递归遍历

非递归的二叉树三种遍历方式其实思想是统一的 : 都是从左到右的将各个结点依次入栈, 当左边已经走到头了, 就开始走右边, 在适当的条件就出栈, 只是每个遍历方式的出栈条件不一样而已.

先序和中序遍历都很好理解, 着重讲一下后序遍历 :
后序遍历的出栈条件有点不一样, 因为后序是先左后右再中的, 比如某个结点p要出栈, 需要遍历完了p的所有右子树之后才能出栈, 而不能第一次就出栈, 所以专门构造了一个结构体F_bt来记录他是否是第一次出栈 (F_bt结构体里有个is_first的数据来记录)

void pre_order_traverse_non_recursion(const BTN_Ptr *btp)
{
    stack<BTN_Ptr> stack_bt;
    BTN_Ptr temp_btp = *btp;
    while ( !stack_bt.empty() || temp_btp != NULL )
    {
        while ( temp_btp != NULL )
        {
            cout << temp_btp->data << endl;
            stack_bt.push(temp_btp);
            temp_btp = temp_btp->LeftChild;
        }

        if ( !stack_bt.empty() )
        {
            temp_btp = stack_bt.top()->RightChild;
            stack_bt.pop();
        }
    }
}

void in_order_traverse_non_recursion(const BTN_Ptr *btp)
{
    stack<BTN_Ptr> stack_bt;
    BTN_Ptr temp_btp = *btp;

    while ( !stack_bt.empty() || temp_btp != NULL )
    {
        while ( temp_btp != NULL )
        {
            stack_bt.push(temp_btp);
            temp_btp = temp_btp->LeftChild;
        }

        if ( !stack_bt.empty() )
        {
            cout << stack_bt.top()->data << endl;
            temp_btp = stack_bt.top()->RightChild;
            stack_bt.pop();
        }
    }
}


typedef struct
{
    BTN_Ptr btnp;
    int is_first;
}F_bt, *F_btp;

void post_order_traverse_non_recursion( const BTN_Ptr *btp)
{
    stack<F_btp> stack_F_btp;
    BTN_Ptr temp_btp = *btp;

    while ( !stack_F_btp.empty() || temp_btp != NULL )
    {
        while ( temp_btp != NULL )
        {
            F_btp temp_F_btp = new F_bt;
            temp_F_btp->btnp = temp_btp;
            temp_F_btp->is_first = 1;
            stack_F_btp.push(temp_F_btp);
            temp_btp = temp_btp->LeftChild;
        }

        if ( !stack_F_btp.empty() )
        {
            if ( stack_F_btp.top()->is_first == 1 )
            {
                stack_F_btp.top()->is_first = 0;
                temp_btp = stack_F_btp.top()->btnp->RightChild;
            }
            else
            {
                cout << stack_F_btp.top()->btnp->data << endl;
                delete stack_F_btp.top();
                stack_F_btp.top() = NULL;
                stack_F_btp.pop();
                temp_btp = NULL;
            }
        }

    }
}

二叉搜索树(又称二叉查找树或二叉排序树)

有了上面二叉树的基础, 我们继续学习二叉搜索树.
我们这里也不给他那种晦涩难懂的定义, 感性的认识二叉搜索树.
直接看图, 很容易看得出来, 二叉搜索树每个结点的左孩子都小于右孩子.

因为具有n个结点的完全二叉树的最大高度为log2n+1
而二叉搜索树的查询/增加的时间复杂度都是O(h), h为树的高度,所以复杂度可以看作O(logn), 所以很明显上图中的a树比b树要高效.

查询

BTN_Ptr search(BTN_Ptr btp, int key)
{
    while (btp != NULL )
    {
        if ( btp->data != key)
        {
            if ( btp->data < key )
                btp = btp->RightChild;
            else
                btp = btp->LeftChild;
        }
        else
        {
            printf("found\n");
            return btp;
        }
    }
   printf("error : not found!\n");
   return NULL;
}

插入

BTN_Ptr insert(BTN_Ptr &btp, int key)
{
    if (btp == NULL)
    {
        btp = new BTN;
        btp->data = key;
        btp->LeftChild = NULL;
        btp->RightChild = NULL;
        return btp;
    }
    else
    {
        BTN_Ptr saved_btp = btp;
        BTN_Ptr temp_btp = NULL;
        while ( btp != NULL)
        {
            temp_btp = btp;
            if ( key < btp->data )
                btp = btp->LeftChild;
            else
                btp = btp->RightChild;
        }
        btp = new BTN;
        btp->data = key;
        btp->LeftChild = NULL;
        btp->RightChild = NULL;
        if ( key < temp_btp->data )
            temp_btp->LeftChild = btp;
        else
            temp_btp->RightChild = btp;
        return saved_btp;
    }
}

测试程序

附上一个测试程序吧

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <stack>

using std::stack;
using std::cout;
using std::cin;
using std::endl;

int main(int argc, char **argv)
{
    BTN_Ptr my_btp = NULL;
    if (create_BT(&my_btp) == -1)
        return -1;
    cout << "==============pre_order:==============" << endl;
    pre_order_traverse(&my_btp);
    cout << "==============in_order:==============" << endl;
    in_order_traverse(&my_btp);
    cout << "==============post_order:==============" << endl;
    post_order_traverse(&my_btp);
    cout << "==============search : 24==============" << endl;
    search(my_btp, 24);
    cout << "==============search : 14==============" << endl;
    search(my_btp, 14);
    cout << "==============insert : 25==============" << endl;
    my_btp = insert(my_btp, 25);
    cout << "==============pre_order2:==============" << endl;
    pre_order_traverse(&my_btp);
    return 0;
}