数据结构——浙大版中国大学mooc（week4）

最新推荐文章于 2021-08-02 19:31:25 发布
最新推荐文章于 2021-08-02 19:31:25 发布
阅读量215 收藏
点赞数
分类专栏： 数据结构mooc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CodingW/article/details/102511663
版权

树（中）

课程给出代码

C语言表示二叉搜索树的插入和搜索

BinTree Insert( BinTree BST, ElementType X )
{
    if( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    }
    else { /* 开始找要插入元素的位置 */
        if( X < BST->Data )
            BST->Left = Insert( BST->Left, X );   /*递归插入左子树*/
        else  if( X > BST->Data )
            BST->Right = Insert( BST->Right, X ); /*递归插入右子树*/
        /* else X已经存在，什么都不做 */
    }
    return BST;
}
 
BinTree Delete( BinTree BST, ElementType X ) 
{ 
    Position Tmp; 
 
    if( !BST ) 
        printf("要删除的元素未找到"); 
    else {
        if( X < BST->Data ) 
            BST->Left = Delete( BST->Left, X );   /* 从左子树递归删除 */
        else if( X > BST->Data ) 
            BST->Right = Delete( BST->Right, X ); /* 从右子树递归删除 */
        else { /* BST就是要删除的结点 */
            /* 如果被删除结点有左右两个子结点 */ 
            if( BST->Left && BST->Right ) {
                /* 从右子树中找最小的元素填充删除结点 */
                Tmp = FindMin( BST->Right );
                BST->Data = Tmp->Data;
                /* 从右子树中删除最小元素 */
                BST->Right = Delete( BST->Right, BST->Data );
            }
            else { /* 被删除结点有一个或无子结点 */
                Tmp = BST; 
                if( !BST->Left )       /* 只有右孩子或无子结点 */
                    BST = BST->Right; 
                else                   /* 只有左孩子 */
                    BST = BST->Left;
                free( Tmp );
            }
        }
    }
    return BST;
}

C语言描述AVL树的旋转和插入

typedef struct AVLNode *Position;
typedef Position AVLTree; /* AVL树类型 */
struct AVLNode{
    ElementType Data; /* 结点数据 */
    AVLTree Left;     /* 指向左子树 */
    AVLTree Right;    /* 指向右子树 */
    int Height;       /* 树高 */
};
 
int Max ( int a, int b )
{
    return a > b ? a : b;
}
 
AVLTree SingleLeftRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B */
  /* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */     
 
    AVLTree B = A->Left;
    A->Left = B->Right;
    B->Right = A;
    A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
    B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
  
    return B;
}
 
AVLTree DoubleLeftRightRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */
     
    /* 将B与C做右单旋，C被返回 */
    A->Left = SingleRightRotation(A->Left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}
 
/*************************************/
/* 对称的右单旋与右-左双旋请自己实现 */
/*************************************/
 
AVLTree Insert( AVLTree T, ElementType X )
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    if ( !T ) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Height = 0;
        T->Left = T->Right = NULL;
    } /* if (插入空树) 结束 */
 
    else if ( X < T->Data ) {
        /* 插入T的左子树 */
        T->Left = Insert( T->Left, X);
        /* 如果需要左旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
            if ( X < T->Left->Data ) 
               T = SingleLeftRotation(T);      /* 左单旋 */
            else 
               T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    } /* else if (插入左子树) 结束 */
     
    else if ( X > T->Data ) {
        /* 插入T的右子树 */
        T->Right = Insert( T->Right, X );
        /* 如果需要右旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
            if ( X > T->Right->Data ) 
               T = SingleRightRotation(T);     /* 右单旋 */
            else 
               T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    } /* else if (插入右子树) 结束 */
 
    /* else X == T->Data，无须插入 */
 
    /* 别忘了更新树高 */
    T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;
     
    return T;
}

04-树7 二叉搜索树的操作集 (30 分)

函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针；
函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针；
函数Find在二叉搜索树BST中找到X，返回该结点的指针；如果找不到则返回空指针；
函数FindMin返回二叉搜索树BST中最小元结点的指针；
函数FindMax返回二叉搜索树BST中最大元结点的指针。
函数接口定义：
BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );

BinTree Insert( BinTree BST, ElementType X ){
    if( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    }
    else { /* 开始找要插入元素的位置 */
        if( X < BST->Data )
            BST->Left = Insert( BST->Left, X );   /*递归插入左子树*/
        else  if( X > BST->Data )
            BST->Right = Insert( BST->Right, X ); /*递归插入右子树*/
    }
    return BST;
}

BinTree Delete( BinTree BST, ElementType X ){
    Position Tmp; 
    if( !BST ) 
        printf("Not Found\n"); 
    else {
        if( X < BST->Data ) 
            BST->Left = Delete( BST->Left, X );   /* 从左子树递归删除 */
        else if( X > BST->Data ) 
            BST->Right = Delete( BST->Right, X ); /* 从右子树递归删除 */
        else { /* BST就是要删除的结点 */
            /* 如果被删除结点有左右两个子结点 */ 
            if( BST->Left && BST->Right ) {
                /* 从右子树中找最小的元素填充删除结点 */
                Tmp = FindMin( BST->Right );
                BST->Data = Tmp->Data;
                /* 从右子树中删除最小元素 */
                BST->Right = Delete( BST->Right, BST->Data );
            }
            else { /* 被删除结点有一个或无子结点 */
                Tmp = BST; 
                if( !BST->Left )       /* 只有右孩子或无子结点 */
                    BST = BST->Right; 
                else                   /* 只有左孩子 */
                    BST = BST->Left;
                free( Tmp );
            }
        }
    }
    return BST;
}

Position Find( BinTree BST, ElementType X ){
    if( !BST ) 
        return NULL; 
    else {
        if( X < BST->Data ) 
            return Find( BST->Left, X );  
        else if( X > BST->Data ) 
            return Find( BST->Right, X ); 
        else 
            return BST;
    }
}

Position FindMin( BinTree BST ){
    if(!BST)
        return NULL;
    else if(!BST->Left)
        return BST;
    else
        FindMin(BST->Left );
}

Position FindMax( BinTree BST ){
    if(!BST)
        return NULL;
    else if(!BST->Right)
        return BST;
    else
        FindMax( BST->Right );
}

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

给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。
输入格式:
输入包含若干组测试数据。每组数据的第1行给出两个正整数N (≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行，每行给出N个插入的元素，属于L个需要检查的序列。
简单起见，我们保证每个插入序列都是1到N的一个排列。当读到N为0时，标志输入结束，这组数据不要处理
输出格式:
对每一组需要检查的序列，如果其生成的二叉搜索树跟对应的初始序列生成的一样，输出“Yes”，否则输出“No”。

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode {
	ElementType Data;
	BinTree Left;
	BinTree Right;
	ElementType flag;
};

BinTree Insert(BinTree BST, ElementType X) {
	if (!BST) { /* 若原树为空，生成并返回一个结点的二叉搜索树 */
		BST = (BinTree)malloc(sizeof(struct TNode));
		BST->Data = X;
		BST->flag = 0;
		BST->Left = BST->Right = NULL;
	}
	else { /* 开始找要插入元素的位置 */
		if (X < BST->Data)
			BST->Left = Insert(BST->Left, X);   /*递归插入左子树*/
		else  if (X > BST->Data)
			BST->Right = Insert(BST->Right, X); /*递归插入右子树*/
	}
	return BST;
}

int check(BinTree BST, ElementType X) {
	if (BST->flag) {
		if (X > BST->Data)
			return check(BST->Right, X);
		else if (X < BST->Data)
			return check(BST->Left, X);
		else
			return 0;
	}
	else {
		if (X == BST->Data) {
			BST->flag = 1;
			return 1;
		}
		else
			return 0;
	}
}
int Judge(BinTree BST, ElementType X) {
	int i, V, flag1 = 0;
	scanf("%d", &V);
	if (V != BST->Data)
		flag1 = 1;
	else
		BST->flag = 1;
	for (i = 1; i < X; i++) {//一定注意从1开始！！！
		scanf("%d", &V);
		if ((!flag1) && (!check(BST, V)))
			flag1 = 1;
	}
	if (flag1)
		return 0;
	else
		return 1;
}

void ResetTree(BinTree BST) {
	if (BST->Left)
		ResetTree(BST->Left);
	if (BST->Right)
		ResetTree(BST->Right);
	BST->flag = 0;
}

int main()
{
	BinTree BST;
	ElementType X;
	int N, i, M;
	BST = NULL;
	scanf("%d", &N);
	while (N) {
		scanf("%d", &M);
		for (i = 0; i < N; i++) {
			scanf("%d", &X);
			BST = Insert(BST, X);
		}
		for (i = 0; i < M; i++) {
			if (Judge(BST, N))
				printf("Yes\n");
			else
				printf("No\n");
			ResetTree(BST);
		}
		BST=NULL;
		scanf("%d", &N);
	}
	return 0;
}

04-树5 Root of AVL Tree (25 分)

An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property.
Now given a sequence of insertions, you are supposed to tell the root of the resulting AVL tree.

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct AVLNode* Position;
typedef Position AVLTree; /* AVL树类型 */
struct AVLNode {
	ElementType Data; /* 结点数据 */
	AVLTree Left;     /* 指向左子树 */
	AVLTree Right;    /* 指向右子树 */
	int Height;       /* 树高 */
};

int Max(int a, int b) {
	return a > b ? a : b;
}

int GetHeight(AVLTree A) {
	if (!A) return 0;
	if (!A->Left && !A->Right) return 1;
	if (A->Left && !A->Right) return GetHeight(A->Left) + 1;
	if (!A->Left && A->Right) return GetHeight(A->Right) + 1;
	return Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
}

AVLTree SingleLeftRotation(AVLTree A) {
	/* 注意：A必须有一个左子结点B */
	/* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */
	AVLTree B = A->Left;
	A->Left = B->Right;
	B->Right = A;
	A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
	B->Height = Max(GetHeight(B->Left), A->Height) + 1;
	return B;
}

AVLTree SingleRightRotation(AVLTree A) {
	AVLTree B = A->Right;
	A->Right = B->Left;
	B->Left = A;
	A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
	B->Height = Max(GetHeight(B->Right), A->Height) + 1;
	return B;
}

AVLTree DoubleLeftRightRotation(AVLTree A) {
	/* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
	/* 将A、B与C做两次单旋，返回新的根结点C */

	/* 将B与C做右单旋，C被返回 */
	A->Left = SingleRightRotation(A->Left);
	/* 将A与C做左单旋，C被返回 */
	return SingleLeftRotation(A);
}

AVLTree DoubleRightLeftRotation(AVLTree A) {
	A->Right = SingleLeftRotation(A->Right);
	return SingleRightRotation(A);
}

AVLTree Insert(AVLTree T, ElementType X) {
	/* 将X插入AVL树T中，并且返回调整后的AVL树 */
	if (!T) { /* 若插入空树，则新建包含一个结点的树 */
		T = (AVLTree)malloc(sizeof(struct AVLNode));
		T->Data = X;
		T->Height = 0;
		T->Left = T->Right = NULL;
	} /* if (插入空树) 结束 */
	else if (X < T->Data) {
		/* 插入T的左子树 */
		T->Left = Insert(T->Left, X);
		/* 如果需要左旋 */
		if (GetHeight(T->Left) - GetHeight(T->Right) == 2)
			if (X < T->Left->Data)
				T = SingleLeftRotation(T);      /* 左单旋 */
			else
				T = DoubleLeftRightRotation(T); /* 左-右双旋 */
	} /* else if (插入左子树) 结束 */
	else if (X > T->Data) {
		/* 插入T的右子树 */
		T->Right = Insert(T->Right, X);
		/* 如果需要右旋 */
		if (GetHeight(T->Left) - GetHeight(T->Right) == -2)
			if (X > T->Right->Data)
				T = SingleRightRotation(T);     /* 右单旋 */
			else
				T = DoubleRightLeftRotation(T); /* 右-左双旋 */
	} /* else if (插入右子树) 结束 */
	/* else X == T->Data，无须插入 */
	/* 别忘了更新树高 */
	T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1;
	return T;
}

int main(void) {
	int n, i, temp;
	AVLTree A = NULL;
	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		scanf("%d", &temp);
		A = Insert(A, temp);
	}
	printf("%d\n", A->Data);
	return 0;
}

04-树6 Complete Binary Search Tree (30 分)

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
Both the left and right subtrees must also be binary search trees.
A Complete Binary Tree (CBT) is a tree that is completely filled, with the possible exception of the bottom level, which is filled from left to right.

Now given a sequence of distinct non-negative integer keys, a unique BST can be constructed if it is required that the tree must also be a CBT. You are supposed to output the level order traversal sequence of this BST.

nt root, int N, int a[])
{
    if(root<=N) {
        mid_tree(2*root, N, a);
        b[root] =  a[pos++];
        mid_tree(2*root+1, N, a);
    }
}

int main()
{
    int N, i;
    int data[1000];
    scanf("%d", &N);
    for(i=0;i<N;i++) 
        scanf("%d", &data[i]);        
    sort(data, N);
    mid_tree(1, N, data);
    for(i=1;i<=N;i++) {
        if(i==1) {
            printf("%d", b[i]);
        } else {
            printf(" %d", b[i]);
        }
    }
    return 0;
}

数组存放

CodingW
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通信网络基础答案——中国大学mooc.docx
06-02
通信网络基础国家精品——西安电子科技大学 课后习题和考试参考答案
数据结构哈希题目
m0_51376859的博客
01-06 700
目录购物券（哈希+dfs的妙用）魔板 (哈希+bfs) 购物券（哈希+dfs的妙用） Description 小Y得到了两张价值不菲的SHOP购物券，所以他决定去买N件礼物送给朋友们。小Y选好了n件礼物，并且它们的价格之和恰好为两张购物券的面值之和。当小Y被自己的聪明所折服，高兴地去结账时，他突然发现SHOP对购物券的使用有非常奸诈的规定：一次只允许使用一张、不找零、不与现金混用。小Y身上根本没有现金，并且他不愿意放弃挑选好的礼物。这就意味着，他只能通过这两张购物券结账，而且每一张购物券所购买的物品的总价
大一C语言程序设计练习题(三)
weixin_51770799的博客
12-03 2018
大一C语言程序设计练习题三A - ASCII码排序B - 字符串统计C - 统计元音D - 回文串E - 让气球升起来！F - C语言合法标识符G - 统计字符(选做)H - Encoding(选做)I - Text Reverse(选做) A - ASCII码排序 Description 输入三个字符后，按各字符的ASCII码从小到大的顺序输出这三个字符。 Input 输入数据有多组，每组占一行，有三个字符组成，之间无空格。 Output 对于每组输入数据，输出一行，字符中间用一个空格分开。 Sa
ACM中常见数据输入格式总结
编写未来
10-31 2241
最开始自己学习编程的时候，输入的数据往往是一次性输入，回车得到结果就完了，请按任意键继续….但是当接触oj上的题目后，起初感觉很困惑，他往往有多组测试数据，我就想这是不是要一次把测试数据全部输入进去然后再得到多组结果，但是一想不对…总之很困惑，最后请教同学，看书体会，终于明白不是我想的那么复杂。然后就不纠结这个问题了。本篇文章总结一下常见的数据输入格式。 1.      输入有若干行，每行有一个
是否同一棵二叉搜索树 (25分)
zp1455604302的博客
09-17 1189
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入包含若干组测试数据。每组数据的第1行给出两个正整数N (≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行，每行给出N个插入的元素，属于L个需要检查
04-树4 是否同一棵二叉搜索树--------C语言
weixin_60245632的博客
08-02 391
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入包含若干组测试数据。每组数据的第1行给出两个正整数N(≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行，每行给出N个插入的元素，属于L个需要.
中国大学MOOC浙江大学数据结构课程____数据结构作业
09-05
本作业聚焦于浙江大学在中国大学MOOC上开设的数据结构课程，由陈越教授主讲。通过完成这份作业，学生将深化对各种数据结构的理解，包括线性结构、树形结构、图结构以及查找和排序算法。 1. 线性结构：线性结构是最...
清华大学邓俊辉教授数据结构（下）MOOC习题
最新发布
09-15
清华大学邓俊辉教授的“数据结构”课程在学堂在线上广受好评，其下部分涵盖了多个重要主题，包括优先级队列、排序、词典、串、二叉搜索树以及高级搜索树。下面我们将逐一深入这些知识点。 1. **优先级队列**：...
MOOC中国大学数据结构（陈越/何钦铭）每周C 语言作业答案
06-25
本资源是“中国大学MOOC”上由陈越和何钦铭教授讲授的数据结构课程的C语言作业答案。C语言是一种强大的、底层的编程语言，特别适合用于理解和实现数据结构的底层细节。 作业答案涵盖了数据结构的基础概念和各种常见...
PTA-mooc：PTA（拼题A）-浙江大学中国大学mooc数据结构全AC代码与翻译解析（C语言）
02-05
本资源主要针对浙江大学在中国大学MOOC平台上开设的数据结构课程，提供了完整的PTA（Programming Task Assistant）平台上的题解代码，全部使用C语言编写，并附带了详细的翻译与解析，对于学习数据结构和算法的C语言...
判断二叉搜索树的前序遍历
06-08
《剑指offer》面试题24的相关题目。输入一个整数数组，判断该数组是不是某二叉搜索树的前序遍历。假设输入的数组的任意两个数字互不相同。
04-树4 是否同一棵二叉搜索树（25 分)
中央单元
04-20 2667
04-树4 是否同一棵二叉搜索树（25 分) 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入包含若干组测试数据。每组数据的第1行给出两个正整数N(≤10)N...
每日一题（五）：栈的基础应用
老肥码码码
01-20 2755
1. 题目描述：     在某个字符串（长度不超过100）中有左括号、右括号和大小写字母；规定（与常见的算数式子一样）任何一个左括号都从内到外与在它右边且距离最近的右括号匹配。写一个程序，找到无法匹配的左括号和右括号，输出原来字符串，并在下一行标出不能匹配的括号。不能匹配的左括号用"$"标注,不能匹配的右括号用"?"标注. 输入：     输入包括多组数据，每组数据一行，包含一个字符串，只包含...
Day_3
zx_02的博客
07-06 120
1、电话聊天狂人 给定大量手机用户通话记录，找出其中通话次数最多的聊天狂人。 输入格式: 输入首先给出正整数N（≤10 ​5 ​​ ），为通话记录条数。随后N行，每行给出一条通话记录。简单起见，这里只列出拨出方和接收方的11位数字构成的手机号码，其中以空格分隔。 输出格式: 在一行中给出聊天狂人的手机号码及其通话次数，其间以空格分隔。如果这样的人不唯一，则输出狂人中最小的号码及其通话次数，并且附加给出并列狂人的人数。 输入样例: 4 13005711862 13588625832 13505711862 1
04-树4 是否同一棵二叉搜索树（25 point(s)） 【Tree】
banshen0201的博客
03-31 402
04-树4 是否同一棵二叉搜索树（25 point(s)） 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入...
SDUT 3373 数据结构实验之查找一：二叉排序树
Code_KK的博客
12-03 3197
数据结构实验之查找一：二叉排序树 Time Limit: 400ms   Memory limit: 65536K  有疑问？点这里^_^ 题目描述 对应给定的一个序列可以唯一确定一棵二叉排序树。然而，一棵给定的二叉排序树却可以由多种不同的序列得到。例如分别按照序列{3,1,4}和{3,4,1}插入初始为空的二叉排序树，都得到一样的结果。你的任务书对于
#数据结构#第七章:查找
vircorns的博客
10-28 6970
文章目录单选题编程题7-1 两个有序序列的中位数7-2 是否同一棵二叉搜索树7-3 是否完全二叉搜索树 单选题 2-1 已知一个长度为16的顺序表L，其元素按关键字有序排列。若采用二分查找法查找一个L中不存在的元素，则关键字的比较次数最多是： 4 5 6 7 作者: DS课程组 单位: 浙江大学 2-2 用二分查找从100个有序整数中查找某数，最坏情况下需要比较的次数是： 7 10 50 99 作...
7-19 是否同一棵二叉搜索树 (25分)
ZZULI_星.夜
06-28 450
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入包含若干组测试数据。每组数据的第1行给出两个正整数N(≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行，每行给出N个插入的元素，属于L个需要.
7-4 是否同一棵二叉搜索树 (25分) (数组模拟)
Gyibin的博客
06-01 168
7-4 是否同一棵二叉搜索树 (25分) 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入包含若干组测试数据。每组数据的第1行给出两个正整数N (≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行
北京大学MOOC数据结构课后习题解析
"这是北京大学MOOC课程《数据结构》的相关课后习题，由教师张铭教授讲解，适合北京大学计算机专业的考研复习。" 1、算法特性是衡量一个算法好坏的重要标准。选项A和D正确地描述了算法的特性。A选项指出算法应确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值