数据结构中树的计数

Posted 2023-02-15

假设对二叉树的n个结点从1到n加以编号，且令其前序序列为1,2,…,n,则由前面的讨论可知，不同的二叉树所得中序序列不同。如图6.37所示两棵有8个结点的二叉树，它们的前序序列都是12345678，而图f-7(a)所示树的中序序列为32465178，图f-7(b) 所示树的中序序列为23147685。因此，不同形态的二叉树的数目恰好是前序序列均为1,2,…,n的二叉树所能得到的中序序列的数目。

而中序遍历的过程实质上是一个结点进栈和出栈的过程。二叉树的形态确定了其结点进栈和出栈的顺序，也确定了其结点的中序序列。例如图f-8所示为n=3时不同形态的二叉树在中序遍历时栈的状态和访问结点次序的关系。由此可知，由前序序列1,2,…,n所能得到的中序序列的数目恰好为数列1,2,…,n按不同顺序进栈和出栈所能得到的排列的数目。这个数目为
b[n] = (1/(n + 1))*C(2n,n)

请问一下b[n]的具体证明方法，看清楚是从树的遍历这方面证明
请看清楚题目要求，是要树的遍历这方面证明b[n] = (1/(n + 1))*C(2n,n)

参考技术A 界面什么的比较次要，不写了
这里定义了二叉树节点类型以及二叉搜索树类型，并且提供了你所需要的操作的公共接口
已经通过编译，如果运行时有bug再告诉我

struct Binary_Node//定义二叉树节点类型

int key;//关键字
int height;//该节点的高度
int size;//以该节点为根的子树的节点个数
Binary_Node *parent,*left,*right;//亲节点、左子节点、右子节点
Binary_Node(int,Binary_Node*);
~Binary_Node();
;

Binary_Node::Binary_Node(int Key,Binary_Node* p)

key=Key;
if (p==0) height=0;
else height=p->height+1;
parent=p;
left=right=0;
size=1;


Binary_Node::~Binary_Node()

if (left!=0) delete left;
left=0;
if (right!=0) delete right;
right=0;


class Binary_Search_Tree//二叉搜索树类型

private:
Binary_Node *root;//根节点
int leaf_count;//叶节点个数计数器
int height;//高度
void Search_Preorder(Binary_Node*,int*);
void Search_Inorder(Binary_Node*,int*);
void Search_Postorder(Binary_Node*,int*);

public:
Binary_Search_Tree();
~Binary_Search_Tree();
void Build(int,int*);
Binary_Node *Query(int);
int Size();
int Leaves();
int Height();
void Search_Preorder(int&,int*);
void Search_Inorder(int&,int*);
void Search_Postorder(int&,int*);
void Search_Levelorder(int&,int*);
;

Binary_Search_Tree::Binary_Search_Tree()

root=0;
height=-1;
leaf_count=0;


Binary_Search_Tree::~Binary_Search_Tree()

if (root!=0) delete root;


void Binary_Search_Tree::Build(int n,int *list)//丛数组list中读取前n个元素作为二叉搜索树的节点关键字以建立二叉搜索树

int i;
for (i=0;i<n;i++,list++)

Binary_Node *p,*q;
p=root;
q=0;
while (p)

p->size++;
q=p;
if (*list<p->key) p=p->left;
else p=p->right;

p=new Binary_Node(*list,q);
if (!q) root=p;
else

if (!q->left && !q->right) leaf_count--;
if (p->key<q->key) q->left=p;
else q->right=p;

leaf_count++;
if (p->height>height) height=p->height;
p=q=0;

return;


Binary_Node* Binary_Search_Tree::Query(int key)//根据关键字返回节点指针，未找到时返回空指针

Binary_Node *p;
p=root;
while (p && p->key!=key)

if (key<p->key) p=p->left;
else p=p->right;

return p;


int Binary_Search_Tree::Size()//返回二叉树的节点个数

if (!root) return 0;
else return root->size;


int Binary_Search_Tree::Height()//返回二叉树的高度

return height;


int Binary_Search_Tree::Leaves()//返回二叉树的叶节点个数

return leaf_count;


void Binary_Search_Tree::Search_Preorder(int &n,int *list)//先序遍历，返回二叉树节点个数到n，返回遍历结果到数组list

if (root)

n=root->size;
Search_Preorder(root,list);

else n=0;
return;


void Binary_Search_Tree::Search_Preorder(Binary_Node *p,int *list)//递归式先序遍历以p为根节点的子树，返回到数组list

*list=p->key;
list++;
if (p->left)

Search_Preorder(p->left,list);
list+=p->left->size;

if (p->right)

Search_Preorder(p->right,list);
list+=p->right->size;

return;


void Binary_Search_Tree::Search_Inorder(int &n,int *list)//中序遍历，返回二叉树节点个数到n，返回遍历结果到数组list

if (root)

n=root->size;
Search_Inorder(root,list);

else n=0;
return;


void Binary_Search_Tree::Search_Inorder(Binary_Node *p,int *list)//递归式中序遍历以p为根节点的子树，返回到数组list

if (p->left)

Search_Inorder(p->left,list);
list+=p->left->size;

*list=p->key;
list++;
if (p->right)

Search_Inorder(p->right,list);
list+=p->right->size;

return;


void Binary_Search_Tree::Search_Postorder(int &n,int *list)//后序遍历，返回二叉树节点个数到n，返回遍历结果到数组list

if (root)

n=root->size;
Search_Postorder(root,list);

else n=0;
return;


void Binary_Search_Tree::Search_Postorder(Binary_Node *p,int *list)//递归式后序遍历以p为根节点的子树，返回到数组list

if (p->left)

Search_Postorder(p->left,list);
list+=p->left->size;

if (p->right)

Search_Postorder(p->right,list);
list+=p->right->size;

*list=p->key;
list++;
return;


void Binary_Search_Tree::Search_Levelorder(int &n,int *list)//层次遍历，返回二叉树节点个数到n，返回遍历结果到数组list

if (root)

Binary_Node **queue;
int head,tail;
n=root->size;
queue=new Binary_Node*[n];
head=0;
tail=1;
queue[0]=root;
while (head<tail)

*list=queue[head]->key;
list++;
if (queue[head]->left!=0) queue[tail++]=queue[head]->left;
if (queue[head]->right!=0) queue[tail++]=queue[head]->right;
queue[head]=0;
head++;

delete [] queue;

else n=0;
return; 参考技术B 楼上那个人的肯定不对！不会也不能随便找个程序就往上粘啊，太不负责任了 参考技术C 111