C++简单实现二叉排序树

#ifndef _TOU_H_
#define _TOU_H_
#include <iostream>
using namespace std;
#include <cstdlib>

typedef
struct{
    int key;
}DataType;

typedef
struct node{
    DataType data;
    struct node *leftchild;
    struct node *rightchild;
}BiTreeNode;

int search(BiTreeNode* root, DataType item)//查找算法
{
    BiTreeNode * p;
    if (root != NULL)
    {
        p = root;
        while (p != NULL)
        {
            if (p->data.key == item.key)return 1;//查找成功
            if (item.key > p->data.key)p = p->rightchild;
            else p = p->leftchild;
        }
    }
    return 0;//查找失败
}

int insert(BiTreeNode**root, DataType item)//插入算法
{
    BiTreeNode* current = *root;
    BiTreeNode* parent = NULL;
    while (current != NULL)
    {
        if (current->data.key == item.key)return 0;//数据元素已经存在
        parent = current;
        if (current->data.key < item.key)current = current->rightchild;
        else current = current->leftchild;
    }
    BiTreeNode* p;
    p = (BiTreeNode*)malloc(sizeof(BiTreeNode));
    if (p == NULL)
    {
        cout << "空间不够" << endl;
        exit(1);
    }

    //生成新的节点
    p->data = item;
    p->leftchild = NULL;
    p->rightchild = NULL;

    if (parent == NULL)
    {
        *root = p;//新的节点称为根节点
    }
    else if (item.key < parent->data.key){
        parent->leftchild = p;//新节点为该节点的左孩子节点
    }
    else
        parent->rightchild = p;//新节点为该节点的右孩子节点
    return 1;
}

void intraverse(BiTreeNode* root)//中序遍历显示二叉排序树节点信息函数
{
    if (root == NULL)
    {
        return;
    }
    if (root->leftchild!= NULL)
    {
        intraverse(root->leftchild);
    }
    cout << " " << root->data.key;
    if (root->rightchild != NULL)
    {
        intraverse(root->rightchild);
    }
}
#endif

#include "tou.h"
#include <iostream>
using namespace std;

void main()
{
    DataType test[] = { 4, 5, 7, 2, 1, 9, 8, 11, 3 }, x = { 9 };
    int n = 9;
    BiTreeNode *root = NULL;
    for (int i = 0; i < n; i++)
    {
        insert(&root, test[i]);
    }
    intraverse(root);//调用中序遍历

    int s = search(root, x);//调用查找函数
    if (s == 1)
    {
        cout << "数据元素" << x.key << "存在!" << endl;
    }
    else
    {
        cout << "数据元素" << x.key << "不存在!" << endl;
    }
    system("pause");
    return ;
}

注意：遍历二叉树的方法是中序遍历！好吧，我们再来说说二叉树的三种遍历方式：

1、前序遍历：（1）访问根节点（2）按照前序遍历左子树（3）按照先序遍历右子树

void proorder（bitree root）//先序遍历
{
     if(root)
{
      visit(root->data);//访问根节点
      proorder(root->lchild);//先序遍历左子树
      proorder(root->rchild);//先序遍历右子树
}  
}

2、中序遍历：（1）按照中序遍历左子树（2）访问根节点（3）按照中序遍历右子树

void inorder（bitree root）//先序遍历
{
     if(root)
{
      inorder(root->lchild);//先序遍历左子树
      visit(root->data);//访问根节点
      inorder(root->rchild);//先序遍历右子树
}  
}

　　

3、后序遍历：（1）按照后序遍历左子树（2）按照后序遍历右子树（3）访问根节点

void postorder（bitree root）//先序遍历
{
     if(root)
{
      postorder(root->lchild);//先序遍历左子树
      postorder(root->rchild);//先序遍历右子树
      visit(root->data);//访问根节点
}  
}

　　上述算法语句简单，结构清晰，非常便于形式上的掌握。注意的是，递归遍历时一定要按约定的次序访问每一个局部变量的子树。形式上，三种遍历算法的区别仅表现在visit函数的位置不同，但由于对子树的遍历是递归是递归调用，所以三种遍历的结果差别是很大的。

　　递归算法的时间复杂度：对于有n个节点的二叉树，设访问每个节点的时间是常量级的，则上述二叉树递归遍历的三个算法的时间复杂度是O（n）,其中，对每个节点都要经过递归调用，和递归退出的控制处理过程。