精华内容
下载资源
问答
  • 5-4是否同一棵二叉搜索树(25分) 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树,都...

    5-4 是否同一棵二叉搜索树   (25分)

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

    输入格式:

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

    简单起见,我们保证每个插入序列都是1到NN的一个排列。当读到NN为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 <cstdio>    
    #include <cstdlib>    
    #include <iostream>    
    #include <vector>    
    #include <queue>    
    #include <map>    
    #include <algorithm>    
    #include <set>    
    #include <string>    
    
    using namespace std;    
    
    #define N 1005    
    
    int n , m ;  
    
    typedef struct node{  
        int data ;  
        struct node* left ;  
        struct node* right ;  
        node(int _data = -1){  
            data = _data ;  
            left = NULL ;  
            right = NULL ;  
        }  
    }Bnode;  
    
    // 二叉排序树 插入 建树  
    Bnode* createTree(Bnode* root,int data)  
    {  
        if(root == NULL)  
            root = new node(data);  
        else{  
            if(data < root->data )  
                root->left = createTree( root->left,data);  
            if(data > root->data){  
                root->right = createTree( root->right,data);  
            }  
        }  
        return root ;  
    }  
    
        // 递归判断两棵树 是否是一摸一样的  
    bool isSame(Bnode* root , Bnode* root2)  
    {  
        if(root == NULL && root2 == NULL){  
            return true;  
        }  
        else if(root == NULL && root2 != NULL){  
            return false;  
        }  
        else if(root != NULL && root2 == NULL){  
            return false;  
        }  
        else if(root->data != root2->data)  
            return  false;  
        else{  
            if(isSame(root->left , root2->left)&&isSame(root->right , root2->right))
                return true;  
            return false;  
        }  
    }  
    
    int main()    
    {    
        //freopen("in.txt","r",stdin);    
        //freopen("out.txt","w",stdout);    
        while(scanf("%d",&n) != EOF && n != 0){  
            scanf("%d",&m);  
            int i , tmpn ;  
            Bnode* root = NULL ;  
            for(i = 0 ; i < n ; i++){  
                scanf("%d",&tmpn);  
                root = createTree(root,tmpn);  
            }  
            while(m --){  
                Bnode* root2 = NULL ;  
                for(i = 0 ; i < n ; i++){  
                    scanf("%d",&tmpn);  
                    root2 = createTree(root2,tmpn);  
                }  
                if(isSame(root , root2))  
                    printf("Yes\n");  
                else  
                    printf("No\n");  
            }  
        }  
        return 0 ;    
    }    
    对源代码进行了改进

     

    展开全文
  • 是否同一棵二叉搜索树 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树,都得到一样的...

    是否同一棵二叉搜索树

    给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{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<cstdio>
    #include<string.h>
    #include<cstdlib>
    using namespace std;
    struct Node{
        int data;
        Node *left;
        Node *right;
    };
    typedef Node* Tree;
    int n,m;
    Tree create(Tree head,int x){	//创建树
        if(!head){
            head = new Node;
            head->data=x;
            head->left=head->right=NULL;
        }else if(x<head->data){
            head->left=create(head->left,x);
        }else if(x>head->data){
            head->right=create(head->right,x);
        }
        return head;
    }
    bool judge1(Tree x,Tree y){	//判断两个树是都一样
        if(x==NULL && y==NULL){  
            return true;
        }else if((x!=NULL&&y==NULL)||(x==NULL&&y!=NULL)){
            return  false;
        }else if(x->data==y->data){	//当前节点一样,继续判断其左右子树
           return judge1(x->left,y->left)&&judge1(x->right,y->right);
        }
        return false;
    }
    int main(){
        while(scanf("%d",&n)&&n){
            scanf("%d",&m);
            Tree head1=NULL;	//初始化为空
            for(int i=0;i<n;i++){
                int num;
                scanf("%d",&num);
                head1=create(head1,num);
            }
            for(int i=0;i<m;i++){
                Tree head2=NULL;
                for(int j=0;j<n;j++){
                    int num;
                    scanf("%d",&num);
                    head2=create(head2,num);
                }
                cout<<(judge1(head1,head2)?"Yes":"No")<<endl;
            }
        }
        return 0;
    }
    

    思路二:

    先判断根节点是否一样,然后根据根节点将数据划分两部分,一部分比根节点小,另一部分比根节点大,然后再递归判断两部分

    3 1 2 4 vs 3 4 1 2

    {1 2} 3 {4} {1 2} 3 {4}

    相同

    3 1 2 4 vs 3 2 4 1

    {1 2} 3 {4} {2 1} 3 {4}

    不同

    #include<iostream>
    #include<cstdio>
    #include<string.h>
    #include<cstdlib>
    using namespace std;
    int n,m;
    bool judge2(int x[],int y[]){
        int lenx=0;
        int leny=0;
        for(int i=0;i<n;i++){
            if(x[i]!=0x3f3f3f3f)lenx++;
            else break;
        }
         for(int i=0;i<n;i++){
            if(y[i]!=0x3f3f3f3f)leny++;
            else break;
        }
        if(lenx!=leny)return false;
        if(x[0]!=y[0]){
            return false;
        }else if(lenx>0){
            int xsmall[lenx],xs=0;
            int xbig[lenx],xb=0;
            int ysmall[lenx],ys=0;
            int ybig[lenx],yb=0;
            memset(xsmall,0x3f3f3f3f,sizeof(xsmall));
            memset(xbig,0x3f3f3f3f,sizeof(xbig));
            memset(ysmall,0x3f3f3f3f,sizeof(ysmall));
            memset(ybig,0x3f3f3f3f,sizeof(ybig));
        for(int i=0;i<lenx;i++){
            if(x[i]>x[0]){
                xbig[xb]=x[i];
                xb++;
            }else if(x[i]<x[0]){
                xsmall[xs]=x[i];
                xs++;
            }
            if(y[i]>x[0]){
                ybig[yb]=y[i];
                yb++;
            }else if(y[i]<y[0]){
                ysmall[ys]=y[i];
                ys++;
            }
        }
        return judge2(xsmall,ysmall)&&judge2(xbig,ybig);
        }
        return true;
    }
    int main(){
    	int treen[15];
        int treem[15];
        memset(treen,0x3f3f3f3f,sizeof(treen));
        memset(treem,0x3f3f3f3f,sizeof(treem));
        while(scanf("%d",&n)&&n){
            scanf("%d",&m);
            for(int i=0;i<n;i++){
                int num;
                scanf("%d",&num);
                treen[i]=num;
            }
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    int num;
                    scanf("%d",&num);
                    treem[j]=num;
                }
                cout<<(judge2(treen,treem)?"Yes":"No")<<endl;
            }
        }
        return 0;
    }
    

    思路三:

    建一棵树,再判别其他序列是否与该树一致
    在这里插入图片描述

    在树T中按顺序搜索3 2 4 1中的每个数

    如果每次搜索所经过的结点在前面均出现过,则一致

    否则(在某次搜索中遇到前面未出现的结点),则不一致

    #include<iostream>
    #include<cstdio>
    #include<string.h>
    #include<cstdlib>
    using namespace std;
    struct Node{
        int data;
        Node *left;
        Node *right;
        bool flag;
    };
    typedef Node* Tree;
    int n,m;
    Tree create(Tree head,int x){
        if(!head){
            head = new Node;
            head->data=x;
            head->flag=false;
            head->left=head->right=NULL;
        }else if(x<head->data){
            head->left=create(head->left,x);
        }else if(x>head->data){
            head->right=create(head->right,x);
        }
        return head;
    }
    bool judge3(Tree head,int x){
        if(head->flag){
            if(x<head->data)return judge3(head->left,x);
            else if(x>head->data)return judge3(head->right,x);
            else return false;
        }else{
            if(x==head->data){
                head->flag=true;
                return true;
            }else{
                return false;
            }
        }
    }
    void reset(Tree head){	//每次判断完,重置标记
        head->flag=false;
        if(head->left)reset(head->left);
        if(head->right)reset(head->right);
    }
    int main(){
         int tmp;
        while(scanf("%d",&n)&&n){
            scanf("%d",&m);
            Tree head=NULL;
            for(int i=0;i<n;i++){
                int num;
                scanf("%d",&num);
                head=create(head,num);
            }
            for(int i=0;i<m;i++){
                bool flag=true;
                for(int j=0;j<n;j++){
                    scanf("%d",&tmp);
                    if(!judge3(head,tmp)){
                        flag=false;
                    }
                }
                cout<<(flag?"Yes":"No")<<endl;
                reset(head);
            }
        }
        return 0;
    }
    
    展开全文
  • 04-树4 是否同一棵二叉搜索树 来自:PTA_数据结构_是否同一棵二叉搜索树 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{...

    04-树4 是否同一棵二叉搜索树

    来自:PTA_数据结构_是否同一棵二叉搜索树

    给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{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

    程序代码:

    /*
    	题目:对于不同的输入序列,判断是否为同一个二叉搜索树。
    	求解思路:
    			1、搜素树表示;
    			2、建搜索树T;
    			3、判断一序列是否与搜索树T一致。
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    
    //搜索树表示
    typedef struct TreeNode *Tree;
    struct TreeNode
    {
    	int v;
    	Tree Left, Right;
    	int flag;
    };
    Tree MakeTree(int N);
    Tree NewNode(int V);
    Tree Insert(Tree T, int V);
    int Judge(Tree T, int N);
    void ResetT(Tree T);
    void FreeTree(Tree T);
    
    //程序框架搭建
    int main()
    {
    	int N, L, i;
    	Tree T;
    
    	scanf("%d", &N);
    	while (N)
    	{
    		scanf("%d", &L);
    		T = MakeTree(N);
    		for (i = 0; i < L; i++)
    		{
    			if (Judge(T, N))
    			{
    				printf("Yes\n");
    			}
    			else
    			{
    				printf("No\n");
    			}
    			ResetT(T); //清除T中的标记flag
    		}
    		FreeTree(T);
    		scanf("%d", &N);
    	}
    	return 0;
    }
    
    //如何建搜索数
    Tree MakeTree(int N)
    {
    	Tree T;
    	int i, V;
    
    	scanf("%d", &V);
    	T = NewNode(V);
    	for (i = 1; i < N; i++)
    	{
    		scanf("%d", &V);
    		T = Insert(T, V);
    	}
    	return T;
    }
    
    //建新节点(一般为第一个节点)
    Tree NewNode(int V)
    {
    	Tree T = (Tree)malloc(sizeof(struct TreeNode));
    	T->v = V;
    	T->Left = T->Right = NULL;
    	T->flag = 0;
    	return T;
    }
    
    //后续节点的插入
    Tree Insert(Tree T, int V)
    {
    	if (!T)
    	{
    		T = NewNode(V);
    	}
    	else
    	{
    		if (V > T->v)
    		{
    			T->Right = Insert(T->Right, V);
    		}
    		else
    		{
    			T->Left = Insert(T->Left, V);
    		}
    	}
    	return T;
    }
    
    //如何判别(已经访问过的节点要被标记)
    int check(Tree T, int V)
    {
    	if (T->flag)
    	{
    		if (V < T->v)
    		{
    			return check(T->Left, V);
    		}
    		else if (V > T->v)
    		{
    			return check(T->Right, V);
    		}
    		else
    		{
    			return 0;
    		}
    	}else
    	{
    		if (V==T->v)
    		{
    			T->flag = 1;
    			return 1;
    		}else
    		{
    			return 0;
    		}
    	}
    }
    
    /*
    //如何判别(判别输入的树是否一致)
    int Judge(Tree T, int N)
    {
    	int i, V;
    	//有bug版本
    	scanf("%d", &V); //当发现序列中的某个数与T不一致时,
    	if (V != T->v)	 //必须把序列后边的数都读完。
    	{
    		return 0;
    	}
    	else
    	{
    		T->flag = 1;
    	}
    
    	for (i = 0; i < N; i++)
    	{
    		scanf("%d", &V);
    		if (!check(T, V))
    		{
    			return 0;
    		}
    	}
    
    	return 1;
    }
    */
    
    int Judge(Tree T, int N)
    {
    	int i, V, flag = 0;
    	//flag:0代表目前还一致,1代表已经不一致
    
    	scanf("%d", &V);
    	if (V != T->v)
    	{
    		flag = 1;
    	}
    	else
    	{
    		T->flag = 1;
    	}
    	for (i = 1; i < N; i++)
    	{
    		scanf("%d", &V);
    		if ((!flag) && (!check(T, V)))
    		{
    			flag = 1;
    		}
    	}
    	if (flag)
    	{
    		return 0;
    	}
    	else
    	{
    		return 1;
    	}
    }
    
    //清楚T中各个节点的标记
    void ResetT(Tree T)
    {
    	if (T->Left)
    	{
    		ResetT(T->Left);
    	}
    	if (T->Right)
    	{
    		ResetT(T->Right);
    	}
    	T->flag = 0;
    }
    
    void FreeTree(Tree T)
    {
    	if (T->Left)
    	{
    		FreeTree(T->Left);
    	}
    	if (T->Right)
    	{
    		FreeTree(T->Right);
    	}
    	free(T);
    }
    
    展开全文
  • 【树】是否同一棵二叉搜索树 题目要求: 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉...

    【树】是否同一棵二叉搜索树

    题目要求:

    给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{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

    解题思路:

    三种思路:

    1. 建两棵树:按序列建树,判断树是否一样。
    2. 建一棵树:将比对的基准序列建树,待比较序列不必建树,在树上按次序搜索待比较序列的元素,每搜到一个元素则在树上作出标记,如果在搜索序列元素的过程中,搜到了之前未搜过的元素(序列后面的元素比序列前面的元素早一步被搜到)(遍历到了未被标记的结点),则该序列与树不一致。
      原理是:按照序列建成的树再按次序在树中搜索该序列中的元素时,搜索过程中不会出现序列前面的元素没搜到就搜到序列后面的元素这样的情况的。
    3. 不建树:直接通过两个序列判断,如果两个序列的第一个元素不同,则一定不符合,因为构成的树的根结点都不一样;如果第一个元素一样,则将后面的元素按次序分为两波,小于该元素的序列(作为左子树),大于该元素的序列(作为右子树),然后递归判断两个序列(左子树序列和右子树序列)。

    该程序采用的思路2。

    注意:

    判断序列与树是否一致时,如果不一致不能直接return,否则用户对该序列的后续输入会被当作下一个序列的输入 。

    完整程序:
    /*
    【解题思路】
    三种思路:
    1.建两棵树:按序列建树,判断树是否一样
    2.建一棵树:将比对的基准序列建树,待比较序列不必建树,在树上按次序搜索待比较序列的元素,每搜到一个元素则在树上作出标记,如果在搜索
    序列元素的过程中,搜到了之前未搜过的元素(序列后面的元素比序列前面的元素早一步被搜到)(遍历到了未被标记的结点),则该序列与树不一致。
    原理是:按照序列建成的树再按次序在树中搜索该序列中的元素时,搜索过程中不会出现序列前面的元素没搜到就搜到序列后面的元素这样的情况的。 
    3.不建树:直接通过两个序列判断,如果两个序列的第一个元素不同,则一定不符合,因为构成的树的根结点都不一样;如果第一个元素一样,
    则将后面的元素按次序分为两波,小于该元素的序列(作为左子树),大于该元素的序列(作为右子树),然后递归判断两个序列(左子树序列
    和右子树序列) 
    
    该程序采用的思路2 
    */
    /*
    【注意】判断序列与树是否一致时,如果不一致不能直接return,否则用户对该序列的后续输入会被当作下一个序列的输入 
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    #define true 1
    #define false 0
    
    typedef struct TNode *Tree;
    struct TNode {
    	int Data;
    	Tree Left;
    	Tree Right;
    	int flag; // 用来标记结点有没有被搜索过 
    }; 
    
    Tree BuildTree(int N); // 建树 
    Tree BuildNode(int data); // 构建结点 
    Tree Insert(Tree T,int data); // 结点的插入操作
    int Check(Tree T,int data); // 判断序列中的特定元素是否应该出现在树的对应位置
    int Judge(Tree T,int N); // 判断序列是否与树一致 
    void ResetT(Tree T); // 清空树的标记
    void FreeT(Tree T); // 释放树所占用的空间 
     
    
    int main()
    {
    	int i;
    	int N,L; // N:每个序列的元素个数;L:序列个数
    	Tree T;
    	scanf("%d",&N);
    	while(N) { // 以输入N为0作为数据输入截止条件
    		scanf("%d",&L);
    		T = BuildTree(N);
    		for(i = 0;i < L;i ++) {
    			if(Judge(T,N))
    				printf("Yes\n");
    			else
    				printf("No\n");
    			ResetT(T); // 清除T中的标记flag 
    		} 
    		FreeT(T); // 不释放树所占内存不影响程序对错,要内存达到最优需要释放 
    		scanf("%d",&N);
    	} 
    	return 0;
    }
    
    Tree BuildTree(int N)
    {
    	Tree T;
    	int i,data;
    	scanf("%d",&data); 
    	T = BuildNode(data); 
    	for(i = 1;i < N;i ++) {
    		scanf("%d",&data);
    		T = Insert(T,data); // 做插入操作 
    	}
    	return T;
    } 
    
    Tree BuildNode(int data)
    {
    	Tree T = (Tree)malloc(sizeof(struct TNode));
    	T -> Data = data;
    	T -> Left = T -> Right = NULL;
    	T -> flag = 0; // 没有被搜索过 
    	return T;
    }
    
    Tree Insert(Tree T,int data)
    {
    	if(!T)
    		T = BuildNode(data);
    	else {
    		if(data > T -> Data)
    			T -> Right = Insert(T -> Right,data);
    		else 
    			T -> Left = Insert(T -> Left,data);
    	}
    	return T;
    }
    
    int Check(Tree T,int data)
    {
    	if(T -> flag) {
    		if(data < T -> Data)
    			return Check(T -> Left,data);
    		else if(data > T -> Data)
    			return Check(T -> Right,data);
    		else
    			return false; // 出现重复结点,二叉搜索树不能出现相同结点,所以该元素不符合 
    	}	
    	else {
    		if(data = T -> Data) { // 该结点之前没有搜索过,且刚好等于这个元素 
    			T -> flag = 1; // 该结点已经被搜索了,标记出来 
    			return true; // 符合 
    		}
    		else 	
    			return false;
    	}
    } 
    
    int Judge(Tree T,int N) // 该函数需要特别注意!一定要将序列都遍历完,如果没有遍历完就return则序列1剩余的元素会被当作序列2读入  
    {
    	int i,data,flag = 0; // flag用来标志序列与树是否一致,0:一致;1:不一致
    	scanf("%d",&data);
    	if(data != T -> Data)
    		flag = 1; // 该元素不等于树根,所以一定不一致
    	else
    		T -> flag = 1; // 该元素等于树根,暂时标记为一致
    	for(i = 1;i < N;i ++) {
    		scanf("%d",&data);
    		// 如果前面已经不一致了,则不需要检查后面的元素了,直接得到序列不一致的结论(flag = 1);如果前面一致,则需要判断后续的元素,只要后面有元素不符合就会得到序列不一致的结论 
    		if(!flag && !Check(T,data))
    			flag = 1;
    	} 
    	if(flag)
    		return false;
    	else
    		return true;
    } 
    
    void ResetT(Tree T)
    {
    	if(T -> Left)
    		ResetT(T -> Left);
    	if(T -> Right)
    		ResetT(T -> Right);
    	T -> flag = 0;
    }
    
    void FreeT(Tree T)
    {
    	if(T -> Left)
    		FreeT(T -> Left);
    	if(T -> Right)
    		FreeT(T -> Right);
    	free(T);
    }
    
    展开全文
  • 7-15 是否同一棵二叉搜索树(25 分) 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而,一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 581
精华内容 232
热门标签
关键字:

是否同一棵二叉搜索树