二叉排序树的建立

二叉排序树

       二叉排序树(Binary Sort Tree)又称二叉查找树(Binary Search Tree),亦称二叉搜索树。

性质

二叉排序树或者是一棵空树,是具有下列性质的二叉树:
(1)若左子树不空,则左子树上所有结点的值均小于它的根结点的值;
(2)若右子树不空,则右子树上所有结点的值均大于它的根结点的值;
(3)左、右子树也分别为二叉排序树;
(4)没有键值相等的节点。

可以看出,二叉查找树是一个递归的数据结构,且对二叉查找树进行中序遍历,可以得到一个递增的有序序列。

首先,我们来定义一下 BST 的结点结构体:

//树的定义
typedef struct TreeNode
{
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

插入

//二叉排序树的插入【递归】
int BST_insert(struct TreeNode *p,int k)
{
    //二叉树中插入一个关键字为k的结点
    if(p == NULL)
    {
        p = (struct TreeNode*)malloc(sizeof(struct TreeNode));
        p ->val = k;
        p ->left = p ->right = NULL;
        return 1;  //返回1表示成功
    }
    //树中存在相同的结点
    else if(k == p ->val)
        return 0;
    //插入到左子树中
    else if(k < p ->val)
        return BST_insert(p ->left,k);
    //插入到右子树中
    else
        return BST_insert(p ->right ,k);
}

注意,插入的新结点一定是某个叶结点。另外,插入操作既可以递归实现,也可以使用非递归(迭代)实现。通常来说非递归的效率会更高。 

/**
 * 非递归插入:将关键字k插入到二叉查找树
 */
int BST_Insert_NonRecur(BSTree &T, int k)
{
    Node* pre = NULL;  // 记录上一个结点
    Node* t = T;
    while(t != NULL)
    {
        pre = t;
        if(k < t->key)
            t = t->left;
        else if(k > t->key)
            t = t->right;
        else
            return 0;
    }
 
    Node* node = (Node*)malloc(sizeof(Node));
    node->key = k;
    node->left = NULL;
    node->right = NULL;
    node->parent = pre;
 
    if(pre == NULL)
        T = node;
    else
    {
        if(k < pre->key)
            pre->left = node;
        else
            pre->right = node;
    }
    return 1;
}

创建  

//二叉树的构建
void BST_create(struct TreeNode *T,int *str,int n)
{
    //用关键字数组建立一个二叉排序树
    T = NULL; //初始时为空树
    int i = 0;
    //依次将每个元素插入
    while(i < n)
    {
        BST_insert(T,str[i]);
        i++;
    }
}

遍历  

//【前序遍历】
void preorder(struct TreeNode *T)
{
    if(T != NULL)
    {
        printf("%d\t",T ->val); //打印根结点
        inorder(T ->left);  //递归遍历左子树
        inorder(T ->right); //递归遍历右子树
    }
}
//【后序遍历】
void inorder(struct TreeNode *T)
{
    if(T != NULL)
    {
        inorder(T ->left);  //递归遍历左子树
        inorder(T ->right); //递归遍历右子树
        printf("%d\t",T ->val); //打印根结点
    }
}
//【中序遍历】
void postorder(struct TreeNode *T)
{
    if(T != NULL)
    {
        inorder(T ->left);  //递归遍历左子树
        printf("%d\t",T ->val); //打印根结点
        inorder(T ->right); //递归遍历右子树
    }
}

完整代码

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

//树的定义
typedef struct TreeNode
{
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};
struct TreeNode *T;
//二叉排序树的插入
int BST_insert(struct TreeNode *p,int k)
{
    //二叉树中插入一个关键字为k的结点
    if(p == NULL)
    {
        p = (struct TreeNode*)malloc(sizeof(struct TreeNode));
        p ->val = k;
        p ->left = p ->right = NULL;
        return 1;  //返回1表示成功
    }
    //树中存在相同的结点
    else if(k == p->val)
        return 0;
    //插入到左子树中
    else if(k < p ->val)
        return BST_insert(p ->left,k);
    //插入到右子树中
    else
        return BST_insert(p ->right ,k);
}
//二叉树的构建
void BST_create(struct TreeNode *T,int *str,int n)
{
    //用关键字数组建立一个二叉排序树
	T = NULL;//初始时为空树
    int i;
    //依次将每个元素插入
    for(i = 0;i < n;i++)
    {
        BST_insert(T,str[i]);
    }
}
//【前序遍历】
void preorder(struct TreeNode *T)
{
    if(T != NULL)
    {
        printf("%d\t",T ->val); //打印根结点
        inorder(T ->left);  //递归遍历左子树
        inorder(T ->right); //递归遍历右子树
    }
}
//【中序遍历】
void inorder(struct TreeNode *T)
{
    if(T != NULL)
    {
        inorder(T ->left);  //递归遍历左子树
        inorder(T ->right); //递归遍历右子树
        printf("%d\t",T ->val); //打印根结点
    }
}
//【后序遍历】
void postorder(struct TreeNode *T)
{
    if(T != NULL)
    {
        inorder(T ->left);  //递归遍历左子树
        printf("%d\t",T ->val); //打印根结点
        inorder(T ->right); //递归遍历右子树
    }
}
int main()
{
    int length,str[] = {3,1,4,NULL,2};
    struct TreeNode *root;
    length = sizeof(str) / sizeof(str[0]);
    BST_create(root,str,length);
    printf("前序遍历:");
    preorder(root);
    printf("\n中序遍历:");
    inorder(root);
    printf("\n后序遍历:");
    postorder(root);
    return 0;
}

问题

BST_insert(T,str[i]);每次调用时,传进去的 T 为什么都是 NULL ?

该问题是:传值出现问题,待有缘人解决!


下面给出新的思路:

以下程序均在VS下调试!

这位大哥在创建二叉树时居然是一个节点一个节点写入的,真的强![2]

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef struct node
{
    int nValue;
    struct node* pLeft;
    struct node* pRight;
}BiTree;

BiTree* CreateBiTree(void)
{
    BiTree* pRoot = NULL;

    //根
    pRoot = (BiTree*)malloc(sizeof(BiTree));
    if (NULL == pRoot)
    {
        printf("pRoot空间分配失败!\n");
        exit(-1);
    }
    pRoot->nValue = 1;
    pRoot->pLeft = NULL;
    pRoot->pRight = NULL;

    //根的左
    pRoot->pLeft = (BiTree*)malloc(sizeof(BiTree));
    if (NULL == pRoot->pLeft)
    {
        printf("pRoot->pLeft空间分配失败!\n");
        exit(-1);
    }
    pRoot->pLeft->nValue = 2;
    pRoot->pLeft->pLeft = NULL;
    pRoot->pLeft->pRight = NULL;

    //根的右
    pRoot->pRight = (BiTree*)malloc(sizeof(BiTree));
    if (NULL == pRoot->pRight)
    {
        printf("pRoot->pRight空间分配失败!\n");
        exit(-1);
    }
    pRoot->pRight->nValue = 3;
    pRoot->pRight->pLeft = NULL;
    pRoot->pRight->pRight = NULL;

    //左的左
    pRoot->pLeft->pLeft = (BiTree*)malloc(sizeof(BiTree));
    if (NULL == pRoot->pLeft->pLeft)
    {
        printf("pRoot->pLeft->pLeft空间分配失败!\n");
        exit(-1);
    }
    pRoot->pLeft->pLeft->nValue = 4;
    pRoot->pLeft->pLeft->pLeft = NULL;
    pRoot->pLeft->pLeft->pRight = NULL;

    //左的右
    pRoot->pLeft->pRight = (BiTree*)malloc(sizeof(BiTree));
    if (NULL == pRoot->pLeft->pRight)
    {
        printf("pRoot->pLeft->pRight空间分配失败!\n");
        exit(-1);
    }
    pRoot->pLeft->pRight->nValue = 5;
    pRoot->pLeft->pRight->pLeft = NULL;
    pRoot->pLeft->pRight->pRight = NULL;

    //右的左
    pRoot->pRight->pLeft = (BiTree*)malloc(sizeof(BiTree));
    if (NULL == pRoot->pRight->pLeft)
    {
        printf("pRoot->pRight->pLeft空间分配失败!\n");
        exit(-1);
    }
    pRoot->pRight->pLeft->nValue = 6;
    pRoot->pRight->pLeft->pLeft = NULL;
    pRoot->pRight->pLeft->pRight = NULL;

    return pRoot;
}

//递归创建二叉树
void RecCreateBiTree(BiTree** ppRoot)
{
    int nNum;

    assert(ppRoot != NULL);

    //输入节点的值
    scanf("%d", &nNum);

    //检测是否是结束标志
    if (0 == nNum)
    {
        return;
    }

    *ppRoot = (BiTree*)malloc(sizeof(BiTree));
    if (NULL == *ppRoot)
    {
        printf("*ppRoot空间分配失败!");
        exit(-1);
    }
    (*ppRoot)->nValue = nNum;
    (*ppRoot)->pLeft = NULL;
    (*ppRoot)->pRight = NULL;

    //处理当前节点的左和右
    RecCreateBiTree(&(*ppRoot)->pLeft);
    RecCreateBiTree(&(*ppRoot)->pRight);
}

//前序遍历
void PreOrderTraversal(BiTree* pRoot)
{
    if (NULL == pRoot)
    {
        return;
    }

    printf("%d ", pRoot->nValue);
    PreOrderTraversal(pRoot->pLeft);
    PreOrderTraversal(pRoot->pRight);
}

//中序遍历
void MidOrderTraversal(BiTree* pRoot)
{
    if (NULL == pRoot)
    {
        return;
    }

    MidOrderTraversal(pRoot->pLeft);
    printf("%d ", pRoot->nValue);
    MidOrderTraversal(pRoot->pRight);
}

//后序遍历
void LastOrderTraversal(BiTree* pRoot)
{
    if (NULL == pRoot)
    {
        return;
    }

    LastOrderTraversal(pRoot->pLeft);
    LastOrderTraversal(pRoot->pRight);
    printf("%d ", pRoot->nValue);
}

int main(void)
{
    printf("新建二叉树:");
    BiTree* pRoot = CreateBiTree();
    printf("前序遍历:");
    PreOrderTraversal(pRoot);
    printf("\n");
    printf("中序遍历:");
    MidOrderTraversal(pRoot);
    printf("\n");
    printf("后序遍历:");
    LastOrderTraversal(pRoot);

    system("pause");
    return 0;
}

下面的这个参考知乎一位老哥[1],稍微修改一下:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

struct Node
{
	int data;
	struct Node* pleft;
	struct Node* pright;
}Node;

//参数声明
struct Node* createnode(int value);
struct Node* addnode(int value, struct Node* pnode);
void ppreorder(struct TreeNode* T);
void pinorder(struct TreeNode* T);
void ppostorder(struct TreeNode* T);
void listnodes(struct Node* pnode);
int Treeheight(struct Node* pnode);

struct Node* createnode(int value)
{
	struct Node* pnode = (struct Node*)malloc(sizeof(struct Node));
	pnode->data = value;
	pnode->pleft = pnode->pright = NULL;
	return pnode;
}

struct Node* addnode(int value, struct Node* pnode)
{
	if (pnode == NULL)
		return createnode(value);

	if (value == pnode->data)
	{
		return pnode;
	}

	if (value < pnode->data)
	{
		if (pnode->pleft == NULL)
		{
			pnode->pleft = createnode(value);
			return pnode->pleft;
		}
		else
		{
			return addnode(value, pnode->pleft);
		}
	}
	else
	{
		if (pnode->pright == NULL)
		{
			pnode->pright = createnode(value);
			return pnode->pright;
		}
		else
		{
			return addnode(value, pnode->pright);
		}

	}
}

//【前序遍历】
void ppreorder(struct Node* pnode)
{
	if (pnode != NULL)
	{
		printf("%d\t", pnode->data); //打印根结点
		pinorder(pnode->pleft);  //递归遍历左子树
		pinorder(pnode->pright); //递归遍历右子树
	}
}
//【中序遍历】
void pinorder(struct Node* pnode)
{
	if (pnode != NULL)
	{
		pinorder(pnode->pleft);  //递归遍历左子树
		pinorder(pnode->pright); //递归遍历右子树
		printf("%d\t", pnode->data); //打印根结点
	}
}
//【后序遍历】
void ppostorder(struct Node* pnode)
{
	if (pnode != NULL)
	{
		pinorder(pnode->pleft);  //递归遍历左子树
		printf("%d\t", pnode->data); //打印根结点
		pinorder(pnode->pright); //递归遍历右子树
	}
}

void listnodes(struct Node* pnode)
{
	if (pnode != NULL)
	{
		listnodes(pnode->pleft);
		printf("%d\n", pnode->data);
		listnodes(pnode->pright);
	}
}

int Treeheight(struct Node* pnode)
{
	int LD, RD;
	if (pnode == NULL)
	{
		return 0;
	}
	else
	{
		LD = Treeheight(pnode->pleft);
		RD = Treeheight(pnode->pright);
		return (LD >= RD ? LD : RD) + 1;
	}
}

int main(void)
{
	int i;
	struct Node* proot = NULL;
	int length, str[] = { 3,1,4,NULL,2 };
	length = sizeof(str) / sizeof(str[0]);

	for (i = 0; i < length; i++)
	{
		if (proot == NULL)
		{
			proot = createnode(str[i]);
		}
		else
		{
			addnode(str[i], proot);
		}
	}
	printf("新建二叉树:");
	listnodes(proot);
	printf("\nThe height of tree is %d!", Treeheight(proot));
	printf("\n前序遍历:");
	ppreorder(proot);
	printf("\n中序遍历:");
	pinorder(proot);
	printf("\n后序遍历:");
	ppostorder(proot);
	return 0;
}

参考

1、二叉树的建立与遍历(C语言实现)

2、创建二叉树

posted @ 2020-04-12 14:48  PamShao  阅读(3642)  评论(5编辑  收藏  举报