数据结构 平衡二叉树

最新推荐文章于 2024-04-16 21:07:10 发布
最新推荐文章于 2024-04-16 21:07:10 发布
阅读量2.3k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq523176585/article/details/17287235
版权

平衡二叉树（Self-Balancing Binary Search Tree或Height-Balanced Binary Search Tree）:是一种二叉排序树，其中每一个节点的左子树和右子树的高度差至多等于1.
即左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1.二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF(Balance Factor),那么平衡二叉树上所有结点的平衡因子只可能是-1,0和1.

距离插入结点最近的，切平衡因子的绝对值大于1的结点为根的子树，我们称为最小不平衡子树。

旋转规律：
    当最小不平衡子树根结点的平衡因子BF是大于1时，就右旋，小于-1就左旋。在插入结点后，最小不平衡子树的BF与它的子树的BF符号相反时，就需要对结点先进行一次旋转以使得符号相同后，再反向旋转一次才能够完成平衡操作。

一般情况下，假设由于在二叉排序树上插入结点而失去平衡的最小子树根结点的指针为a(即a是离插入结点最近，且平衡因子绝对值超过1的祖先结点)，则失去平衡后进行调整的规律可归纳为下列4种情况：
   (1) 单向右旋处理：由于在*a的左子树根结点的左子树上插入结点，*a的平衡因子由1增至2，致使*a为根的子树失去平衡，则需进行一次向右的顺时针旋转操作，操作过后的结果：左子树取代结点的位置，结点成为其右子树，左子树的右字树成为结点的左子树。
   (2) 单向左旋处理: 由于在*a的右子树根结点的右子树上插入结点，*a的平衡因子由-1变为-2，致使以*a为根结点的子树失去平衡，则需进行一次向左的逆时针旋转操作，操作过后，右子树取代结点的位置，结点成为其左子树，右子树的左子树成为结点的右子树。
   (3) 双向旋转(先左后右)平衡处理：由于在*a的右子树根结点的左子树上插入结点，*a的平衡因子由1增至2，致使以*a为根结点的子树失去平衡，则需进行两次旋转操作
 (先左旋后右旋)。
   (4) 双向旋转(先右后左)平衡处理:由于在*a的右子树根结点的左子树上插入结点，*a的平衡因子有-1变成-2，致使*a为根结点的子树失去平衡，则需进行两次旋转(先右旋后左旋)操作。

在平衡二叉树BBST上插入一个新的数据元素e的递归算法可描述如下：
  (1)若BBST为空树，则插入一个数据元素为e的新结点作为BBST的根结点，树的深度增1；
  (2)若e的关键字和BBST的根结点的关键字相等，则不进行插入；
  (3)若e的关键字小于BBST的根结点的关键字，而且在BBST的左子树中不存在和e有相同关键字的结点，则将e插入在BBST的左子树上，并且当插入之后的左子树深度增加(+1)时，分别就下列不同情况处理之：
  a： BBST的根节点的平衡因子为-1(右子树的深度大于左子树的深度)，则将根结点的平衡因子更改为0，BBST的深度不变。
  b： BBST的根节点的平衡因子为0(右子树的深度等于左子树的深度)，则将根结点的平衡因子更改为+1，BBST的深度增1。
  c： BBST的根结点的平衡因子为1(左子树的深度大于右子树的深度)：若BBST的左子树根结点的平衡因子为1，则需进行单向右旋平衡处理，并且在右旋处理之后，将根结点和其右子树根结点的平衡因子更改为0，树的深度不变；

 

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

typedef int ElemType;

typedef struct BSTNode
{
	ElemType data;
	int bf;
	struct BSTNode *lchild,*rchild;
}BSTNode, *BiTree;

/*对以*p为根的二叉排序树作右旋转处理，处理之后p指向新的树根结点，
  即旋转处理之前的左子树的根结点
              ⑥
	         /  \
           ④    ⑦       插入② --->
		  /  \
		③	  ⑤


              ⑥
	         /  \
           ④    ⑦       右旋转 --->
		  /  \
		③	  ⑤
	   /
      ②

              ④
	         /  \
           ③    ⑥     
		  /     /  \
		②	   ⑤  ⑦ 
*/

void R_Rotate(BiTree &p)
{
	BiTree lc = p->lchild;  //示意图中的⑥为p，lc指向结点④
	p->lchild = lc->rchild ; //④的右孩子⑤成为⑥的左孩子
	lc->rchild = p;         //⑥成为④的右孩子
	p = lc;                //p指向新的结点
}

/*对以*p为根的二叉排序树作左旋转处理，处理之后p指向新的树根结点，
  即旋转处理之前的右子树的根结点
              ⑥
	         /  \
           ⑤    ⑧       插入⑩ --->
		        /  \
               ⑦   ⑨


              ⑥
	         /  \
           ⑤    ⑧       左旋转 --->
		        /  \
               ⑦   ⑨
                      \
					   ⑩

              ⑧
	         /  \
           ⑥    ⑨     
		  /  \     \
         ⑤   ⑦    ⑩
*/
void L_Rotate(BiTree &p)
{
	BiTree rc = p->rchild;  //示意图中的⑥为p，lc指向结点⑧
	p->rchild = rc->lchild; //⑧的左孩子⑦成为⑥的右孩子
	rc->lchild = p;         //⑥成为⑧的左孩子
	p = rc;                 //p指向新的根结点
}
	
#define LH    +1   /*左高*/
#define EH     0   /*等高*/
#define RH     -1  /*右高*/
#define TRUE   1
#define FALSE  0

/*
对指针T所指向结点为根的二叉树作左平衡旋转处理
本算法结束时，指针T指向新的根结点
*/
void LeftBlance(BiTree &T)
{
	BiTree L,Lr;
	L = T->lchild;   /* L指向T的左子树根结点*/
	switch(L->bf)
	{/*检查T的左子树的平衡度，并作相应平衡处理*/
	case LH:     /*新结点插入在T的左孩子的左子树上，符号相同，要作单右旋处理*/
		T->bf = L->bf = EH;
		R_Rotate(T);
		break;
	case RH: /*新结点插入在T的左孩子的右子树上，,符号不同，要做双旋处理*/
		Lr = L->rchild; /*Lr指向T的左孩子的右子树根*/
		switch(Lr->bf)  /*修改T及其左孩子的平衡因子*/
		{
		case LH:
			T->bf = RH;
			L->bf = EH;
			break;
		case EH:
			T->bf = L->bf = EH;
			break;
		case RH:
			T->bf = EH;
			L->bf = LH;
			break;
		}
		Lr->bf = EH;
		L_Rotate(T->lchild);   /*对T的左子树作左旋平衡处理*/
		R_Rotate(T);           /*对T作右旋平衡处理*/
	}
}

/*
对指针T所指向结点为根的二叉树作右平衡旋转处理
本算法结束时，指针T指向新的根结点
*/
void RightBlance(BiTree &T)
{
	BiTree L,Ll;
	L = T->rchild;   /* L指向T的右子树根结点*/
	switch(L->bf)
	{/*检查T的右子树的平衡度，并作相应平衡处理*/
	case RH:     /*新结点插入在T的右孩子的右子树上，符号相同，要作单右旋处理*/
		T->bf = L->bf = EH;
		L_Rotate(T);
		break;
	case LH: /*新结点插入在T的右孩子的左子树上，,符号不同，要做双旋处理*/
		Ll = L->lchild; /*Lr指向T的右孩子的左子树根*/
		switch(Ll->bf)  /*修改T及其右孩子的平衡因子*/
		{
		case RH:
			T->bf = RH;
			L->bf = EH;
			break;
		case EH:
			T->bf = L->bf = EH;
			break;
		case LH:
			T->bf = EH;
			L->bf = LH;
			break;
		}
		Ll->bf = EH;
		R_Rotate(T->rchild);   /*对T的右子树作右旋平衡处理*/
		L_Rotate(T);           /*对T作左旋平衡处理*/
	}
}


int InsertAVL(BiTree &T, int e, int &taller)
{
	if (!T)
	{/*插入新结点，树长高，置taller为TRUE*/
		T = (BiTree) malloc(sizeof(BSTNode));
		T->data = e;
		T->lchild = T->rchild = NULL;
		T->bf = EH;
		taller = TRUE;
	}
	else
	{
		if (e == T->data)
		{
			taller = FALSE;
			return FALSE;
		}
		if (e < T->data)
		{/*应继续在T的左子树中进行搜索*/
			if (!InsertAVL(T->lchild,e,taller))/*未插入*/
			{
				return FALSE;
			}
			if (taller)  
			{/* 已插入到T的左子树中且左子树"长高"*/
				switch( T->bf ) /*检查T的平衡度*/
				{
				case LH: /*原本左子树比右子树高，需要作左平衡处理*/
					LeftBlance(T);
					taller = FALSE;
					break;
				case EH:/*原本左右子树等高，现因左子树增高而树增高*/
					T->bf = LH;
					taller = TRUE;
					break;
				case RH: /*原本右子树比左子树高，现左右子树等高*/
					T->bf = EH;
					taller = FALSE;
					break;
				}
			}
		}

		else
		{/*应继续在T的右子树中进行搜索*/
			if (!InsertAVL(T->rchild,e,taller))/*未插入*/
			{
				return FALSE;
			}
			if (taller)  
			{/* 已插入到T的右子树中且右子树"长高"*/
				switch( T->bf ) /*检查T的平衡度*/
				{
				case LH: /*原本左子树比右子树高，现左右子树等高*/
					T->bf = EH;
					taller = FALSE;
					break;
				case EH:/*原本左右子树等高，现因右子树增高而树增高*/
					T->bf = RH;
					taller = TRUE;
					break;
				case RH: /*原本右子树比左子树高，现左右子树等高*/
					RightBlance(T);
					taller = FALSE;
					break;

				}
			}
		}
	}
	return TRUE;
}


void InOrderTraverse(BiTree T)
{
	if (T == NULL)
	{
		return;
	}
	InOrderTraverse(T->lchild);//访问左子树
	printf("%d ",T->data);//访问根结点
	InOrderTraverse(T->rchild);//访问右子树
}


int main()
{
	int i;
	int a[] = {3,2,1,4,5,6,7,10,9,8,25,13,46,26,68,98,15,12};
	BiTree T = NULL;
	int taller;
	for (i=0; i<(int)sizeof(a)/sizeof(a[0]); i++)
	{
		InsertAVL(T,a[i],taller);
	}
	InOrderTraverse(T);
	printf("\n");
	return 0;
}


 

悦来客栈的老板
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
110题：平衡二叉树
Randar0306的博客
08-04 337
给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 https://leetcode-cn.com/problems/balanced-binary-tree/ 深度值是一个很好地反映子树是否失衡的量。设当深度值为-1时，二叉树失衡。 getDepth递归函数 ：从叶子节点开始计算深度。计算非叶子节点的左右子树深度，如果相差值大于1，则返回-1表示失衡。 该函数的具体逻辑为： 首先节点如果为空，直接返回深度。.
C语言 数据结构平衡二叉树实例详解
08-30
C语言 数据结构平衡二叉树实例详解 以下是对C语言数据结构平衡二叉树实例详解的知识点总结： 1. 平衡二叉树的定义：平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不能超过1，使得树的高度尽可能的小...
平衡二叉树
周翔的专栏
05-24 1077
二叉树的查找，插入和删除操作的时间与树的高度有关，如果树尽量的矮胖，那么时间就短，那就要是满二叉树，或者说满N叉树，对于一颗M个节点的满N叉树时间复杂度为，但是维护满叉树，难度是很大的。所以AVL树(平衡树)放宽了条件，允许左右子树的高度差在一定的范围之内，avl树平衡条件是左右子树高度相差不能为2，而不是满叉树左右子树高度相同。AVL是以提出它的两位苏联数学家的名字头字母命名的。一棵N个节点的A
Leetcode110. 平衡二叉树 （python3）
weixin_43199534的博客
03-04 336
Leetcode110. 平衡二叉树 题目描述： 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 解法1： class Solution: def isBalanced(self, root): &quot;&quot;&quot; :type root: TreeNode ...
leetcode 110. 平衡二叉树(python3)
算法探索之路
03-13 185
110. 平衡二叉树 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # ...
LeetCode 110 平衡二叉树 Python3
mxxxkuku的博客
03-17 97
1、深度搜索，自顶向下 遍历节点时都判断是否满足平衡的条件 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: def isBalan
数据结构平衡二叉树的操作演示
05-07
数据结构平衡二叉树的操作演示 本篇文章将对平衡二叉树的操作演示进行详细的介绍，包括创建表、查找、插入、删除、合并、分裂六种操作。并对平衡二叉树的实现过程进行了详细的设计和分析。 一、概要设计 平衡...
广工数据结构实验——平衡二叉树
07-06
本实验“广工数据结构实验——平衡二叉树”着重探讨了一种特殊类型的数据结构，即平衡二叉树。平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的...
数据结构 平衡二叉树 c
07-02
我们的数据结构实验课里的关于平衡二叉树的代码。 包含二叉树的插入和平衡，先序、中序和后序遍历。 基本全是按照清华的那本教科书里的思路写的，清晰易懂。
leetcode110.平衡二叉树(python3实现)
qq_28805597的博客
11-05 287
问题描述 链接：leetcode110 我的解法 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: #取当前结点的高度。叶子节点为0，父
LeetCode110-平衡二叉树-Python3
王俊的博客
02-07 323
题目 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回 true 。示例 2: 给定二叉树 [1,2,2,3,3,null,...
平衡二叉树-python
baisong6412的博客
08-10 104
思路：平衡二叉树的左右子树的深度相差不能超过1， 因此可以利用上一题求二叉树的深度的函数，对左右子树求最大深度，如果深度小于1，那么就是平衡二叉树了 # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None ...
python 平衡二叉树
WYXHAHAHA123的博客
05-06 318
''' 题目描述 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 ''' # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Soluti...
二叉树python实现_平衡二叉树的python实现
weixin_39600319的博客
12-10 73
class Node:def __init__(self, val):self.val = valself.left = Noneself.right = Nonedef __str__(self):return str(self.val)__repr__ = __str__def depth(node):if node is None:return 0d1 = depth(node.left)d...
python实现平衡二叉树_平衡二叉树python
weixin_32659227的博客
02-10 222
# stack_depth is initialised to 0def find_in_tree(node, find_condition, stack_depth):assert (stack_depth < max_stack_depth), 'Deeper than max depth'stack_depth += 1result = []if find_condition(node...
【python数据结构】平衡二叉树
weixin_37206602的博客
03-29 358
具体知识点：https://blog.csdn.net/liyuanyue2017/article/details/83652743 便于理解 平衡二叉树要解决的问题： 是设计怎样的树结构才能使查找的效率比较高。用Asl来进行衡量 平衡因子： 左右子树的高度差 要求 平衡因子 <=1 这样的数称为平衡儿二叉树 使得树的高度 logn 在我们将数据插入平衡二叉树的时候会导致树变得不平...
python 平衡二叉树实现
weixin_30407099的博客
06-13 207
平衡二叉树： 　　在上一节二叉树的基础上我们实现，如何将生成平衡的二叉树 　　所谓平衡二叉树： 　　　　我自己定义就是：任何一个节点的左高度和右高度的差的绝对值都小于2 　　　　如图所示，此时a的左高度等于3，有高度等于1，差值为2，属于不平衡中的左偏 　　 　　此时的处理办法就是： 　　　　将不平衡的元素的左枝的最右节点变为当前节点， 　　　　此时分两种情况： 　　　...
Java——二叉树
最新发布
weixin_74521994的博客
04-16 1273
平衡因子可以是 -1、0 或 1，这确保了每个节点的左右子树的高度差不会超过 1，从而维持了树的平衡状态。AVL树是一种高度平衡的二叉搜索树，它在每次插入或删除节点后，都会通过旋转操作来保持树的平衡。AVL树的主要优点是在保持平衡的同时，还能保持二叉搜索树的性质，因此在查找、插入和删除操作时具有较高的效率。红黑树是一种特殊的二叉查找树，它的每个节点都有一个颜色属性，要么是红色，要么是黑色。：当一个节点的平衡因子变为非法值时，如果不平衡在节点的某一侧，那么只需要一次旋转就可以恢复平衡。
数据结构平衡二叉树C语言代码
07-16
当然，下面是一个简单的平衡二叉树的C语言代码示例： ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树节点结构 typedef struct Node { int data; // 节点值 struct Node* left; // 左子节点指针 struct Node* right; // 右子节点指针 int height; // 节点高度 } Node; // 计算节点的高度 int height(Node* node) { if (node == NULL) { return 0; } return node->height; } // 获取两个数中较大的值 int max(int a, int b) { return (a > b) ? a : b; } // 创建一个新节点 Node* createNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->left = NULL; newNode->right = NULL; newNode->height = 1; return newNode; } // 执行右旋操作 Node* rightRotate(Node* y) { Node* x = y->left; Node* T2 = x->right; x->right = y; y->left = T2; y->height = max(height(y->left), height(y->right)) + 1; x->height = max(height(x->left), height(x->right)) + 1; return x; } // 执行左旋操作 Node* leftRotate(Node* x) { Node* y = x->right; Node* T2 = y->left; y->left = x; x->right = T2; x->height = max(height(x->left), height(x->right)) + 1; y->height = max(height(y->left), height(y->right)) + 1; return y; } // 获取节点的平衡因子 int getBalanceFactor(Node* node) { if (node == NULL) { return 0; } return height(node->left) - height(node->right); } // 插入节点 Node* insertNode(Node* node, int data) { if (node == NULL) { return createNode(data); } if (data < node->data) { node->left = insertNode(node->left, data); } else if (data > node->data) { node->right = insertNode(node->right, data); } else { // 忽略插入相同的节点 return node; } node->height = 1 + max(height(node->left), height(node->right)); int balanceFactor = getBalanceFactor(node); // 左-左情况，执行右旋操作 if (balanceFactor > 1 && data < node->left->data) { return rightRotate(node); } // 右-右情况，执行左旋操作 if (balanceFactor < -1 && data > node->right->data) { return leftRotate(node); } // 左-右情况，先对左子节点进行左旋，再对当前节点进行右旋 if (balanceFactor > 1 && data > node->left->data) { node->left = leftRotate(node->left); return rightRotate(node); } // 右-左情况，先对右子节点进行右旋，再对当前节点进行左旋 if (balanceFactor < -1 && data < node->right->data) { node->right = rightRotate(node->right); return leftRotate(node); } return node; } // 中序遍历二叉树 void inorderTraversal(Node* root) { if (root != NULL) { inorderTraversal(root->left); printf("%d ", root->data); inorderTraversal(root->right); } } int main() { Node* root = NULL; root = insertNode(root, 10); root = insertNode(root, 20); root = insertNode(root, 30); root = insertNode(root, 40); root = insertNode(root, 50); root = insertNode(root, 25); printf("中序遍历结果："); inorderTraversal(root); return 0; } ``` 这段代码实现了一个平衡二叉树的插入和中序遍历操作。你可以根据需要自行修改和扩展。希望对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值