算法导论练习12.1

最新推荐文章于 2024-06-03 11:36:18 发布

007havegone

最新推荐文章于 2024-06-03 11:36:18 发布

阅读量786

点赞数

CC 4.0 BY-SA版权

分类专栏：算法导论数据结构二叉树算法导论文章标签：算法导论 BST 二叉搜索树

本文链接：https://blog.youkuaiyun.com/qq_40512922/article/details/98905507

算法导论同时被 3 个专栏收录

16 篇文章

订阅专栏

算法导论

15 篇文章

订阅专栏

数据结构

8 篇文章

订阅专栏

本文详细解析了基于给定关键字集构建不同高度的二叉搜索树的方法，并探讨了二叉搜索树与最小堆的性质差异。此外，还提供了在Θ(n)时间内完成先序、中序和后序遍历的非递归算法实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

12.1-1 对于关键字集合 ${1,4,5,10,16,17,21\}$ ，分别画出高度为2、3、4、5和6的二叉搜索树。

这里说明一下：算法导论中定义的高度是根节点到叶节点的最大距离

高度为2：      高度为3：                高度为4：
    10              10                      5
   /  \            /  \                    /  \
  4    17         4   16                  4    10
 / \   /\        / \   \                 /      \
1   5 16 21     1   5   17              1        16
                         \                         \
                          21                        17
                                                     \
                                                      21
高度为5：           高度为6：
    4                       1
   / \                       \
  1   5                       4
       \                       \
        10                      5
         \                       \
          16                      10
           \                        \
            17                       16
             \                         \
              21                        17 
                                          \
                                           21

12.1-2 二叉搜索树的性质与最小堆性质之间有什么不同？能使用最小堆性质在 $O (n)$ 时间内按序输出一颗n个结点树的关键字吗？可以的话，说明如何做，否则解释理由。

最小堆是一棵近似的完全二叉树(Perfect Binary Tree),满足堆中每个结点小于等于子结点。但是左右孩子之间的没有确定的大小关系。要想按序输出最小堆，需要使用堆排序的时间复杂度为 $\Omega(nlgn)$ 。

12.1-3 设计一个执行中序遍历的非递归算法。（提示：一个容易的方法是使用栈作为辅助数组结构；另一种较复杂但比较简介的做法是不使用栈，但要假设能测试两个指针是否相等）。

这个问题和算法导论练习10.4-3和10.4-5的题目一致。我在另外一篇博客已经讲过，大家可以看下。
算法导论10.4-5题解

12.1-4 对于一棵有n个结点的树，请设计在 $\Theta(n)$ 时间内完成的先序遍历算法和后序遍历算法。

下面是我的实现代码，分别给出了先序和后序遍历的递归和非递归实现。

#include<iostream>
#include<stack>
#define NIL -1
using namespace std;

struct Tree
{
	Tree *left;
	Tree *right;
	int key;
};
//创建二叉树
void createTree(Tree *&t)
{
    int key;
    cin >> key;
    if(key==NIL){
        t=nullptr;
        return;
    }
    t=new Tree();
    t->key=key;
    createTree(t->left);
    createTree(t->right);
}
void print(const Tree* x)
{
    cout << x->key << " ";
}
void preOrder_recursion(Tree* x)
{
    if(x)
    {
        print(x);
        preOrder_recursion(x->left);
        preOrder_recursion(x->right);
    }
}
void preOrder_byStack(Tree *x)
{
    stack<Tree*> sta;
    Tree *p=x;
    while(p||!sta.empty())
    {
    while(p)
    {
        print(p);
        sta.push(p);
        p=p->left;
    }
    p=sta.top();
    sta.pop();
    p=p->right;
    }
}
void postOrder_recursion(Tree *x)
{
    if(x)
    {
        postOrder_recursion(x->left);
        postOrder_recursion(x->right);
        print(x);
    }
}
void postOrder_byStack(Tree *x)
{
    Tree *pre=nullptr;
    stack<Tree*> sta;
    while(x||!sta.empty())
    {
        while(x)//达到左子树
        {
            sta.push(x);
            x=x->left;
        }
        x=sta.top();
        //没有右子树或右子树已访问
        if(!x->right||x->right==pre){
            sta.pop();
            print(x);
            pre=x;
            x=nullptr;
        }
        else
        {
            x=x->right;
        }
    }
}
int main()
{
    Tree *head;
    createTree(head);
    cout << "先序遍历递归版:\n";
    preOrder_recursion(head);
    cout << "\n先序遍历非递归版:\n";
    preOrder_byStack(head);
    cout << "\n后序遍历递归版:\n";    
    postOrder_recursion(head);
    cout << "\n后序遍历非递归版:\n";        
    postOrder_byStack(head);
}