7.二叉树各种基本算法的实现

内容:编写一个程序实现二叉树的基本运算,完成如下功能:
(1)由如图7.1所示的二叉树创建对应的二叉链存储结构b,该二叉树的括号表示串为“A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”。
(2)输出二叉树b。
(3)输出‘H'结点的左、右孩子结点值。
(4)输出二叉树6的高度。
(5)释放二叉树b。

值得注意的是二叉树的创建相比之前难度要大,这里给出详细解释:

1. BTnode* st[max]  定义了一个指针数组st,用于存储二叉树节点的指针。
2. *p  定义了一个指向BTnode类型的指针p,用于指向当前处理的节点。
3. int top = -1 定义了一个整型变量top,用于表示栈顶位置,初始值为-1。
4. int k 定义了一个整型变量k,用于表示当前处理的节点是左子树还是右子树。
5. char ch 定义了一个字符变量ch,用于存储当前处理的字符。

这些变量和数组在createBTree函数中用于创建二叉树,通过栈的方式实现了二叉树的创建过程。

代码如下:

#include<stdio.h>
#include<stdlib.h>
#define max 100
typedef char elemtype;
typedef struct node
{
	elemtype data;
	struct node* lchild;
	struct node* rchild;
}BTnode;                    //声明二叉链节点类型

void createBTree(BTnode*& b, const char* str)  //创建二叉树
{
	BTnode* st[max], * p;
	p = NULL;
	int top = -1, k;
	char ch;
	b = NULL;                  //建立二叉树初始时为空
	ch = str[0];
	int j = 0;
	while (ch != '\0')              //\0为转义字符,意思是空字符,(ch != '\0') 即为ch不为空的意思
	{
		switch (ch)
		{
		case'(': top++; st[top] = p; k = 1; break; //开始处理左子树
		case')': top--; break;                     //子树处理完毕
		case',': k = 2; break;                     //开始处理右子树
		default: p = (BTnode*)malloc(sizeof(BTnode));
			p->data = ch, p->lchild = p->rchild = NULL;
			if (b == NULL)
			{
				b = p;
			}
			else {
				switch (k)
				{
				case '1': st[top]->lchild = p; break;
				case '2': st[top]->rchild = p; break;
				}
			}
		}
		j++; ch = str[j];
	}
}

void destroyBTree(BTnode*& b)            //销毁二叉树(递归)
{
	if (b != NULL)
	{
		destroyBTree(b->lchild);
		destroyBTree(b->rchild);
		free(b);
	}
}

BTnode* findnode(BTnode* b, elemtype x)   //查找值为x的结点(递归)
{
	BTnode* p;
	if (b == NULL)
	{
		return NULL;
	}
	else if (b->data == x)
	{
		return b;
	}
	else
	{
		p = findnode(b->lchild, x);
		if (p != NULL)
		{
			return p;
		}
		else
			return findnode(b->rchild, x);
	}
}

BTnode* lchildnode(BTnode* p)     //返回p结点的左孩子结点指针
{
	return p->lchild;
}

BTnode* rchildnode(BTnode* p)
{
	return p->rchild;
}

int BTheight(BTnode * b)  //求二叉树b的高度
{
	int lchildh, rchildh;
	if (b == NULL)
	{
		return 0;
	}
	else
	{
		lchildh = BTheight(b->lchild);
		rchildh = BTheight(b->rchild);
		return (lchildh > rchildh) ? (lchildh + 1) : (rchildh + 1);
	}
}

void dispBTnode(BTnode * p)  //输出p结点的值
{
	if (p != NULL)
	{
		printf("%c", p->data);
	}
}

void dispBTtree(BTnode * b)    //输出二叉树b
{
	if (b != NULL)
	{
		printf("%c", b->data);
		if (b->lchild != NULL || b->rchild != NULL)
		{
			printf("(");
			dispBTtree(b->lchild);
			if (b->rchild != NULL)
			{
				printf(",");
			}
			dispBTtree(b->rchild);
			printf(")");
		}
	}
}

int main()
{
	BTnode* b;
	createBTree(b, "A(B(D,E(H(J,K(L,M(,N)))),C(F,G(,I)))");
	printf("二叉树的基本运算如下\n");
	printf("1.创建二叉树\n");
	printf("2.输出二叉树:");
	dispBTtree(b);
	printf("\n");
	BTnode* h = findnode(b, 'H');
	printf("3.H结点:");
	if (h != NULL)
	{
		BTnode* lp = lchildnode(h);
		if (lp != NULL)
		{
			printf("左孩子为%c", lp->data);
		}
		else
		{
			printf("无左孩子");
		}
		BTnode* rp = rchildnode(h);
		if (rp != NULL)
		{
			printf("右孩子为%c", rp->data);
		}
		else
		{
			printf("无右孩子");
		}
	}
	printf("\n");
	printf("4.二叉树b的高度:%d\n", BTheight(b));
	printf("5.释放二叉树b\n");
	destroyBTree(b);
	return 0;
}

运行结果如下:

  • 10
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
### 回答1: 二叉树基本操作包括插入节点、删除节点、查找节点、遍历节点等。 1. 插入节点 二叉树的插入操作可以分为两种情况: - 当树为空时,插入的节点作为根节点; - 当树不为空时,从根节点开始按照比较大小的规则找到插入位置,插入新节点。 具体实现如下: ```python class Node: def __init__(self, value): self.value = value self.left = None self.right = None class BinaryTree: def __init__(self): self.root = None def insert(self, value): if self.root is None: self.root = Node(value) else: self._insert(value, self.root) def _insert(self, value, node): if value < node.value: if node.left is None: node.left = Node(value) else: self._insert(value, node.left) else: if node.right is None: node.right = Node(value) else: self._insert(value, node.right) ``` 2. 删除节点 删除节点时需要考虑以下几种情况: - 要删除的节点是叶子节点; - 要删除的节点只有一个子节点; - 要删除的节点有两个子节点。 具体实现如下: ```python class BinaryTree: # ...省略代码... def delete(self, value): if self.root is None: return False else: if self.root.value == value: if self.root.left is None and self.root.right is None: self.root = None elif self.root.left is None: self.root = self.root.right elif self.root.right is None: self.root = self.root.left else: temp = self._get_max(self.root.left) self.root.value = temp.value self._delete(temp.value, self.root.left) else: self._delete(value, self.root) def _delete(self, value, node): if node is None: return False if value == node.value: if node.left is None and node.right is None: return None elif node.left is None: return node.right elif node.right is None: return node.left else: temp = self._get_max(node.left) node.value = temp.value node.left = self._delete(temp.value, node.left) elif value < node.value: node.left = self._delete(value, node.left) else: node.right = self._delete(value, node.right) def _get_max(self, node): if node.right is None: return node else: return self._get_max(node.right) ``` 3. 查找节点 查找节点的实现比较简单,从根节点开始按照比较大小的规则找到目标节点即可。 ```python class BinaryTree: # ...省略代码... def search(self, value): return self._search(value, self.root) def _search(self, value, node): if node is None: return False elif node.value == value: return True elif value < node.value: return self._search(value, node.left) else: return self._search(value, node.right) ``` 4. 遍历节点 二叉树的遍历分为三种方式:前序遍历、中序遍历和后序遍历。具体实现如下: ```python class BinaryTree: # ...省略代码... def pre_order(self): if self.root is not None: self._pre_order(self.root) def _pre_order(self, node): if node is not None: print(node.value) self._pre_order(node.left) self._pre_order(node.right) def in_order(self): if self.root is not None: self._in_order(self.root) def _in_order(self, node): if node is not None: self._in_order(node.left) print(node.value) self._in_order(node.right) def post_order(self): if self.root is not None: self._post_order(self.root) def _post_order(self, node): if node is not None: self._post_order(node.left) self._post_order(node.right) print(node.value) ``` 以上就是二叉树基本操作算法实现。 ### 回答2: 二叉树是一种重要的数据结构,在计算机科学和算法中有广泛的应用。基本操作指的是对二叉树进行插入、删除、查找、遍历等操作的算法实现。 1. 二叉树的插入操作:插入一个节点可以分为两种情况。首先判断二叉树是否为空,如果为空,则直接将节点作为根节点插入。如果不为空,则比较要插入节点的值与当前节点的值的大小关系,如果小于当前节点的值,则将节点插入当前节点的左子树,反之则插入右子树。递归操作直到找到合适的插入位置。 2. 二叉树的删除操作:删除一个节点可以分为三种情况。首先判断要删除的节点是否存在于当前二叉树中,如果不存在则直接返回。如果存在,则根据节点的子节点情况进行删除操作。如果要删除的节点没有子节点,则直接删除即可。如果要删除的节点只有一个子节点,则将子节点替换为要删除的节点。如果要删除的节点有两个子节点,则需要找到该节点右子树中的最小值节点来替换要删除的节点。 3. 二叉树的查找操作:查找操作可分为两种,分别是按节点值的查找和按节点位置的查找。按节点值的查找可以使用递归的方式,先判断当前节点是否为空或者节点的值等于要查找的值,如果是则返回该节点,否则按照节点值的大小关系在左右子树中递归查找。按节点位置的查找可以使用前序遍历、中序遍历或后序遍历等方法进行。 4. 二叉树的遍历操作:遍历操作可以分为前序遍历、中序遍历和后序遍历三种。前序遍历先访问根节点,然后递归遍历左子树和右子树。中序遍历先递归遍历左子树,然后访问根节点,最后递归遍历右子树。后序遍历先递归遍历左子树和右子树,最后访问根节点。 以上是二叉树基本操作算法实现的简要介绍,这些操作可以帮助我们在二叉树中查找、插入、删除等操作。 ### 回答3: 二叉树是一种树结构,每个节点最多有两个子节点,分为左子树和右子树。二叉树基本操作包括创建二叉树、插入节点、删除节点、查找节点以及遍历二叉树。 创建一个二叉树算法实现可以通过递归的方式来完成。首先创建一个空的根节点,然后递归地创建左子树和右子树。创建过程中可以通过用户输入来确定每个节点的值。 插入节点的算法实现主要通过比较节点的值大小,找到要插入节点的位置。如果要插入的节点大于当前节点,则插入到右子树中;如果要插入的节点小于当前节点,则插入到左子树中。如果子树为空,则直接插入新节点,否则继续递归查找插入位置。 删除节点的算法实现需要考虑多种情况。首先找到要删除的节点,如果节点没有子节点,直接删除;如果节点只有一个子节点,将子节点连接到当前节点的父节点上;如果节点有两个子节点,可以选择将左子树的最大节点或右子树的最小节点替换要删除的节点,然后再删除被替换节点。 查找节点的算法实现可以采用递归或者迭代的方式。递归方法通过比较节点的值大小来决定向左子树还是右子树查找。迭代方法可以利用栈或队列来实现,遍历每个节点并比较节点的值,直到找到目标节点。 遍历二叉树算法实现包括前序遍历、中序遍历和后序遍历。前序遍历先访问根节点,然后递归遍历左子树和右子树。中序遍历先递归遍历左子树,然后访问根节点,最后递归遍历右子树。后序遍历先递归遍历左子树和右子树,最后访问根节点。这些遍历方式都可以通过递归或迭代来实现。 这些是二叉树基本操作算法实现,通过它们可以有效地对二叉树进行操作和遍历。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值