CLRS 12.4随机构建二叉搜索树

最新推荐文章于 2024-01-01 11:50:32 发布
最新推荐文章于 2024-01-01 11:50:32 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： 算法导论 文章标签： clrs 随机 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012593447/article/details/50453822
版权

12.4-1
证明前先需要知道有 (44)=(33) 以及附录 C 的练习 C.1-7 需要证明的等式 (nk)=(n−1k)+(n−1k−1)
先证明附录 C 的练习 C.1-7

(n−1k)+(n−1k−1)=(n−1)!k!(n−1−k)!+(n−1)!(k−1)!(n−1−k+1)!=(n−1−k+1)(n−1)!k!(n−1−k+1)!+k(n−1)!k!(n−1−k+1)!=(n−1−k+1+k)(n−1)!k!(n−1−k+1)!=n!k!(n−k)!=(nk)

然后有：
∑i=0n−1(i+33)=(44)+∑i=1n−1(i+33)=(44)+(43)+(53)+⋯+(n+23)=(54)+(53)+⋯+(n+23)=(n+34)

12.4-2
首先给出第二个问题的答案，即渐进上界 O(nlgn−−−−−√) 。证明略，可以参考算法导论指导手册上此题的证明。
下面给出一个例子， n 个结点的平均深度 Θ(lgn) 但高度是 ω(lgn) 。其中 n−nlgn−−−−−√ 个结点是完全二叉树，剩下的是一条单链，高度为：
Θ(lg(n−nlgn−−−−−√))+nlgn−−−−−√=Θ(nlgn−−−−−√)=ω(lgn)
这里写图片描述
对此例的平均深度证明是 Θ(lgn) 同样略过。

12.4-3
先给出 n=3 构建出来的全部二叉搜索树。
这里写图片描述
从左到右依次编号为 1,2,3,4,5 ：
1;2;3 对应图1；
1;3;2 对应图2；
2;1;3 和 2;3;1 对应图3；
3;2;1 对应图4；
3;1;2 对应图5。
因此图3被创建的概率是 2/6 ，其余的是 1/6 。而随机构建二叉搜索树都是 1/5 。

12.4-4
在书的附录里面有凸函数的定义（见中文版第三版的P701或英文版的P1199），然后国外的语意和国内相反，所以我们是要证明 f(x)=2x 是凹函数。
证明：根据凹函数定义：对于任意 x,y,λ∈(0,1) ，有 λ2x+(1−λ)2y≥2(λx+(1−λ)y) ……①
这里有个重要不等式，即对于任意 a,b,c 都有 ca≥cb+(a−b)(cb)lnc 。在这简单证明一下，根据 ex≥1+x 有：设 x=(a−b)lnc 带入 e((a−b)lnc)≥1+(a−b)lnc 即 c(a−b)≥1+(a−b)lnc 两边都乘以 cb 即得证。
这样用 2 代替 c,x 代替 a,z 代替 b ，其中 z=λx+(1−λ)y
带入并化解得： 2x≥2z+(x−z)(2z) ….②同理， a 变 y 其他一样，得 2y≥2z+(y−z)(2z) ….③。
把②和③式带入①式得：

λ2x+(1−λ)2y≥λ(2z+(x−z)(2z))+(1−λ)(2z+(y−z)(2z))=(λ+1−λ)2z+(λ(x−z)+(1−λ)(y−z))(2z)

由于 (λ(x−z)+(1−λ)(y−z))=0 ，所以 λ2x+(1−λ)2y≥2z=2(λx+(1−λ)y) ，得证！

12.4-5
略。



附上本章的一些实现代码

#include <iostream>
#include <stack>
using std::cout;
using std::endl;
using std::stack;

struct BinTree
{
    int key;
    BinTree *parent;
    BinTree *left;
    BinTree *right;
};

void preOrder(BinTree *root)
{
    if(root != NULL)
    {
        cout << root->key << ' ';
        preOrder(root->left);
        preOrder(root->right);
    }
}

void non_recursive_preOrder(BinTree *root)
{
    stack<BinTree *> ptr;
    ptr.push(root);
    while(root != NULL && !ptr.empty())
    {
        BinTree *p = ptr.top();
        cout << p->key << ' ';
        ptr.pop();
        if(p->right != NULL)
            ptr.push(p->right);
        if(p->left != NULL)
            ptr.push(p->left);
    }
}

void inOrder(BinTree *root)
{
    if(root != NULL)
    {
        inOrder(root->left);
        cout << root->key << ' ';
        inOrder(root->right);
    }
}

void non_recursive_inOrder(BinTree *root)
{
    stack<BinTree *> ptr;
    BinTree *p = root;
    while(p != NULL || !ptr.empty())
    {
        while(p != NULL)    //找到最左孩子
        {
            ptr.push(p);
            p = p->left;
        }
        if(!ptr.empty())    //弹出，然后向右
        {
            p = ptr.top();
            ptr.pop();
            cout << p->key << ' ';
            p = p->right;
        }
    }
}

void postOrder(BinTree *root)
{
    if(root != NULL)
    {
        postOrder(root->left);
        postOrder(root->right);
        cout << root->key << ' ';
    }
}

void non_recursive_postOrder(BinTree *root)
{
    stack<BinTree *> ptr;
    BinTree *cur;
    BinTree *pre = NULL;
    ptr.push(root);
    while(!ptr.empty())
    {
        cur = ptr.top();
        //当前结点没孩子或者左（右）孩子已经访问过，则访问当前结点
        if(cur->left == NULL && cur->right == NULL || pre != NULL && (pre == cur->left || pre == cur->right))
        {
            cout << cur->key << ' ';
            ptr.pop();
            pre = cur;
        }
        else
        {
            if(cur->right != NULL)
                ptr.push(cur->right);
            if(cur->left != NULL)
                ptr.push(cur->left);
        }
    }
}

BinTree *TREE_SEARCH(BinTree *root,int value)
{
    if(root == NULL)
        return root;
    if(root->key == value)
        return root;
    if(root->key < value)
        TREE_SEARCH(root->right,value);
    else TREE_SEARCH(root->left,value);
}

BinTree *non_recursive_TREE_SEARCH(BinTree *root,int value)
{
    while(root != NULL && root->key != value)
    {
        if(root->key < value)
            root = root->right;
        else root = root->left;
    }
    return root;
}

BinTree *TREE_MINIMUM(BinTree *root)
{
    if(root == NULL)
        return root;
    if(root->left == NULL)
        return root;
    else return TREE_MINIMUM(root->left);
}

BinTree *non_recursive_TREE_MINIMUM(BinTree *root)
{
    if(root == NULL)
        return root;
    while(root->left != NULL)
        root = root->left;
    return root;
}

BinTree *TREE_MAXIMUM(BinTree *root)
{
    if(root == NULL)
        return root;
    if(root->right == NULL)
        return root;
    else return TREE_MAXIMUM(root->right);
}

BinTree *non_recursive_TREE_MAXIMUM(BinTree *root)
{
    if(root == NULL)
        return root;
    while(root->right != NULL)
        root = root->right;
    return root;
}

BinTree *TREE_SUCCESSOR(BinTree *p)
{
    if(p == NULL)
        return p;
    if(p->right != NULL)
        return TREE_MINIMUM(p->right);
    BinTree *x = p->parent;
    while(x != NULL && p == x->right)
    {
        p = x;
        x = x->parent;
    }
    return x;
}

BinTree *TREE_PREDECESSOR(BinTree *p)
{
    if(p == NULL)
        return p;
    if(p->left != NULL)
        return TREE_MAXIMUM(p->left);
    BinTree *x = p->parent;
    while(x != NULL && p == x->left)
    {
        p = x;
        x = x->parent;
    }
    return x;
}

void TREE_INSERT(BinTree **root,int key)
{
    if(*root == NULL)   //插入根节点
    {
        BinTree *z = new BinTree;
        z->key = key;
        z->left = z->right = NULL;
        *root = z;
        z->parent = NULL;
        return;
    }
    BinTree *x = *root;
    if(x->key > key)    //左子树
    {
        if(x->left == NULL) //左子树为空
        {
            BinTree *z = new BinTree;
            z->key = key;
            z->left = z->right = NULL;
            z->parent = x;
            x->left = z;
        }
        else TREE_INSERT(&(x->left),key);//以左子树为根递归插入
    }
    else        //右子树
    {
        if(x->right == NULL)
        {
            BinTree *z = new BinTree;
            z->key = key;
            z->left = z->right = NULL;
            z->parent = x;
            x->right = z;
        }
        else TREE_INSERT(&(x->right),key);
    }
}

void non_recursive_TREE_INSERT(BinTree **root,int key)
{
    BinTree *z = new BinTree;
    z->key = key;
    z->left = z->right = NULL;
    BinTree *y = NULL;
    BinTree *x = *root;
    while(x != NULL)
    {
        y = x;
        if(x->key < z->key)
            x = x->right;
        else x = x->left;
    }
    z->parent = y;
    if(y == NULL)
        *root = z;
    else if(y->key < z->key)
        y->right = z;
    else y->left = z;
}

void TRANSPLANT(BinTree **root,BinTree *u,BinTree *v)
{
    if(u->parent == NULL)
        *root = v;
    else if(u == u->parent->left)
        u->parent->left = v;
    else u->parent->right = v;
    if(v != NULL)
        v->parent = u->parent;
}

void TREE_DELETE(BinTree **root,int key)
{
    BinTree *p = TREE_SEARCH(*root,key);
    if(p == NULL)
        return;
    if(p->left == NULL)
        TRANSPLANT(root,p,p->right);
    else if(p->right == NULL)
        TRANSPLANT(root,p,p->left);
    else{
        BinTree *y = TREE_MINIMUM(p->right);
        if(y->parent != p)
        {
            TRANSPLANT(root,y,y->right);
            y->right = p->right;
            y->right->parent = y;
        }
        TRANSPLANT(root,p,y);
        y->left = p->left;
        y->left->parent = y;
    }
    delete p;
}

int main()
{
    BinTree *root = NULL;
    int array[] = {8,2,-5,1,77,-6,45,0,5};
    for(int i = 0; i < 5; ++i)
        TREE_INSERT(&root,array[i]);    //创建树
    for(int i = 5; i < 9; ++i)
        non_recursive_TREE_INSERT(&root,array[i]);  //接上继续创建，在这只是为了测试

    //分别用先中后序输出，包括每种顺序的递归和非递归
    cout << "preOrder: ";
    preOrder(root);
    cout << endl;
    cout << "non recursive preOrder: " ;
    non_recursive_preOrder(root);
    cout << endl;
    cout << "inOrder: " ;
    inOrder(root);
    cout << endl;
    cout << "non recursive inOrder: ";
    non_recursive_inOrder(root);
    cout << endl;
    cout << "postOrder: ";
    postOrder(root);
    cout << endl;
    cout << "non recursive postOrder: ";
    non_recursive_postOrder(root);
    cout << endl;

    //查找元素，找到则输出并找到该元素的前驱和后继
    BinTree *p = TREE_SEARCH(root,77);
    if(p != NULL){
        cout << "find " << p->key << endl;
        cout << "it's predecessor and successor: ";
        BinTree *pre = TREE_PREDECESSOR(p);
        if(pre != NULL)
            cout << pre->key << ' ';
        else cout << "NULL" << ' ';
        BinTree *succ = TREE_SUCCESSOR(p);
        if(succ != NULL)
            cout << succ->key << ' ';
        else cout << "NULL" << ' ';
        cout << endl;
    }
    else cout << "can not find in the tree" << endl;
    p = TREE_SEARCH(root,66);
    if(p != NULL){
        cout << "find " << p->key << endl;
        cout << "it's predecessor and successor: ";
        BinTree *pre = TREE_PREDECESSOR(p);
        if(pre != NULL)
            cout << pre->key << ' ';
        else cout << "NULL" << ' ';
        BinTree *succ = TREE_SUCCESSOR(p);
        if(succ != NULL)
            cout << succ->key << ' ';
        else cout << "NULL" << ' ';
        cout << endl;
    }
    else cout << "can not find in the tree" << endl;
    p = TREE_SEARCH(root,8);
    if(p != NULL){
        cout << "find " << p->key << endl;
        cout << "it's predecessor and successor: ";
        BinTree *pre = TREE_PREDECESSOR(p);
        if(pre != NULL)
            cout << pre->key << ' ';
        else cout << "NULL" << ' ';
        BinTree *succ = TREE_SUCCESSOR(p);
        if(succ != NULL)
            cout << succ->key << ' ';
        else cout << "NULL" << ' ';
        cout << endl;
    }
    else cout << "can not find in the tree" << endl;

    //找到树的最小和最大值
    p = TREE_MINIMUM(root);
    if(p != NULL)
        cout << "minimum is: " << p->key << endl;
    p = TREE_MAXIMUM(root);
    if(p != NULL)
        cout << "maximum is: " << p->key << endl;

    //删除操作
    TREE_DELETE(&root,8);
    p = TREE_SEARCH(root,8);
    if(p != NULL){
        cout << "find " << p->key << endl;
        cout << "it's predecessor and successor: ";
        BinTree *pre = TREE_PREDECESSOR(p);
        if(pre != NULL)
            cout << pre->key << ' ';
        else cout << "NULL" << ' ';
        BinTree *succ = TREE_SUCCESSOR(p);
        if(succ != NULL)
            cout << succ->key << ' ';
        else cout << "NULL" << ' ';
        cout << endl;
    }
    else cout << "can not find in the tree" << endl;

    //删除后中序遍历
    inOrder(root);
    cout << endl;
    return 0;
}
昵称怎么会存在
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
clrs 习题答案
08-03
算法導論第三版习题答案
随机构建一棵二叉树
zxc120389574的博客
11-20 2214
·完全二叉树【不带parent指针】 #include <iostream> using namespace std; struct BinaryTreeNode { int m_nValue; BinaryTreeNode* m_pLeft; BinaryTreeNode* m_pRight; }; /*********************************...
[算法][Python]随机生成一棵具有N个节点的二叉树
身披白袍的博客
08-31 1894
查了一圈网上现有的资料，基本都是“天下文章一大抄”或者过时、甚至无法运行的代码，也没有讲明原理，代码质量烂得一比，怒而亲自动手。
强迫症的随机二叉树
if_Riffraff的博客
05-15 955
分享一个生成随机二叉树的小想法 PS：写这篇帖的人患了强迫癌，症状极其严重。 最近学习数据结构写了一些二叉树的算法，但偶尔调试的时候想整一棵随机二叉树来验证，自己建总是觉得随机性不高，所以抱着研究的心态写一个生成随机二叉树的代码，跟大家分享一个想法，有不足的地方，但希望可以帮到一些有需要的朋友。 关于二叉树的概念，网上很多大神的分析都很到位，而且还有动画大神直接图形化的超级带感，这里就不多说了。由于后面要用到节点位置的值，所以这里简单讲一下二叉树位置的一些表示方法： 对于左边的满二叉树而言，根节点位置是1
C随机生成二叉树
最新发布
qq_35753439的博客
01-01 521
该程序代码分别实现了按给定深度和按给定元素个数来生成随机二叉树。但是生成的随机二叉树可能会导致同一棵树上相同结点个数过多。
二叉树实现，随机生成，遍历，求高度，求最后一个节点
qq_41565526的博客
01-24 637
二叉树实现 package data_structure; import java.util.Random; class TreeNode { public int val; public TreeNode LefttreeNode; public TreeNode RighttreeNode; } public class TreeApp { public static int k = 0; static Random random = new Random(
CLRS英文第二版
08-04
CLRS英文第二版 .
CLRS：算法入门第3版中的一些练习和问题
02-02
笔记本摘要我基础1算法在计算中的作用2入门3功能成长4分而治之5概率分析和随机算法II排序和订单统计6堆排序7快速排序8线性时间排序9中位数和订单统计III数据结构10种基本数据结构11哈希表12个二叉搜索树13棵红黑树14...
clrs-mit-THIRD EDITION
06-15
指《算法导论》（Introduction to Algorithms）。 由Thomas H. Cormen，Charles E. Leiserson，Ronald L. Rivest，Clifford Stein编写，MIT出版的一本介绍、分析当代计算机...用四位作者姓的首字母组成的CLRS代表此书。
clrs_prev.rar_CLRS_算法导论 答案_算法导论答案
09-14
算法导论答案 南大学长提供 答案正确率有保证！！！
任何二叉树生成器
06-09
该生成器可以根据用户的要求生成任何用户所需要的类型的二叉树
【算法导论】【随机二叉搜索树】
Lxyking123的博客
01-14 418
我们已经证明了二叉搜索树上的每个基本操作都能在O ( h ) O(h)O(h)时间内完成，其中h hh为这棵树的高度。然而，随着元素的插入和删除，二叉搜索树的高度是变化的。例如，如果n nn个关键字按严格递增的次序被插入，则这棵树一定是高度为n − 1 n-1n−1的一条链。 遗憾的是，当一棵二叉搜索树同时由插入和删除操作生成时，我们对这棵树的平均高度了解的甚少。当树是由插入操作单独生成时，分析就会变得容易得多。因此，我们定义n nn个关键字的一棵随机构建二叉搜索树为按随机次序插入这些关键字到棵初始的空树中
二叉搜索树
github_38730134的博客
06-24 203
二叉搜索树 搜索树结构支撑许多动态集合操作，包括SEARCH、MINIMUM、MAXIMUM、PREDECESSOR、SUCCESSOR、INSERT和DELETE等。使用一颗搜索数既可以作为一个字典 又可以作为一个优先队列 二叉搜索树的基本操作所花费时间与这颗树的高度成正比。对于有n个节点的完全二叉树来说，操作的最坏运行时间为θ(lgn)。但如果这颗树是一条包含n个节点的链表，那操作的最坏运行时间为θ(n) 简介 二叉搜索树是以一个二叉树构建的搜索树。可以使用一条链表数据结构来表示，其中每个节点就是一个对
java随机生成一棵二叉树_随机二叉树(Treap) Java实现
weixin_39531178的博客
02-28 572
importjava.util.ArrayList;importjava.util.LinkedList;importjava.util.List;importjava.util.Random;importjava.util.concurrent.Callable;importjava.util.concurrent.ExecutionException;importjava.util.concu...
随机化二叉搜索树的构造（算法导论）
头号玩家的博客
01-30 1576
说实话，算法导论上讲的那个节点插入算法写得不太专业，虽然让人一看就感觉懂了，但正真实现起来才发现根本不是那回事（当然变换过程是一样的，但不像算法里写的那样用结构体来完成）。经过我自己一本不正经的摸索和大佬们的指点迷津，终于用数组实现了二叉搜索树的构造呵呵哈哈哈~ 交换过程可以参考算法导论以及网易公开课算法导论。 算法描述 不知何为二叉搜索的童鞋请先百科。对于数组A[ ],令A[1]为根节
随机化的二叉搜索树总结（treap,随机输入）
tdscdma123的博客
01-06 2034
看数据结构的时候，书里面说对于随机输入的序列，BST的期望深度是log(n),当时没当一回事（其实是证明看不懂），这两天复习二叉搜索树遇到树堆（treap）又回去翻了一下证明过程，其实还蛮简单的。    总结起来也就一句话：    只要保证BST的任意子树的根节点选取是随机的，那么这颗树的期望深度就必然是log(n). 证明如下：  1.首先要定义一个概念——内部路径长（D（N）），也就是
算法导论12.4随机构建二叉搜索树 练习总结
chan15的博客
10-08 2428
12.4-1 证明等式（12.3）。 ANSWER： 证明：                                                                                             此处将用不寻常的证明方法：引入一个新问题，利用两个不同解法的等效性证明等式（12.3） 12.4-3 说明含有 n 个关键字的随机
数据结构与算法分析生成N节点随机二叉查找树
qq_28161649的博客
11-21 883
/*生成n节点随机二叉查找树，该树具有从1到n的不同关键字*/ #include #include typedef struct Node *Position; typedef struct Node *Tree; Tree makeRandomTree(int lower,int upper); void printTree(Tree T); int RandInt(int i
随机树生成算法（就是树！）
热门推荐
姬小野的博客
04-02 1万+
一个生成随机树（此树非彼数）的算法，树的结点编号从1开始，这个算法生成了树的结点个数、树的结点的权值、树的每条边的结点。 如下面是一棵10结点的二叉树的生成结果： 10 -23 -44 -51 -9 13 51 62 11 -63 19 6 9 6 4 9 2 9 3 4 7 4 1 2 5 2 8 3 10 思路是将结点编号1-n push进vector中，然后随机选一个点为root，并从...
clrs 3rd pdf
10-04
《CLRS算法导论（第三版）》是由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein共同撰写的一本计算机算法教材。这本书是计算机科学领域中最著名的算法教材之一，广泛用于大学的计算机科学和计算机工程专业的教学。 这本书的第三版主要通过对算法的分析和设计原理进行详细讲解，为读者提供了深入理解算法的工具和方法。书中首先介绍了算法的基本概念和分析方法，包括渐进分析、递归和循环不变式等。然后依据算法的应用领域，分章对各类经典算法进行了讲解，包括排序、搜索、图算法等。同时，还对动态规划、贪心算法、随机化算法以及算法的问题复杂性等内容进行了详细讲解。 此外，这本书还涉及了算法领域中的一些高级主题，如线性规划、流网络、字符串匹配等。每一章都以一个综合案例来说明算法的应用和具体实现。此外，书中还提供了丰富的习题和编程项目，以帮助读者巩固所学的知识。 《CLRS算法导论（第三版）》具有严谨的逻辑结构，语言简洁明了，示例丰富具体，讲解深入细致，适合作为计算机算法的入门教材。同时，这本书在全球范围内也广泛应用于算法研究和实践中，被誉为算法领域的圣经。对于计算机科学和计算机工程专业的学生和从业人员来说，它是一本不可或缺的参考书。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值