二叉树学习笔记

最新推荐文章于 2022-03-08 14:04:38 发布

WULI_LIN

最新推荐文章于 2022-03-08 14:04:38 发布

阅读量330

点赞数

分类专栏：算法与设计模式文章标签：二叉树数据结构

本文链接：https://blog.youkuaiyun.com/WULI_LIN/article/details/110250688

版权

算法与设计模式专栏收录该内容

9 篇文章

订阅专栏

二叉树

插入

插入值 < 结点值，插入结点的左子树
插入值 > 结点值，插入结点的又子树
不插入相同的值

遍历

1 前序遍历

根结点 -> 左子树 -> 右子树

2 中序遍历

左子树 -> 根结点 -> 右子树

3 后序遍历

左子树 -> 右子树 -> 根结点

删除结点

1 删除的结点没有左右子树

直接删除该结点

      if (del_node->entry.left == NULL && del_node->entry.right == NULL)

      {

            printf("%d\n", parent_node->value);

            if (del_node->value < parent_node->value)

            {

                  parent_node->entry.left = NULL;

            }

            else

            {

                  parent_node->entry.right = NULL;

            }

      }

2 删除的结点只有左子树或右子树

父结点指向删除结点的左子树或右子树

      else if (del_node->entry.left != NULL && del_node->entry.right == 
NULL)

      {

            if (del_node->value < parent_node->value)

            {

                  parent_node->entry.left = del_node->entry.left;

            }

            else

            {

                  parent_node->entry.left = del_node->entry.right;

            }

      }

      else if (del_node->entry.left == NULL && del_node->entry.right != 
NULL)

      {

            if (del_node->value < parent_node->value)

            {

                  parent_node->entry.left = del_node->entry.right;

            }

            else

            {

                  parent_node->entry.right = del_node->entry.right;

            }

      }

3 删除的结点有左右子树

在这里用删除结点的左子树的最右结点（称作后续结点）来代替删除结点的位置（也可是右子树的最左结点作为后续结点，同理）

1）后续结点为删除结点的子叶

将删除结点的父结点指向后续结点, 然后后续结点的右子树指向删除结点的右子树

2）后续结点非删除结点的子叶

后续结点的值赋值给删除的结点, 后续结点的父结点的右子树指向后续结点的左子树, 删除后续结点

// 1)和2）
else if (del_node->entry.left != NULL && del_node->entry.right != NULL) // 2)

      {

            stBtreeNode *parent = del_node->entry.left;

            stBtreeNode *node = parent->entry.right;



            if (node != NULL)

            {

                  while (node != NULL)

                  {



                        if (node->entry.right != NULL)

                        {

                              parent = node;

                              node = node->entry.right;

                        }

                        else

                        {

                              break;

                        }

                  }

                  del_node->value = node->value;

                  parent->entry.right = node->entry.left;



                  free(node);

                  node = NULL;

            }

            else //2)

            {

                  if (del_node->value < parent_node->value)

                  {

                        parent_node->entry.left = parent;

                  }

                  else

                  {

                        parent_node->entry.right = parent;

                  }

                  parent->entry.right = del_node->entry.right;

            }

      }

在这里插入图片描述

全部代码

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

#define KEY_VALUE int
#define NODE_ENTRY(name, type)			\
	struct name {					\
		struct type *left;			\
		struct type *right;			\
	}

typedef enum {
	EN_PREORDER,
	EN_INORDER,
	EN_POSTORDER,
} TRAVER_TYPE;

typedef struct {
	struct btree_node *left;
	struct btree_node *right;
} stNodeEntry;

typedef struct btree_node {
	KEY_VALUE value;
//	NODE_ENTRY(,btree_node) entry;
	stNodeEntry entry;
} stBtreeNode;

typedef struct btree {
	stBtreeNode *root;
} stBtree;

int btree_destroy_node(stBtreeNode *parent_node, stBtreeNode *del_node)
{
	printf("%d, %d\n", parent_node->value, del_node->value);
	if (del_node == NULL)
	{
		return -1;
	}

	if (del_node->entry.left == NULL && del_node->entry.right == NULL)
	{
		printf("%d\n", parent_node->value);
		if (del_node->value < parent_node->value)
		{
			parent_node->entry.left = NULL;
		}
		else
		{
			parent_node->entry.right = NULL;
		}
	}
	else if (del_node->entry.left != NULL && del_node->entry.right == NULL)
	{
		if (del_node->value < parent_node->value)
		{
			parent_node->entry.left = del_node->entry.left;
		}
		else
		{
			parent_node->entry.left = del_node->entry.right;
		}
	}
	else if (del_node->entry.left == NULL && del_node->entry.right != NULL)
	{
		if (del_node->value < parent_node->value)
		{
			parent_node->entry.left = del_node->entry.right;
		}
		else
		{
			parent_node->entry.right = del_node->entry.right;
		}
	}
	else if (del_node->entry.left != NULL && del_node->entry.right != NULL)
	{
		stBtreeNode *parent = del_node->entry.left;
		stBtreeNode *node = parent->entry.right;

		if (node != NULL)
		{
			while (node != NULL)
			{

				if (node->entry.right != NULL)
				{
					parent = node;
					node = node->entry.right;
				}
				else
				{
					break;
				}
			}

			del_node->value = node->value;
			parent->entry.right = node->entry.left;

			free(node);
			node = NULL;
		}
		else
		{
			if (del_node->value < parent_node->value)
			{
				parent_node->entry.left = parent;
			}
			else
			{
				parent_node->entry.right = parent;
			}
			parent->entry.right = del_node->entry.right;
		}
	}

	if (parent_node != del_node)
	{
		free(del_node);
		del_node = NULL;
	}

	return 0;
}

stBtreeNode *btree_create_node(KEY_VALUE value)
{
	stBtreeNode *node;

	node = (stBtreeNode *)malloc(sizeof(stBtreeNode));
	assert(node != NULL);

	node->value = value;
	node->entry.left = NULL;
	node->entry.right = NULL;

	return node;
}

int btree_insert_node(stBtree *tree, KEY_VALUE value)
{
	assert(tree != NULL);

	if (tree->root == NULL)
	{
		tree->root = btree_create_node(value);
		return 0;
	}

	stBtreeNode *node;
	stBtreeNode *temp;
	node = tree->root;

	while (node != NULL)
	{
		temp = node;
		if (value < node->value)
		{
			node = node->entry.left;
		}
		else
		{
			node = node->entry.right;
		}
	}

	if (value < temp->value)
	{
		temp->entry.left = btree_create_node(value);
	}
	else
	{
		temp->entry.right = btree_create_node(value);
	}

	return 0;
}

int btree_del_value(stBtree *tree, KEY_VALUE value)
{
	assert(tree != NULL);

	int ret = -1;
	stBtreeNode *parent, *node;

	parent = tree->root;
	node = tree->root;

	while (node != NULL)
	{
		if (value == node->value)
		{
			ret = btree_destroy_node(parent, node);

			break;
		}
		else if (value < node->value)
		{
			parent = node;
			node = node->entry.left;
		}
		else
		{
			parent = node;
			node = node->entry.right;
		}
	}

	return ret;
}


int btree_traversal(stBtreeNode *node, TRAVER_TYPE type)
{
	if (node == NULL)
	{
		return 0;
	}

	if (EN_PREORDER == type) printf("%4d", node->value);

	btree_traversal(node->entry.left, type);

	if (EN_INORDER == type) printf("%4d", node->value);
	btree_traversal(node->entry.right, type);

	if (EN_POSTORDER == type) printf("%4d", node->value);

	return 0;
}

int main(void)
{
	int i;
//	int array[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
	int array[] = {11,7,13,6,8,9,10,12,14};
	int len = 8;
	stBtree btree = {0};

	for (i = 0; i < len; i++)
	{
		btree_insert_node(&btree, array[i]);
	}

	btree_traversal(btree.root, EN_PREORDER);
	printf("\n");

	printf("del: %s\n", btree_del_value(&btree, 11) == 0 ?  "succeed":"failed");

	btree_traversal(btree.root, EN_PREORDER);
	printf("\n");

	return 0;
}