数据结构--树（中）平衡树、搜索树、判断搜索树是否相同

最新推荐文章于 2022-09-08 22:12:19 发布
最新推荐文章于 2022-09-08 22:12:19 发布
阅读量341 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20225851/article/details/104133674
版权

二叉搜索树

什么是二叉搜索树？
一颗二叉树，可以为空，如果不为空，满足以下性质：

  • 非空左子树的所有键值小于其根结点的键值
  • 非空右子树的所有键值大于其根结点的键值
  • 左右子树都是二叉搜索树

在这里插入图片描述

二叉搜索树操作的特别函数

  • Position Find( ElementType X, BinTree BST )：从二叉搜索树BST中查找元素X，返回其所在结点的地址；
  • Position FindMin( BinTree BST )：从二叉搜索树BST中查找并返回最小元素所在结点的地址；
  • Position FindMax( BinTree BST ) ：从二叉搜索树BST中查找并返回最大元素所在结点的地址。
  • BinTree Insert( ElementType X, BinTree BST )
  • BinTree Delete( ElementType X, BinTree BST )

下面对这些函数的功能进行实现！

1.Find
递归写法：

  1. 判断是否为空，空则代表未找到
  2. 判断当前结点的大小关系，大则从右子树找，小则从左子树找，相等说明找到了。
BinTree Find(ElementType x, BinTree BST)
{
	if (!BST) //未找到 
	{
		return NULL;
	}
	if (x < BST->date) //小  查找左子树 
	{
		return Find(x, BST->left);
	}
	else if (x > BST->date)//大 查找右子树 
	{
		return Find(x, BST->right);
	}
	else  // 相等则找到 
		return BST;
}

递归效率较低，尾递归可以用循环实现

BinTree IterFind(ElementType x, BinTree BST) //尾递归函数可改为迭代函数 
{
	while (BST)
	{
		if (BST->date < x)
			BST = BST->left;
		else if (BST->date > x)
			BST = BST->right;
		else
			return BST;
	}
	return NULL;
}

2.FindMax/Min

  1. 树的最左边即为最小值，因为任何一个结点的右子树存在都会比该结点大，最大值同理
BinTree FindMin(BinTree BST)
{
	if (!BST) return NULL;  // 空树 
	if (BST->left != NULL)
		return  FindMin(BST->left);
	else
		return BST;
}

BinTree FindMax(BinTree BST)
{
	if (!BST) return NULL;  // 空树 
	if (BST->right != NULL)
		return  FindMax(BST->right);
	else
		return BST;
}

3.Insert

  1. 首先先按上面查找的方式找到合适插入元素的位置
  2. 递归到待插入结点，因为没有元素，所以是空，所以会进入if (!BST) 语句中，分配空间，赋值，最后一定要把结点返回回去。
BinTree Insert(ElementType x, BinTree BST)
{
	if (!BST)//空  插入 
	{
		BST = (BinTree)malloc(sizeof(Tree));
		BST->date = x;
		BST->left = BST->right = NULL;
	}
	else
	{
		if (x < BST->date)
			BST->left = Insert(x, BST->left); //小 插入左子树 
		else
			BST->right = Insert(x, BST->right);//大 插入右子树 
		//相等则不操作	
	}
	return BST;
}

4.Delete（难点）

  • 首先找到待删除的结点 ，未找到则返回空
  • 找到结点后又下面几种情况
    1.当前为子叶结点，则直接把当前结点的空间释放即可
    2.当前结点左子树为空，右子树不为空，则需要把当前结点先用一个变量保存起来，然后把当前位置赋值为当前位置的右子树，最后将待删除的结点空间释放，反过来的处理方法类似
    3.当左右子树都非空时，找到右子树的最小值和待删除的结点值替换，然后再把找到的那个最小值删掉。理由：当前结点的右子树的最小值和当前节点替换，仍然保持左小右大的性质，最重要的时，右子树的最小值一定是是叶子结点或者只有左子树，这就转化成上面那种情况的删除方法了。（寻找左子树的最大值也可以）
BinTree Delete(ElementType x, BinTree BST)
{
	if (!BST) return NULL;// 未找到
	else if (BST->date > x)
		  BST->left = Delete(x, BST->left);
	else if (BST->date < x)
		 BST->right =Delete(x, BST->right);
	else //找到待删除结点，分类处理
	{
		if (BST->left && BST->right) //左右子树都非空的情况
		{
			BinTree tem = FindMin(BST->right); //寻找右子树的最小值
			BST->date = tem->date;//替换
			BST->right = Delete(BST->date, BST->right);//删除替换的结点
		}
		else // 叶子结点或者只有左子树或只有右子树
		{
			BinTree temp = BST;	
			if (!BST->left) //只有右子树
				BST = BST->right;
			else if (!BST->right)//只有左子树
				BST = BST->left;
			//叶子结点直接删除即可
			free(temp);
		}
	}
	return BST;
}

5.InTraverse
这里采用先序遍历，方法上篇博客讲过这里不再解释

void InTraverse(BinTree BST) // 中序遍历 
{
	if (!BST)
		return;
	InTraverse(BST->left);
	cout << BST->date << " ";
	InTraverse(BST->right);
}

总代码：

#include<iostream>
#include <stdlib.h>
#include <string.h>
#include <string>
using namespace std;
#define ElementType  int 
#define Maxn 10000

typedef struct node {
	ElementType date;
	struct node* left;
	struct node* right;
}*BinTree, Tree;


BinTree Find(ElementType x, BinTree BST)
{
	if (!BST) //未找到 
	{
		return NULL;
	}
	if (x < BST->date) //小  查找左子树 
	{
		return Find(x, BST->left);
	}
	else if (x > BST->date)//大 查找右子树 
	{
		return Find(x, BST->right);
	}
	else  // 相等则找到 
		return BST;
}

BinTree IterFind(ElementType x, BinTree BST) //尾递归函数可改为迭代函数 
{
	while (BST)
	{
		if (BST->date < x)
			BST = BST->left;
		else if (BST->date > x)
			BST = BST->right;
		else
			return BST;
	}
	return NULL;
}

BinTree FindMin(BinTree BST)
{
	if (!BST) return NULL;  // 空树 
	if (BST->left != NULL)
		return  FindMin(BST->left);
	else
		return BST;
}

BinTree FindMax(BinTree BST)
{
	if (!BST) return NULL;  // 空树 
	if (BST->right != NULL)
		return  FindMax(BST->right);
	else
		return BST;
}

BinTree Insert(ElementType x, BinTree BST)
{
	if (!BST)//空  插入 
	{
		BST = (BinTree)malloc(sizeof(Tree));
		BST->date = x;
		BST->left = BST->right = NULL;
	}
	else
	{
		if (x < BST->date)
			BST->left = Insert(x, BST->left); //小 插入左子树 
		else
			BST->right = Insert(x, BST->right);//大 插入右子树 
		//相等则不操作	
	}
	return BST;
}

BinTree Delete(ElementType x, BinTree BST)
{
	if (!BST) return NULL;// 未找到
	else if (BST->date > x)
		  BST->left = Delete(x, BST->left);
	else if (BST->date < x)
		 BST->right =Delete(x, BST->right);
	else
	{
		if (BST->left && BST->right)
		{
			BinTree tem = FindMin(BST->right);
			BST->date = tem->date;
			BST->right = Delete(BST->date, BST->right);
		}
		else
		{
			BinTree temp = BST;	
			if (!BST->left)
				BST = BST->right;
			else if (!BST->right)
				BST = BST->left;
			free(temp);
		}
	}
	return BST;
}

void InTraverse(BinTree BST) // 中序遍历 
{
	if (!BST)
		return;
	InTraverse(BST->left);
	cout << BST->date << " ";
	InTraverse(BST->right);
}
int main()
{
	BinTree root =NULL;
	for (int i = 1; i < 10; i++)
		root = Insert(i, root);
	InTraverse(root);
	cout <<endl;
	BinTree item = FindMax(root);
	cout <<"最大：" <<item->date <<endl;
	item = FindMin(root);
	cout <<"最小："<<item->date<<endl;
	Delete(2,root);
	InTraverse(root);
	cout <<endl;
	item = Find(5,root);
	cout <<"查找5的结果："<< item->date ;
	Insert(-5,root);
	InTraverse(root);
	cout <<endl;
	return 0;
}

在这里插入图片描述

我们来观察下上面我们画的树：
在这里插入图片描述
上次博客树的介绍中可以知道，树的深度等于搜索的次数，如果我们要查找9，需要查找9次，这和顺序查找的效率相同，原因很显然，这颗树左右不平衡是导致搜索次数增加的原因，因此下面介绍一种平衡树，平衡树可以很好的避免这个问题。

搜索树结点不同插入次序，将导致不同的深度和平均查找长度ASL
在这里插入图片描述
不同的结构的搜索树，ASL的值会不同，树左右越平衡，平均搜索次数越小，搜索效率越高。

平衡树二叉树

平衡因子：BF(T) = Hl - Hr，为左右子树高度的差

平衡二叉树（AVL树）
空树，或者任一结点左、右子树高度差的绝对值不超过1，即|BF（T)|<=1
在这里插入图片描述
给定结点数为n的AVL树的最大高为O（log2n）也就是说搜索次数最大为log2n。

平衡二叉树的调整

一共有下面四种调整方法：

RR旋转
在这里插入图片描述
插入后，A结点不平衡，不平衡的地方位于右子树的右子树，因而叫右右插入，需要RR旋转（右单旋）个人理解是按着右手旋转。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

AVLTree SingleRightRotation ( AVLTree A )
{/* 注意：A必须有一个右子结点B */
  /* 将A与B做右单旋，更新A与B的高度，返回新的根结点B */ 
      
	AVLTree B = A->Right;
	A->Right = B->Left; 
	B->Left = A ;
	A->Height = Max(GetHeight(A->Left) , GetHeight(A->Right))+1;
	B->Right = Max(A->Height , GetHeight(B->Right))+1;
	return B ;
}

LL旋转
理解了RR旋转，LL旋转是一个道理的。
在这里插入图片描述
插入后，A结点不平衡，不平衡的地方位于左子树的左子树，因而叫左左插入，需要LL旋转（左单旋）
在这里插入图片描述

AVLTree SingleLeftRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B */
  /* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */     
  
    AVLTree B = A->Left;
    A->Left = B->Right;
    B->Right = A;
    A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
    B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
    return B;
}

LR旋转
在这里插入图片描述
插入后，A结点不平衡，导致不平衡的位置位于A左子树的右子树上，因而叫LR插入，需要LR旋转。

LR旋转方法：

1.从不平衡结点 以及该结点的左结点和左节点的右结点中找一个中间值（左节点的右结点：Mar）

在这里插入图片描述
2.然后将中间值作为其余两个结点的父节点
在这里插入图片描述
注意观察Cl /Cr挂的方式 ， Cl和Cr只会存在一种，只是挂在左边和右边旋转后挂的地方也会不同
在这里插入图片描述

AVLTree DoubleLeftRightRotation ( AVLTree A ) //LR旋转 
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */
  
    /* 将B与C做右单旋，C被返回 */
    A->Left = SingleRightRotation(A->Left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}

RL旋转
RL则和LR类似
在这里插入图片描述

 AVLTree DoubleRightLeftRotation ( AVLTree A ) //LR旋转 
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */
  
    /* 将B与C做右单旋，C被返回 */
    A->Right = SingleLeftRotation(A->Right);
    /* 将A与C做左单旋，C被返回 */
    return SingleRightRotation(A);
}

元素插入

AVLTree Insert( AVLTree T, ElementType X )
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    if ( !T ) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Height = 0;
        T->Left = T->Right = NULL;
    } /* if (插入空树) 结束 */
 
    else if ( X < T->Data ) {
        /* 插入T的左子树 */
        T->Left = Insert( T->Left, X);
        /* 如果需要左旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
            if ( X < T->Left->Data ) 
               T = SingleLeftRotation(T);      /* 左单旋 */
            else 
               T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    } /* else if (插入左子树) 结束 */
     
    else if ( X > T->Data ) {
        /* 插入T的右子树 */
        T->Right = Insert( T->Right, X );
        /* 如果需要右旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
            if ( X > T->Right->Data ) 
               T = SingleRightRotation(T);     /* 右单旋 */
            else 
               T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    } /* else if (插入右子树) 结束 */
 
    /* else X == T->Data，无须插入 */
 
    /* 别忘了更新树高 */
    T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;
     
    return T;
}

代码：

#include<iostream>
#include <stdlib.h>
#include <string>
#include <string.h>

using namespace std;
#define ElementType int
typedef struct AVLNode* Position;
typedef Position AVLTree; /* AVL树类型 */
AVLTree Root = NULL;
struct AVLNode {
    ElementType Data; /* 结点数据 */
    AVLTree Left;     /* 指向左子树 */
    AVLTree Right;    /* 指向右子树 */
    int Height;       /* 树高 */
};




int Max(int a, int b)
{
    return a > b ? a : b;
}

int GetHeight(AVLTree A)
{
    if (!A)
        return 0;
    return Max(GetHeight(A->Left),GetHeight(A->Right))+1;
}
AVLTree SingleLeftRotation(AVLTree A)
{ /* 注意：A必须有一个左子结点B */
  /* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */

    AVLTree B = A->Left;
    A->Left = B->Right;
    B->Right = A;
    A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
    B->Height = Max(GetHeight(B->Left), A->Height) + 1;
    return B;
}

AVLTree SingleRightRotation(AVLTree A)
{/* 注意：A必须有一个右子结点B */
  /* 将A与B做右单旋，更新A与B的高度，返回新的根结点B */

    AVLTree B = A->Right;
    A->Right = B->Left;
    B->Left = A;
    A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
    B->Height = Max(A->Height, GetHeight(B->Right)) + 1;
    return B;
}


AVLTree DoubleLeftRightRotation(AVLTree A) //LR旋转 
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */

    /* 将B与C做右单旋，C被返回 */
    A->Left = SingleRightRotation(A->Left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}

AVLTree DoubleRightLeftRotation(AVLTree A) //LR旋转 
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */

    /* 将B与C做右单旋，C被返回 */
    A->Right = SingleLeftRotation(A->Right);
    /* 将A与C做左单旋，C被返回 */
    return SingleRightRotation(A);
}


AVLTree Insert(AVLTree &T, ElementType X)
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    if (!T) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Height = 0;
        T->Left = T->Right = NULL;
    } /* if (插入空树) 结束 */
    else if (X < T->Data) {
        /* 插入T的左子树 */
        T->Left = Insert(T->Left, X);
        /* 如果需要左旋 */
        if (GetHeight(T->Left) - GetHeight(T->Right) == 2)
            if (X < T->Left->Data)
                T = SingleLeftRotation(T);      /* 左单旋 */
            else
                T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    } /* else if (插入左子树) 结束 */

    else if (X > T->Data) {
        /* 插入T的右子树 */
        T->Right = Insert(T->Right, X);
        /* 如果需要右旋 */
        if (GetHeight(T->Left) - GetHeight(T->Right) == -2)
            if (X > T->Right->Data)
                T = SingleRightRotation(T);     /* 右单旋 */
            else
                T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    } /* else if (插入右子树) 结束 */

    /* else X == T->Data，无须插入 */

    /* 别忘了更新树高 */
    T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1;
    return T;
}

void preTraverse(AVLTree T)
{
    if (!T)
        return;
    cout << "数据:" << T->Data << " 高度：" << T->Height << " ||";
    preTraverse(T->Left);
    preTraverse(T->Right);
}
void inTraverse(AVLTree T)
{
    if (!T)
        return;
    inTraverse(T->Left);
    cout << "数据:" << T->Data << " 高度：" << T->Height << " ||";
    inTraverse(T->Right);
}

int main()
{
    
    for (int i = 0; i < 10; i++)
    {
        Insert(Root, i);
    }
    cout << "先序："; preTraverse(Root); cout << endl;
    cout << "中序："; inTraverse(Root); cout << endl;
}

在这里插入图片描述

在这里插入图片描述
这是该程序生成的AVL树。

习题：是否同一棵二叉搜索树

题目：
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。

输入格式:
输入包含若干组测试数据。每组数据的第1行给出两个正整数N (≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行，每行给出N个插入的元素，属于L个需要检查的序列。

简单起见，我们保证每个插入序列都是1到N的一个排列。当读到N为0时，标志输入结束，这组数据不要处理。

输出格式:
对每一组需要检查的序列，如果其生成的二叉搜索树跟对应的初始序列生成的一样，输出“Yes”，否则输出“No”。

输入样例:
4 2
3 1 4 2
3 4 1 2
3 2 4 1
2 1
2 1
1 2
0

输出样例:
Yes
No
No

一个序列对应唯一一颗判断树，但是一颗树不一定对应一个序列！

解法一:不建树判别方法
思路：
在这里插入图片描述
只需要同过比对数字，就可以判断是否相同，我是用递归的方法进行判断的。

#include <iostream>
#include <algorithm>
using namespace std;

bool cmp(int T1[], int T2[], int n)
{
	if (n == 0) //n==0 没元素 返回true
		return true;
	if (T1[0] != T2[0]) //首元素不同  则树不同
		return false;
	if (T1[0] == T2[0] && n == 1) //首元素相同，且只有一个元素，则相同
		return true;
	int T1L[100], T1R[100], T2L[100], T2R[100];
	int L1 = 0, R1 = 0, L2 = 0, R2 = 0;
	for (int i = 1; i < n; i++) // 分别获取每个树的左子树和右子树
	{
		if (T1[i] > T1[0])
			T1R[R1++] = T1[i];
		else
			T1L[L1++] = T1[i];
	}
	for (int i = 1; i < n; i++)
	{
		if (T2[i] > T2[0])
			T2R[R2++] = T2[i];
		else
			T2L[L2++] = T2[i];
	}
	if (L1 != L2 || R1 != R2)//如果长度不同则子树肯定不同返回false
		return false;
	return cmp(T1L, T2L, L1) && cmp(T1R, T2R, R1);//递归子树进行比较
}

int main()
{
	int n, l;
	int T1[100], T2[100];
	while (cin >> n && n)
	{
		cin >> l;
		for (int i = 0; i < n; i++)
			cin >> T1[i];
		while (l--)
		{
			for (int i = 0; i < n; i++)
				cin >> T2[i];
			if (cmp(T1, T2, n))
				cout << "Yes" << endl;
			else
				cout << "No" << endl;
		}
	}
	return 0;
}

哈哈，这么投机取巧的方法当然不是做这个题目的目的啦，还是规规矩矩的建个树判断吧，锻炼下建树能力！

解法二：建树判断

  1. 建树，只需建第一颗树 ，每个结点多了一个flag ，用于后面判断树是否相同
  2. 判断，每输入一个元素都在模板树中进行一次搜索，如果如果每次搜索所经过的结点在前面均出现过，则一致，否则（某次搜索中遇到前面未出现的结点），则不一致。
bool Find(int date, Tree& T)
{
//flag ==0 代表未访问， ==1代表访问过
	if (!T) //未找到 false
		return false;
	else if (T->date == date) //找到了 true
	{
		T->flag = 1; //设为访问
		return true;
	}
	else if (T->date != date && T->flag == 0) //不相等 且未访问 false
		return false;
	else
	{
		if (T->date > date) //继续往下找
			return Find(date, T->left);
		else
			return Find(date, T->right);
	}
}
void  check(Tree T, int n)
{
	clean(T); //将每个flag 都先清0
	int flag = 0; //标记树是否相同
	int date;
	while (n--)
	{
		cin >> date;
		if (!flag && !Find(date, T))  //如果判断出树不同，则无需比较了，但还是要继续循环，因为数据还没输入完
		{
			flag = 1;
		}
	}
	if (!flag)
		cout << "Yes" << endl;
	else
		cout << "No" << endl;
}

解题代码：

#include <iostream>
#include <algorithm>
using namespace std;

typedef struct BiTree {
	int date;
	int flag;
	struct BiTree* left;
	struct BiTree* right;
}*Tree, Treenode;

Tree Insert(int date, Tree& T)
{
	if (!T)
	{
		T = (Tree)malloc(sizeof(Treenode));
		T->date = date;
		T->left = T->right = NULL;
	}
	else
	{
		if (T->date > date)
		{
			T->left = Insert(date, T->left);
		}
		else if (T->date < date)
		{
			T->right = Insert(date, T->right);
		}
	}
	return T;
}

void clean(Tree& T)
{
	if (!T)
		return;
	T->flag = 0;
	clean(T->left);
	clean(T->right);
}

bool Find(int date, Tree& T)
{
	if (!T)
		return false;
	else if (T->date == date)
	{
		T->flag = 1;
		return true;
	}
	else if (T->date != date && T->flag == 0)
		return false;
	else
	{
		if (T->date > date)
			return Find(date, T->left);
		else
			return Find(date, T->right);
	}
}

void  check(Tree T, int n)
{
	clean(T);
	int flag = 0;
	int date;
	while (n--)
	{
		cin >> date;
		if (!flag && !Find(date, T))
		{
			flag = 1;
		}
	}
	if (!flag)
		cout << "Yes" << endl;
	else
		cout << "No" << endl;
}
int main()
{
	int n, date;
	while (cin >> n && n)
	{
		Tree Root =NULL ;
		int l;
		cin >> l;
		for (int i = 0; i < n; i++)
		{
			cin >> date;
			Insert(date, Root);
		}
		while (l--)
		{
			check(Root,n);
		}
	}

	return 0;
}
代码噜噜噜
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构-树（三）：多路搜索树B树、B+树
12-15
多路搜索树 完全二叉树高度：O(log2N)，其中2为对数 完全M路搜索树的高度：O(logmN)，其中M为对数，树每层...B树是一种M路搜索树，B树主要用于解决M路搜索树的不平衡导致树的高度变高，跟二叉树退化为链表导致性能问
二叉排序树插入相同值的处理
热门推荐
qq_38608897的博客
01-04 2万+
二叉排序树插入相同值的处理什么是二叉排序树二叉排序树建立（插入）出现相同值的处理 什么是二叉排序树 二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有下列性质的二叉树： （1）若左子树不为空，则左子树上所有结点的值均小于它的根节点的值 （2）若右子树不为空，则右子树上所有结点的值均大于它的根节点的值 （3）左右子树自己也是二叉排序树 二叉排序树建立（插入）出现相同值的处理 一...
数据结构（十四）二叉树 —— 二叉排序树
在路上
07-17 2838
二叉排序树（BinarySortedTree）是二叉树的另一个典型应用，之所以称之为二叉排序树，是因为这种二叉树结构在创建的时候遵循一些特殊的规则，并且在对这棵二叉树进行制定顺序的遍历之后，能够得到一个有序序列。 二叉排序树相当于是另一种排序算法的实现。但是，二叉排序树也同样存在着不足：二叉排序树中不允许存在取值相同的值这也是由其结构决定的。下面，我们就以Java中的TreeSet结构为入手点...
查找之二叉排序树
是我是我都是我的博客
08-02 899
查找之二叉排序树
二叉搜索树（数据结构）
weixin_61518137的博客
03-15 591
1.二叉搜索树的定义： 若它的左子树不为空，则左子树的所有结点的值都小于根结点的值； 若它的右子树不为空，则右子树的所有结点的值都大于根结点的值； 他的左右子树也是二叉搜索树 上代码： static class Node { int data; public Node(int data) { this.data=data; } Node left; Node right;
二叉搜索树
HHHuYYYue的博客
05-29 1125
一. 什么是二叉搜索树? 二叉搜索树是一棵特殊的二叉树, 又称为二叉排序树, 其特性为: 空树也是二叉搜索树 若它的左子树不为空, 则左子树上所有节点值均小于根节点的值 若它的右子树不为空, 则右子树上所有节点值均大于根节点的值 二叉搜索树的左右子树也都是二叉搜索树 二叉搜索树通过中序遍历可以得到一个有序的序列 例如上图中, 中序遍历的结果为: 2 3 3 7 8 9 10 12 16 18 二. 关于二叉搜索树的操作 1. 增加一个节点 根据二叉搜索树的性质, 增加节点的思路如下: 假设在这棵二叉
C++数据结构-二叉查找树和平衡二叉树
01-03
实现了二叉查找树的查找、插入...实现了平衡二叉树（AVL树）的查找、插入、删除和迭代遍历的完整功能，插入时的各种旋转操作按照经典数据结构教材实现，并有详细的注释和说明。删除操作和相关旋转方法有单独描述文档。
南邮实践周项目-搜索树的相关操作-Java语言
最新发布
11-10
实践周程序设计项目之一，比较简单，仅仅涉及到了二叉搜索树、二叉平衡树、平衡树的插入、删除、搜索等操作，最后用一个图形化界面进行展示。有需求者可自取。 阅读建议：有一定Java语言基础，了解package和类的...
二叉搜索树，红黑树，AVL平衡树，B树
05-08
完整实现二叉搜索树，红黑树，AVL平衡树，B树的搜索插入删除基本功能和其它功能。红黑树和B树参考自算法导论。
Java实现的二叉搜索树和平衡二叉树的代码示例
01-20
Java实现的二叉搜索树和平衡二叉树的代码示例
两个序列是否对应相同搜索树的判别（浙--建议采用“调试”体会函数的调用过程）
weixin_45846799的博客
11-28 413
#include <stdio.h> #include <stdlib.h> typedef struct TreeNode *Tree; struct TreeNode{ int v; Tree Left,Right; int flag;//设立标志判断是否为找过的函数，为函数check()与Judge()做准备 }; //如何建立搜索树 Tree MakeTree (int N); //根据首个元素创建一个结点，形成树根或创建一个新的结点 Tree NewNod
6、数据结构
qq_44774198的博客
09-08 742
数据结构是指数据对象及其相互关系和构造方法。在软件设计过程中，不同的数据结构的选用，对系统最终效果的影响极大。所以该知识点是软件设计师核心考点，无论是上午综合知识部分，还是下午的软件设计部分，考查分值都很高。根据考试大纲，本章要求考生掌握数组、链表、队列和栈、树、图、杂凑相关知识，从历年的考试情况来看，本章主要考查常见数据结构的逻辑结构特性及存储的相关内容。
二叉树 平衡树 搜索树 AVL树 红黑树 B树 B+树
trigger的博客
03-08 407
为了解决二叉树数据有序时出现的线性插入树太深问题，树的深度会明显降低，虽然极大提高性能，但是当数据量很大时，一般mysql中一张表达到3-5百万条数据 是很普遍，因此平衡二叉树的深度会非常大，mysql读取时会消耗大量IO。 不仅如此，计算机从磁盘读取数据时以页(4KB)为单位的，每次读取4096byte。平衡二叉树每个节点只保存了一个关键字（如int即4byte），浪费了4092byte，极大的浪费了读取空间。 ...
二叉树（链式、顺序、线索二叉树、二叉排序树、平衡二叉树）
Mona
07-20 953
二叉树（链式、顺序、线索二叉树、二叉排序树、平衡二叉树）
查找（排序）二叉树、最优二叉树（哈夫曼树）、线索二叉树、平衡二叉树；各种二叉树你还记得它们都是什么吗？（二）
wdshhh的博客
05-29 1223
查找二叉树 又叫二叉排序树 性质： 左儿子的值 < 父结点的值 < 右儿子的值 因此，不能存在俩个相同值的结点 作用（意义)：极大程度提高查询数据的效率。（相当于二分查找的效率） 插入结点： 若有相同键值的结点，则不插入。 若查找二叉树为空，则直接作为根结点。 与父结点（先从根结点）比较。小于父结点，插入结点到左子树。大于父结点，插入结点到右子树。 删除结点： 如果为叶子结点，直接删除。 如果只有一个儿子结点，则让儿子结点代替它的位置。 如果有俩个儿子结点，则在该结点的左子树上，找到
树---二叉树、顺序存储二叉树、线索化二叉树、二叉搜索树（BST）、平衡二叉树（AVL）
IT_10的博客
02-20 917
树 树形结构： 每个结点有零个或多个子结点； 没有父结点的结点称为根结点； 每一个非根结点有且只有一个父结点； 除了根结点外，每个子结点可以分为多个不相交的子树； 关于树形结构中的一些术语： 节点的高度=节点到叶子节点的最长路径（边数） 节点的深度=根节点到这个节点所经历的边的个数 节点的层数=节点的深度+1 树的高度=根节点的高度 二叉树 每个节点最多有两个子节点 满二叉树：一棵二叉树...
数据结构与算法学习---数据结构篇（树b）（默然回首，夯实基础）
weixin_43185348的博客
05-26 324
一、平衡树 之前我们学习过二叉查找树，发现它的查询效率比单纯的链表和数组的查询效率要高很多，大部分情况下，确实是这样的，但不幸的是，在最坏情况下，二叉查找树的性能还是很糟糕。 例如我们依次往二叉查找树中插入9,8,7,6,5,4,3,2,1这9个数据，那么最终构造出来的树是长得下面这个样子： 我们会发现，如果我们要查找1这个元素，查找的效率依旧会很低。效率低的原因在于这个树并不平衡，全部是向左边分支，如果我们有一种方法，能够不受插入数据的影响，让生成的树都像完全二叉树那样，那么即使在最坏情况下，查找的效率
初识二叉搜索树
玄鸟轩墨的博客
07-30 803
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树可以这么说,一般二叉搜索树的中树节点里面的值是不相等的,当然我们也可以存放相等的,那么就变成的另外的一棵树了,这是在后面谈的....
平衡二叉树的构造c语言,数据结构之---C语言实现平衡二叉树（AVL树）
06-02
AVL树是一种自平衡的二叉搜索树，它的高度始终保持在O(log n)。 下面是C语言实现平衡二叉树（AVL树）的代码： ``` #include #include /* 定义平衡二叉树节点结构体 */ struct AVLNode { int data; // 存储的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值