设二叉排序树中有n个结点,则在二叉排序树的平均查找长度为

已知一棵二叉排序树上所有关键字中的最小值为-max,最大值为max,又-max

骑龟去看大海龟1年前1

风吹yy 共回答了14个问题 | 采纳率64.3%

int search(char a[],char b[],char x[],BiTree T,BiTree p)
{
if(T!=NULL) p=T;
if(strcmp(x,T->lchild->data.key)==0)
{
if(mark) {b=T->data.key;return 0;}
mark=1;
a=p->data.key;
}
else
{
if(search(a,b,x,T,p))
if(search(a,b,x,T->rchild,p))
return OK;
}
}
还有点问题 自己再看看吧 我烦了

1年前查看全部

已知下面二叉排序树的各结点的值依次为1－9,请标出各结点的值

已知下面二叉排序树的各结点的值依次为1－9,请标出各结点的值

最好能有过程

watter12341年前1

keming110 共回答了17个问题 | 采纳率88.2%

1、二叉排序树的定义就是左边的子树都比根小,右边的子树都比根大,所以此图的根（也就是最上面这个肯定是5,左边的肯定是1-4,右边的肯定是6-92、先看左子树的根.它只有右子树,根据定义,所有的都要比它大,从1-4里面可以...

1年前查看全部

4.二叉树为二叉排序树的充分必要条件是其任一节点的值均大于其左孩子的值,小于右孩子的值.

4.二叉树为二叉排序树的充分必要条件是其任一节点的值均大于其左孩子的值,小于右孩子的值.
数据结构判断题

喝汤好不好1年前1

亲亲青苹果 共回答了16个问题 | 采纳率81.3%

错误,5
/
3 6
/
8 2
这棵二叉树满足其任一节点的值均大于其左孩子的值,小于右孩子的值,但它并不是二叉排序树,因为在右支路中有25不满足二叉排序树的性质.

1年前查看全部

已知关键码序列为30,15,8,43,25,49,20,13,28,46,55,10,请画出此序列对应的二叉排序树?

cmjsdfjsadkfiopu1年前1

新鲜独舞 共回答了17个问题 | 采纳率88.2%

30
15 43
8 25 49
13 20 28 46 55
10
30下面左15右43
15下面左8右25
43下面右49
8下面右13
25下面左20右28
49下面左46右55
13下面左10

1年前查看全部

依次输入序列(23,15,9,17,26,18,24),请构造一个二叉排序树,并画出构造过程

buupii1年前1

吉林一止 共回答了21个问题 | 采纳率100%

1、23为根结点
2、1523,24

1年前查看全部

请问这个二叉排序树怎么画设记录关键字集合：Key={66，93，72，8，15，16，66，90，38，18，85 }，

请问这个二叉排序树怎么画
设记录关键字集合：Key={66，93，72，8，15，16，66，90，38，18，85 }，画出它的二叉排序树

agbexlap1年前1

兜兜梨10号 共回答了15个问题 | 采纳率86.7%

66为根节点，做插入操作。大的在右边，小的在左边，逐一比较。如：66作为根节点 插入93，93大于66，所以93为66的右子节点；插入72，,72大于66,插右边跟93比较，72小于93，所以72为93的左子节点。以此类推，有重复的不插入。

1年前查看全部

关于二叉排序树查找的问题?8.在含有27个结点的二叉排序树上,查找关键字为35的结点,则依次比较的关键字有可能是 A.2

关于二叉排序树查找的问题?
8.在含有27个结点的二叉排序树上,查找关键字为35的结点,则依次比较的关键字有可能是 A.28,36,18,46,35 B.18,36,28,46,35 C.46,28,18,36,35 D.46,36,18,28,35请哥哥姐姐给说下解析方法,我好笨.

liouxiaomi1年前1

风_起_云_涌 共回答了13个问题 | 采纳率92.3%

A选项的查找比较路径是这样的
28

36
/
18

46
/
35
该选项,若说它是升序排序树,18在右子树上,若说是降序排序树,则显然不是.
B选项的查找比较路径是这样的
18

36
/
28

46
/
35
这里看的是以36为根的子树,弃选它道理同上.36的右左子树上既有28,又有46、35.
C选项的查找比较路径是这样的
48
/
28
/
18

36
/
35
则以28为根的子树,它的左子树上既有18又有36、35.所以弃选.
选项D的查找比较路径如下
46
/
36
/
18

28

35
完全符合条件,所以正确选项是D.

1年前查看全部

数据结构题目（元素插入生成二叉排序树）

数据结构题目（元素插入生成二叉排序树）
已知一组元素为（34,76,45,18,26,54,92,65）,试画出按元素排列次序插入生成的一棵二叉排序树.（答案如图,为什么是这样这,插入生成的过程是什么?）

℅幽海深蓝1年前1

小女子4 共回答了25个问题 | 采纳率84%

根据二叉排序树的性质：
（1）若左子树不空,则左子树上所有结点的值均小于它的根结点的值；
（2）若右子树不空,则右子树上所有结点的值均大于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
第一步：34为根节点；76>34 故为其右子树的根节点；1834 故肯定在其右子树上,与右子树的根节点 76比较,可知应为76的左儿子；
按第二步插入18、26、54、92、65
明白了没有

1年前查看全部

数据结构问题 急求依次将以下关键字{50，17，10，80，70，40，90，60 }插入到初始状态为空的二叉排序树中，

数据结构问题 急求
依次将以下关键字{50，17，10，80，70，40，90，60 }插入到初始状态为空的二叉排序树中，请画出该树，并求在等概率的情况下查找成功的平均查找长度

foresee04251年前1

kang777 共回答了15个问题 | 采纳率80%

50
/
17 80
/ /
10 40 70 90
/
60
查找成功的平均查找长度=(1*1+2*2+4*3+1*4)/8=2.625

1年前查看全部

32．对给定的数列R＝{7,16,4,8,20,9,6,18,5},构造一棵二叉排序树,并且 （1）给出按中序遍历得到

32．对给定的数列R＝{7,16,4,8,20,9,6,18,5},构造一棵二叉排序树,并且 （1）给出按中序遍历得到
建立的查找二叉树的结果唯一吗
是不是只要符合左孩子小又孩子大就行
中序遍历结果唯一吗

非草1年前1

tiandejian 共回答了19个问题 | 采纳率89.5%

1、给定初始数列构造二叉排序树结果唯一,但是构造完后对已有元素反复执行插入删除操作,二叉排序树的形状就不唯一了
2、中序遍历结果唯一,因为二叉排序树中序遍历后得到的是一个从小到大排列的有序序列

1年前查看全部

已知关键字序列为{45,28,67,33,29,50},二叉排序树初始为空,要求：

已知关键字序列为{45,28,67,33,29,50},二叉排序树初始为空,要求：
（A） 画出按正向（从关键字45开始）顺序插入结点建立的二叉排序树.
（B） 画出按反向（从关键字50开始）顺序插入结点建立的二叉排序树

我的漂亮cc1年前1

斯科达速派 共回答了20个问题 | 采纳率100%

(A)
45
28 67
33 50
29
(B)
50
29 67
28 33
45

1年前查看全部

二叉排序树。用二叉链表作存储结构。（8

二叉排序树。用二叉链表作存储结构。（8
要求：
(1)以回车('n')为输入结束标志,输入数列L，生成一棵二叉排序树T；
(2)对二叉排序树T作中序遍历，输出结果；
(3)计算二叉排序树T查找成功的平均查找长度,输出结果；
(4)输入元素x,查找二叉排序树T,若存在含x的结点,则删除该结点,并作中序遍历(执行操作2)；否则输出信息“无x”。

fiyour1年前1

saly8 共回答了19个问题 | 采纳率89.5%

这是我前几天写的，看了下应该可以满足要求，由于测试还不够，不知道有没有bug。
第一点你自己改改，2、3都达到了，至于第四，不用说肯定是平衡了的二叉树相对查找效率要高一些，平衡，随机插入，打乱插入等操作都是为了防止最差情况的线性树的出现。测试的话用rand()生成随机数外加time.h里的几个函数，配合使用下就出来了。
#include
#include
// binary search tree
typedef struct BST
{
int data;
struct BST* lhs;
struct BST* rhs;
}BST;
// 插入一个节点
BST* BSTInsertNode(BST* root, int elem)
{
BST* node;
node = (BST*)malloc(sizeof(BST));
node->data = elem;
node->lhs = node->rhs = 0;

if(!root)
return node;

while(1)
{
if(node->data < root->data)
{
if(root->lhs)
root = root->lhs;
else
{
root->lhs = node;
return root->lhs;
}
}
else
{
if(root->rhs)
root = root->rhs;
else
{
root->rhs = node;
return root->rhs;
}
}
}
}
// 获得父节点
BST* BSTGetParentNode(BST* root, BST* node)
{
if(root == node)
return 0;

if(root->lhs && node->data < root->lhs->data)
return BSTGetParentNode(root->lhs, node);
else if(root->rhs && node->data > root->rhs->data)
return BSTGetParentNode(root->rhs, node);
else
return root;
}
// 删除一个节点
BST* BSTDeleteNode(BST* root, BST* node)
{
BST* parent;
BST** whichNode;
BST* temp;

if(root != node)
{

parent = BSTGetParentNode(root, node);
whichNode = parent->lhs == node ? &parent->lhs : &parent->rhs;
}
else
whichNode = &root;
if(!node->lhs && !node->rhs)
*whichNode = 0;
else if(!((node->lhs ? 1 : 0) ^ (node->rhs ? 1 : 0)))
*whichNode = node->lhs ? node->lhs : node->rhs;
else
{
temp = node->rhs;
while(temp->lhs)
temp = temp->lhs;
temp->lhs = node->lhs;
*whichNode = node->rhs;
}
free(node);
return *whichNode;
}
// 删除树
void BSTDeleteTree(BST* node)
{
if(node)
{
BSTDeleteTree(node->lhs);
BSTDeleteTree(node->rhs);
free(node);
}
}
// 建造树，从数组构造
BST* BSTBuildTree(int* beg, int* end)
{
BST* root;

if(beg >= end)
return 0;

root = (BST*)malloc(sizeof(BST));
root->data = *beg++;
root->lhs = root->rhs = 0;

while(beg != end)
BSTInsertNode(root, *beg++);

return root;
}
// 查找节点
BST* BSTSearchNode(BST* root, int elem)
{
if(root)
{
if(elem < root->data)
return BSTSearchNode(root->lhs, elem);
else if(elem > root->data)
return BSTSearchNode(root->rhs, elem);
else
return root;
}
else
return 0;
}
// 获得最小值
BST* BSTGetMinimumNode(BST* root)
{
while(root->lhs)
root = root->lhs;
return root;
}
// 获得最大值
BST* BSTGetMaximumNode(BST* root)
{
while(root->rhs)
root = root->rhs;
return root;
}
// 前序遍历
void BSTPreorderTraverse(BST* node)
{
if(node)
{
printf("%d ", node->data);
BSTPreorderTraverse(node->lhs);
BSTPreorderTraverse(node->rhs);
}
}
// 中序遍历
void BSTInorderTraverse(BST* node)
{
if(node)
{
BSTInorderTraverse(node->lhs);
printf("%d ", node->data);
BSTInorderTraverse(node->rhs);
}
}
// 后序遍历
void BSTPostorderTraverse(BST* node)
{
if(node)
{
BSTPostorderTraverse(node->lhs);
BSTPostorderTraverse(node->rhs);
printf("%d ", node->data);
}
}
// 获得前继值
BST* BSTGetPredecessor(BST* root, BST* node)
{
BST* predecessor;
BST* rightCld;

if(node->lhs)
return BSTGetMaximumNode(node->lhs);

predecessor = rightCld = node;
while((predecessor = BSTGetParentNode(root, predecessor)))
if(predecessor->rhs == rightCld)
return predecessor;
else
rightCld = predecessor;
return 0;
}
// 获得后继值
BST* BSTGetSuccessor(BST* root, BST* node)
{
BST* successor;
BST* leftCld;

if(node->rhs)
return BSTGetMinimumNode(node->rhs);

successor = leftCld = node;
while((successor = BSTGetParentNode(root, successor)))
if(successor->lhs == leftCld)
return successor;
else
leftCld = successor;
return 0;
}
// 获得树高
int BSTGetTreeHeight(BST* root)
{
int l;
int r;
if(root)
{
l = BSTGetTreeHeight(root->lhs);
r = BSTGetTreeHeight(root->rhs);
return 1 + (l > r ? l : r);
}
else
return -1;
}
// 计算子节点数
int BSTGetSubtreeNodeNum(BST* node)
{
if(node)
return BSTGetSubtreeNodeNum(node->lhs)
+ BSTGetSubtreeNodeNum(node->rhs)
+ 1;
else
return 0;
}
// 用于打乱数组，交换
inline void Swap(int* a, int* b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
// 用于打乱数组，qsort的比较用过程
inline int CMP(const void* lhs, const void* rhs)
{
return *(const int*)lhs - *(const int*)rhs;
}
// 数组有序?
int IsOrdered(int* beg, int* end)
{
int attri;
int cmpVal;
if(beg >= end)
return 0;
if(end - beg <= 2)
return 1;

if(*beg < *(beg + 1))
attri = 1;
else
attri = 0;

cmpVal = *beg++;
while(++beg != end)
{
if(attri)
{
if(cmpVal > *beg)
return 0;
}else
{
if(cmpVal < *beg)
return 0;
}
}
return 1;
}
// 高层次打乱数组
void HighlyUnorderArray(int* beg, int* end)
{

int* mid = beg + (end - beg)/2;
int* folk;
if(!IsOrdered(beg, end))
qsort(beg, end - beg, sizeof(int), CMP);

if((mid - beg) & 1)
Swap(beg++, mid);
folk = beg + 2;
while(folk < mid)
{
Swap(beg++, folk++);
Swap(beg++, folk++);
}

folk = mid + 2;
while(folk < end)
{
Swap(folk, folk - 1);
folk += 2;
}
}
// 中序遍历结果输出到数组
void BSTInorderWalkToArray(BST* root, int** p)
{
if(root)
{
BSTInorderWalkToArray(root->lhs, p);
**p = root->data;
(*p)++;
BSTInorderWalkToArray(root->rhs, p);
}
}
// 平衡树，返回平衡好的新树
BST* BSTBalanceTree(BST* root)
{
int size = BSTGetSubtreeNodeNum(root);
int* a = (int*)malloc(sizeof(int) * size);
int* end = a;
BST* balancedTree;

BSTInorderWalkToArray(root, &end);
HighlyUnorderArray(a, end);
balancedTree = BSTBuildTree(a, end);
free(a);
return balancedTree;
}
int main()
{
int a[] = ;
int c[] = ;
BST* bstTree = BSTBuildTree(a, a + sizeof(a)/sizeof(a[0]));

BSTPreorderTraverse(bstTree);
putchar('n');
BSTInorderTraverse(bstTree);
putchar('n');
BSTPostorderTraverse(bstTree);
printf("nn");

BST* balancedTree = BSTBalanceTree(bstTree);
printf("%d %dn", BSTGetTreeHeight(bstTree), BSTGetTreeHeight(balancedTree));
BSTDeleteTree(bstTree);
BSTDeleteTree(balancedTree);
}

1年前查看全部

画出下列二叉树有一组关键值12、6、9、1、15、4、18、14,画出其二叉排序树.

wanghuaigu1年前1

目的明确的zz 共回答了25个问题 | 采纳率96%

12
/
6 15
/ /
1 9 14 18

4
12为总根,比根小的在左,比根大的在右

1年前查看全部

从空树起,依次插入关键字37,50,42,18,48,12,56,30,23,构造一棵二叉排序树.

从空树起,依次插入关键字37,50,42,18,48,12,56,30,23,构造一棵二叉排序树.
（1）画出该二叉排序树；
（2）画出从（1）所得树中删除关键字为37的结点之后的二叉排序树.

numberchenbo1年前1

美丽心情2003 共回答了28个问题 | 采纳率85.7%

（1）结果是
37
/
1850
/ /
1230 4256
/45
(2)
23
/
1850
/ /
1230 4256
48

1年前查看全部

关于二叉查找树二叉树为二叉排序树的充分必要条件是其任一结点的值均大于其左孩子的值、小于其右孩子的值.这句话为什么是错的

泛舟戏子1年前1

lzhua0906 共回答了22个问题 | 采纳率86.4%

没有考虑等的情况...

1年前查看全部

数据结构 填空题目 二叉排序树的平均查找长度

数据结构 填空题目 二叉排序树的平均查找长度
设一组初始记录关键字序列为(20,12,42,31,18,14,28),则根据这些记录关键字构造的二叉排序树的平均查找长度 具体过程是怎么样的不会啊

三江_ww1年前1

lnqbbx 共回答了21个问题 | 采纳率90.5%

先构造二叉排序树,然后计算就行了:
（2×3+2×2+2）/7=1.7

1年前查看全部

已知序列 18,11,17,7,5,13,41,29,37,23,19.请画出相应的二叉排序树并写出该树的前序、中序和后

已知序列 18,11,17,7,5,13,41,29,37,23,19.请画出相应的二叉排序树并写出该树的前序、中序和后序序列.
如何根据序列画树,不要结果

20050606061年前0

共回答了个问题 | 采纳率

查看全部

（1）设有一个整数序列{50,38,16,82,110,13,64},依次取出数列中的数,构造一颗二叉排序树.（2）

（1）设有一个整数序列{50,38,16,82,110,13,64},依次取出数列中的数,构造一颗二叉排序树.（2）
利用上述二叉排序树,为了查找110,经多少次元素间的比较能成功查到,为了查找15,经多少次元素间的比较可知道查找失败?

g600045521年前1

gzhzw 共回答了22个问题 | 采纳率100%

首先,二叉排序树是具有下列性质的二叉树：
（1）若左子树不空,则左子树上所有结点的值均小于它的根结点的值；
（2）若右子树不空,则右子树上所有结点的值均大于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
据此,可知该二叉树为：
50
╱ ╲
38 82
╱ ╱ ╲
16 64 110
╱
13
若查找110,则首先与根节点比较,110大于根节点50,判断110存在于二叉树的右子树.依次向下比较寻找,共经过3次比较,可查找到110；
同理,经过4次比较,可知查找失败.

1年前查看全部

数据结构与算法选择题!1.在最坏的情况下,查找成功时二叉排序树的平均查找长度（）A.无法与顺序表的平均查找长度比较B.大

数据结构与算法选择题!
1.在最坏的情况下,查找成功时二叉排序树的平均查找长度（）
A.无法与顺序表的平均查找长度比较
B.大于顺序表的平均查找长度
C.小于顺序表的平均查找长度
D.与顺序表的平均查找
2.弱线性表次啊用链式存储结构,则使用的查找方式（）
A.随机查找
B.散列查找
C.二分查找
D.顺序查找长度相同
第一题是选择C吗?能不能说说理由啊?我不太确定,但是感觉是D啊,不是在最坏的情况下不是退化成顺序表吗?就是只有一侧子树的那种!所以是不是应该是D啊?
第二题我打错了,最后一个选项是顺序查找,没有后面那几个字.

londonfog_wxg1年前1

qczxy 共回答了21个问题 | 采纳率90.5%

1.C
2.D

1年前查看全部

数据结构 二叉排序树的概念问题判断题：二叉树为二叉排序树的充分必要条件是：其任一结点的值均大于其左孩子的值、小于其右孩子

数据结构 二叉排序树的概念问题
判断题：
二叉树为二叉排序树的充分必要条件是：其任一结点的值均大于其左孩子的值、小于其右孩子的值.
为什么说这是错误的?
可以解释得再清楚一点么?
你们说得我越来越糊涂了!可以打个简单的比方么

goblin50007771年前1

windys521 共回答了18个问题 | 采纳率94.4%

二叉排序树（Binary Sort Tree）又称二叉查找树.它或者是一棵空树；或者是具有下列性质的二叉树：（1）若左子树不空,则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空,则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树

1年前查看全部

有关二叉排序树和结点的问题题目是这样的：由4个结点可以构造出多少种不同的二叉排序树?答案是14.我想问这是怎么算出来的,

有关二叉排序树和结点的问题
题目是这样的：由4个结点可以构造出多少种不同的二叉排序树?
答案是14.
我想问这是怎么算出来的,还有有没有通法或者公式来解决类似问题?谢谢!

b247191年前1

狂拽狂玩 共回答了15个问题 | 采纳率86.7%

catalan数 可以去查一下 很多组合数学的问题都与此相关 括号匹配 进出栈 多边形划分为三角形等问题

1年前查看全部

结点数目为 n 的二叉查找树(二叉排序树)的最大高度为______.

结点数目为 n 的二叉查找树(二叉排序树)的最大高度为______.
结点数目为 n 的二叉查找树（二叉排序树）的最大高度为______.
n/2
[log2 (n+1)]
n
[log2 n]

zxp881年前1

liujitao2 共回答了17个问题 | 采纳率94.1%

log2(n+1)

1年前查看全部

数据结构重点问题 关于二叉排序树的 已知一组数据为 37 80 29 46 25 78 62 1

数据结构重点问题 关于二叉排序树的 已知一组数据为 37 80 29 46 25 78 62 1
数据结构重点问题 关于二叉排序树的 已知一组数据为 37 80 29 46 25 78 62 12画出按元素排列生成的二叉排序树～

风清月明ks1年前1

宋春 共回答了14个问题 | 采纳率100%

不知道你要的是不是这个,左边数据小,右边数据大

1年前查看全部

100.120.110.130.80.60.90.构造二叉排序树

小娘子yl1年前1

清溪生_aa 共回答了17个问题 | 采纳率88.2%

构造二叉排序树时遵照定义即可：
（1）若左子树不空,则左子树上所有结点的值均小于它的根结点的值；
（2）若右子树不空,则右子树上所有结点的值均大于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
则该树应为
100
╱ ╲
80 120
╱ ╲ ╱ ╲
60 90 110 130

1年前查看全部

序列(11,56,4,13,7,12,18)如何构造二叉排序树,并平均查找长ASL

dchsh_20021年前1

ymyy3812 共回答了14个问题 | 采纳率85.7%

二叉排序树为
11
/
4 56
/
7 13
/
12 18
ASL=(1+2*2+3*2+4*2)/7≈2.714

1年前查看全部

由空树起,依次插入关键字25,24,21,47,15,68构成一棵平衡二叉排序树.应该怎么画呢

晓菲凌乱1年前1

seeksumm 共回答了13个问题 | 采纳率92.3%

结果是：25
/
24 47
/ /
15 21 68
This is it !

1年前查看全部

用序列(41,83,40,34,65,53,96,5,61,29)建立一个二叉排序树,画出该树,并求在等概率

用序列(41,83,40,34,65,53,96,5,61,29)建立一个二叉排序树,画出该树,并求在等概率
情况下查找成功的平均长度

woshinidebei1年前0

共回答了个问题 | 采纳率

查看全部

46,88,45,39,70,58,101,10,66,34.建立一个二叉排序树,画出该二叉树,并求在相等概率下查找的平

46,88,45,39,70,58,101,10,66,34.建立一个二叉排序树,画出该二叉树,并求在相等概率下查找的平均长度.
要求有图和步骤,好的话加分10

lyq5681年前3

老百aa 共回答了19个问题 | 采纳率84.2%

（1*1+2*2+3*3+4*2+5*2）/10=3.2

1年前查看全部

数据结构：在一棵空的二叉查找树中依次插入关键字序列为54,18,66,87,36,12 请画出所得到的二叉排序树

pp822296301年前1

dalong668 共回答了15个问题 | 采纳率93.3%

54
/
18 66
/
12 36 87

1年前查看全部

设一组初始记录关键字序列为(20,12,42,31,18,14,28),则根据这些记录关键字构造的二叉排序树的平均查找长

设一组初始记录关键字序列为(20,12,42,31,18,14,28),则根据这些记录关键字构造的二叉排序树的平均查找长度是

wangang25851年前1

赌煞 共回答了19个问题 | 采纳率89.5%

平均查找长度是19/7

1年前查看全部

数据结构题 麻烦大神帮忙下设数据集合 D={10，12，4，8，14，6}。（1）依次取 D 各数据，构造一棵二叉排序树

数据结构题 麻烦大神帮忙下
设数据集合 D={10，12，4，8，14，6}。（1）依次取 D 各数据，构造一棵二叉排序树；（2）画出在二叉树中删除“10”后的树结构。
麻烦截图给我看下 谢谢

香肥皂芳芳1年前0

共回答了个问题 | 采纳率

查看全部

设有一组关键字序列(34,76,45,18,26,54,92),则由这组记录关键字生成的二叉排序树的深度为（）

设有一组关键字序列(34,76,45,18,26,54,92),则由这组记录关键字生成的二叉排序树的深度为（）
5,6,7,选哪个,

coldfish1年前1

wkygcj 共回答了16个问题 | 采纳率93.8%

二叉排序树的生成方法你要先了解,简单的说,最基本就是：
1,第一个关键字做根结点.
2,每个关键字都与根结点比较,如果小于根结点,就插入到左子树,否则插入到右子树.
以序列（(34,76,45,18,26,54,92）为例：
34
/
18 76
/
26 45 92

54
深度为：4.

1年前查看全部

对给定的数列R={7,16,4,8,20,9,6,18,5},构造一棵二叉排序树,并且：（1）给出按中序遍历得到的数列R

对给定的数列R={7,16,4,8,20,9,6,18,5},构造一棵二叉排序树,并且：（1）给出按中序遍历得到的数列R1；（
对给定的数列R={7,16,4,8,20,9,6,18,5}，构造一棵二叉排序树，并且：（1）给出按中序遍历得到的数列R1；（2）给出按后序遍历到得数列R2；

yanqipingsha1年前4

squallnini 共回答了19个问题 | 采纳率84.2%

7
4 16
6 8 20
5 9 18
中序遍历为4,5,6,7,2,9,16,18,20

1年前查看全部

设有一组初始记录关键字为（45、80、48、40、22、78,要求构造一棵二叉排序树并给出构造过程?

浪子791年前0

共回答了个问题 | 采纳率

查看全部

3、依次输入表（30,15,28,20,24,10,12,68,35,50,46,55）中的元素,生成一棵二叉排序树.（

3、依次输入表（30,15,28,20,24,10,12,68,35,50,46,55）中的元素,生成一棵二叉排序树.（18分
(1)试画出生成之后的二叉排序树；
(2)若该二叉排序树作中序遍历,试写出遍历序列；
(3)若删除元素28,请画出删除该结点后的二叉排序树图.

speak171年前1

york4 共回答了18个问题 | 采纳率88.9%

只需记住：第一个元素是根,以后所有的都和这个根做比较,小的在左,大的在右.如果位子上有元素占住了,就和这个占住位置的元素比大小,小的在左,大的在右.如此循环就ok了.
以题目为例：
1、根30
2、插入15,比30小,所以在左子叶
------------30-------
-----------/----------
---------15-----------
3、插入28,比30小,所以在左子叶,但左子叶已有元素15了,那就继续和15比,比15大,长在其右子叶：
------------30-------
-----------/----------
---------15----------
-------/--------------
------------28-------
4、插入20,如第三步所属,比30小,比15大,比28小,所以是28 的左子叶
------------30-------
-----------/----------
---------15----------
-------/--------------
------------28-------
-----------/----------
---------20-----------
5、重复以上过程一直到最后.

1年前查看全部

依次插入关键字37,50,42,18,48,12,56,30,23,构造一棵二叉排序树,并计算平均查找长度

ryyx3001年前1

车来车往之后 共回答了19个问题 | 采纳率89.5%

37是根 18是37的左孩子 50是37的右孩子
12是18的左孩子 30是18的右孩子
23是30的左孩子
42是50的左孩子
56是50的右孩子
48是42的右孩子 平均查找长度是 1+2+2+3+3+3+3+4+4/9=

1年前查看全部

设K1,K2,K3是三个不同的关键字且K1>K2>K3,请画出按不同的输入顺序建立相应的二叉排序树.

笑看蝶舞清秋1年前1

欧阳谬论 共回答了11个问题 | 采纳率100%

K1, K2, K3：
　　　　K1
　　　╱
　　K2
　╱
K3

K1, K3, K2：
　　　　K1
　　　╱
　　K3
　　　╲
　　　　K2

K2, K1, K3和K2, K3, K1：
　　K2
　╱　╲
K3　　　K1

K3, K2, K1：
K3
　╲
　　K2
　　　╲
　　　　K1

K3, K1, K2：
K3
　╲
　　K1
　╱
K2

1年前查看全部

1.设有序列（45、24、53、12、28、90）,请构成一棵二叉排序树,并求其查找成功时的平均查找长度.

6707249471年前1

琼ee 共回答了20个问题 | 采纳率95%

.45
24 53
12 28 90
平均时间=1/6(1+2*2+3*3)=7/3

1年前查看全部

统计二叉排序树中值小于X的结点个数

jaforce1年前1

cfelj 共回答了15个问题 | 采纳率86.7%

具体思想应该是递归思想,大概这样
int count(BinTree *T)
{
if(T == NULL)
return 0;
return count(T->left) + count(T->right) + 1;
}
然后如果你是用左儿子表示小于根的节点的话,小于X的节点数就是count(T->left)

1年前查看全部

向具有n个结点的、结构均衡的二叉排序树中插入一个元素的时间复杂度大致为( ).

sonjack1年前1

小几虫 共回答了20个问题 | 采纳率90%

O(log2n )

1年前查看全部

将整数序列{4,5,7,2,1,3,6}中的数依此插入到一棵空的二叉排序树中，试构造相应的二叉排序树，要求用图形给出构造

将整数序列{4,5,7,2,1,3,6}中的数依此插入到一棵空的二叉排序树中，试构造相应的二叉排序树，要求用图形给出构造过程，不需编写程序

孤单魔羯051年前1

PS2-NGC-XBOX 共回答了16个问题 | 采纳率93.8%

7505535棵

1年前查看全部

定表(40,36,55,6,64,77,9,41),按数据元素在表中的次序构造一颗二叉排序树,并求其平均查找长度.

吻风之蝶1年前1

yunla530 共回答了18个问题 | 采纳率83.3%

.45 24 53 12 28 90 平均时间=1/6(1+2*2+3*3)=7/3

1年前查看全部

把序列{15,20,15,7,9,18,6}构造成对应的二叉排序树

天平上睡着的砝码1年前1

Cuiflower 共回答了14个问题 | 采纳率100%

晕哦.如果没有错的话.应该是这样的.
15
15 20
7 18
6 9
好久没有看了哦.

1年前查看全部

N个结点能构成多少种二叉排序树．例如4个结点有14种

安娜有心1年前1

去翁 共回答了14个问题 | 采纳率92.9%

你的问题实际上就是N结点能构成多少种二叉树（一般二叉排序树的可能形态数和二叉树一样）.答案是C(2n, n)/(n+1)种.
详情请查询Catalan数相关内容.

1年前查看全部

具有m个结点的二叉排序树,其最大深度为?

hao25811年前3

饭饭_饭饭 共回答了25个问题 | 采纳率100%

具有m个结点的二叉排序树,其深度取决于给定集合的初始排列顺序,最好情况下,其深度为 ,最坏情况下,其深度为m

1年前查看全部

请问怎么用结点来计算二叉排序树的个数?

请问怎么用结点来计算二叉排序树的个数?
比如给四个结点abcd,应该怎么计算呢?

kuenge3311年前1

frade 共回答了16个问题 | 采纳率75%

对于任一给定的节点序列,只有一个二叉排序树
因为二叉排序树总是以第一个节点为根节点,将以后的节点按顺序添加到树里面的
如果非要计算有多少个不同的二叉排序树,那么只需计算给定的节点有多少种排列就可以了
如果给定n个点,并且值各不相同,那么就有n!种排列了.
///////////////////////
汗!上面写错了

1年前查看全部

序列{ 45, 36, 56, 6, 64, 78,8,96 }, 如何建立二叉排序树?

序列{ 45, 36, 56, 6, 64, 78,8,96 }, 如何建立二叉排序树?
请用图形表示，谢谢！

99997m1年前2

白云深处之风 共回答了8个问题 | 采纳率100%

对每个节点的子节点 小的放左面,大的放右面
比如放8的时候,与根节点45比,小,所以应该在45的左子树里,看45的左孩子36,现在把36当成“根节点”,8比它小,再看36的左子树,6成了36左子树的“根节点”,8比它大,所以8放在6的右边.
45
45
/
36
45
/
36 56
45
/
36 56
/
6
45
/
36 56
/
6 64
45
/
36 56
/
6 64

78
45
/
36 56
/
6 64

8 78
45
/
36 56
/
6 64

8 78

96

1年前查看全部

数据结构综合应用题,已知一个长度为5的线性表（20,60,30,10,15）.按该线性表中元素的顺序构造出一棵二叉排序树

数据结构综合应用题,
已知一个长度为5的线性表（20,60,30,10,15）.
按该线性表中元素的顺序构造出一棵二叉排序树
若每个元素的查找概率均等,查找此二叉排序树中任意一个结点的查找成功的平均查找长度ASL是多少?查找不成功的平均查找长度是多少?
若对线性表的元素按字典顺序从小到大排列以后,再用折半查找方法,则查找其中任意一个元素的平均查找长度ASL是多少?

xgsmcy1年前1

爱睡觉的郎郎 共回答了11个问题 | 采纳率100%

(1)2.211/3(2)2.2

1年前查看全部

一组元素（50,28,9,18,75,82,68,49,80）画出上述顺序输入生成的一棵二叉排序树，该树是否是平衡二叉树

一组元素（50,28,9,18,75,82,68,49,80）画出上述顺序输入生成的一棵二叉排序树，该树是否是平衡二叉树。

kunui20031年前0

共回答了个问题 | 采纳率

查看全部