数据结构——搜索二叉树

本篇实现了搜索二叉树的有序创建、查找、查找最大最小节点 以及求父节点

bst.h

#include "bst.h"
typedef struct _TreeNode
{
    int  data;
    struct _TreeNode *left;
    struct _TreeNode *right;
}TreeNode;

void initTree(TreeNode **t);
void insertTreeNode(TreeNode **t, int data);
void insertTreeNodecycle(TreeNode **t,int data);
TreeNode * searchBSTcycle(TreeNode *t,int data);
TreeNode * searchBSTrecursive(TreeNode *t,int data);
TreeNode *minTreeNode(TreeNode *t);
TreeNode *maxTreeNode(TreeNode *t);
TreeNode *getparentTreeNode(TreeNode *t,TreeNode *fNode);
void midorderTraverseTree(TreeNode *t);

bst.c

创建和查找分别用递归和循环实现。

父节点的查找，一可以用递归（静态指针存放parent，注意return的位置，详见代码）

                        二是可用队存储二叉树的层序遍历，当遍历到该节点时return。

#include "bst.h"
#include <stdlib.h>
#include <stdio.h>

//初始化一个空树
void initTree(TreeNode **t)
{
    (*t) = NULL;
}

//有序插入  递归实现
void insertTreeNode(TreeNode **t, int data)
{
    if((*t) == NULL)
    {
        (*t) = (TreeNode *)malloc(sizeof(TreeNode));
        (*t)->data = data;
        (*t)->left = (*t)->right = NULL;
    }
    else if(data > (*t)->data)
    {
        insertTreeNode(&((*t)->right),data);
    }
    else
        insertTreeNode(&((*t)->left),data);
}

//有序插入 迭代实现
void insertTreeNodecycle(TreeNode **t,int data)
{
    TreeNode *mt = *t;
    TreeNode *temp;

    //应对一开始的根节点
    if((*t) == NULL)
    {
        (*t) = (TreeNode *)malloc(sizeof(TreeNode));
        (*t)->data = data;
        (*t)->left = (*t)->right = NULL;
    }
    //后续节点
    else
    {
        while(1)
        {
            if(data > mt->data)
            {
                //错误点：mt没有移动 此时mt还是指向root结点 对root操作的
                //                if(mt->right == NULL)
                //                {
                //                    mt = (TreeNode *)malloc(sizeof(TreeNode*));
                //                    mt->data = data;
                //                    mt->left = mt->right = NULL;
                //                    break;

                if(mt->right == NULL)
                {
                    //                    temp = mt->right; 顺序  ！！先为temp开创空间之后再把结点拷贝过去，连接起来
                    temp = (TreeNode *)malloc(sizeof(TreeNode));
                    temp->data = data;
                    temp->left = temp->right = NULL;
                    mt->right = temp;
                    break;
                }
                else
                    mt = mt->right;
            }
            else
            {
                if(mt->left == NULL)
                {
                    temp = (TreeNode *)malloc(sizeof(TreeNode));
                    temp->data = data;
                    temp->left = temp->right = NULL;
                    mt->left = temp;
                    break;
                }
                else
                    mt = mt->left;
            }
        }
    }
}

//搜索 循环实现
TreeNode * searchBSTcycle(TreeNode *t,int data)
{
    while(t)
    {
        if(data == t->data)
            return t;
        else if(data > t->data)
            t = t->right;
        else if(data < t->data)
            t = t ->left;
    }
    return NULL;
}

//搜索 递归实现
TreeNode * searchBSTrecursive(TreeNode *t,int data)
{
    if(!t)
        return NULL;
    if(data == t->data)
        return t;
    else if(data > t->data)
//        searchBSTrecursive(t->right,data);    //****查到直接return了****
        return searchBSTrecursive(t->right,data);
    else if(data < t->data)
//        searchBSTrecursive(t->left,data);
        return searchBSTrecursive(t->left,data);
}

//寻找BST最小节点
TreeNode *minTreeNode(TreeNode *t)
{
    if(!t)
        return NULL;
    else
    {
       while(t->left) t = t->left;
       return t;
    }
}

//寻找BST最大节点
TreeNode *maxTreeNode(TreeNode *t)
{
    if(!t)
        return NULL;
    else
    {
       while(t->right) t = t->right;
       return t;
    }
}

//求当前结点的父节点
//递归的奥妙。相当于开启了多 层 函数模块，一层的return只是返回到上一层。而不是整体的递归。
TreeNode *getparentTreeNode(TreeNode *t,TreeNode *fNode)
{
    static TreeNode *parent = NULL; //静态变量 保存parent指针
    if(t)
    {
        if(t->left == fNode || t->right == fNode)
        {
            parent = t;
        }
        getparentTreeNode(t->left,fNode);
        getparentTreeNode(t->right,fNode);
    }
    return parent;
}

//中序打印输出  (正序)
void midorderTraverseTree(TreeNode *t)
{
    if(t != NULL)
    {
        midorderTraverseTree(t->left);
        printf("%-4d",t->data);
        midorderTraverseTree(t->right);
    }
}

对代码逻辑不清晰的建议模拟一个树跟着逻辑画一画。  有问题欢迎来撩~ 。