其他分享
首页 > 其他分享> > 2021秋季《数据结构》_第五章书面作业

2021秋季《数据结构》_第五章书面作业

作者：互联网

测试数据见附录

题目

建立

  1. 前序+附加两个标志位

    BiNODE* buildTree_twoTags()
{
	int n; cin >> n;
	if (n == 0) return NULL;
	BiNODE* root = new BiNODE;
	// root = NULL;
	BiNODE* p = root;
	BiNODE** Stack=new BiNODE*[n];

	int top = 0;
	
	for (int i = 0; i < n; i++)
	{
		int ltag = 0, rtag = 0;
		cin >> ltag >> p->data >> rtag;
		if (rtag == 0)  // 有右子树
			Stack[++top] = p;
		else p->rchild = NULL;
		
		BiNODE* q = new BiNODE;
		if (ltag == 0)  // 有左子树
			p->lchild = q;
		else
		{
			p->lchild = NULL;
			p = Stack[top--];  // 更新p为p的双亲结点
			p->rchild = q;
		}

		p = q;  // 移动指针
	}
	int ltag = 0, rtag = 0;
	// 读入最后一个结点
	cin >> ltag >> p->data >> rtag;
	p->lchild = NULL;
	p->rchild = NULL;
	return root;
}

  2. 前序序列+中序序列

    // 递归调用
BiNODE* buildTree_pre_in_re(int* pre, int head1, int tail1, 
				int* in, int head2, int tail2)
{
	if (tail2 < head2)
		return NULL;
	//cout << head1 << ' ' << tail1 << ' ' << head2 << ' ' << tail2 << endl;

	int i = head2;  // 在中序遍历中找根节点
	for (; i <= tail2; i++)
	{
		if (in[i] == pre[head1])
			break;
	}
	BiNODE* root = new BiNODE;
	root->data = pre[head1];
	//cout << root->data << endl;
	root->lchild = buildTree_pre_in_re(pre, head1+1, head1 + i - head2, in, head2, i - 1);
	root->rchild = buildTree_pre_in_re(pre, head1 + i - head2+1, tail1, in, i + 1, tail2);
	return root;
}

// 前序序列+中序序列
BiNODE* buildTree_pre_in()
{
	int n;  cin >> n;
	if (n == 0) return NULL;
	int* pre = new int[n];
	int* in = new int[n];
	for (int i = 0; i < n; i++)
	{
		cin >> pre[i];
	}
	for (int i = 0; i < n; i++)
	{
		cin >> in[i];
	}

	BiNODE* root = buildTree_pre_in_re(pre, 0, n-1, in, 0, n-1);
	return root;
}

  3. 后序序列+中序序列

    BiNODE* buildTree_post_in_re(int* post, int head1, int tail1,
	int* in, int head2, int tail2)
{
	if (tail2 < head2)
		return NULL;
	int i = head2;
	for (; i <= tail2; i++)
	{
		if (in[i] == post[tail1])
			break;
	}
	BiNODE* root = new BiNODE;
	root->data = post[tail1];
	root->lchild = buildTree_post_in_re(post, head1, head1+i-head2-1, in, head2, i - 1);
	root->rchild = buildTree_post_in_re(post, head1 + i - head2, tail1-1, in, i + 1, tail2);
	return root;

}

BiNODE* buildTree_post_in()
{
	int n;  cin >> n;
	if (n == 0) return NULL;
	int* post = new int[n];
	int* in = new int[n];
	for (int i = 0; i < n; i++)
	{
		cin >> post[i];
	}
	for (int i = 0; i < n; i++)
	{
		cin >> in[i];
	}
	BiNODE* root = buildTree_post_in_re(post, 0, n - 1, in, 0, n - 1);
	return root;
}

遍历

  1. 非递归前序遍历

    void preorder(BiNODE* root)
{
	if (!root)
		return;

	BiNODE* q[MAXN];
	q[0] = root;
	int top = 1;
	while (top > 0)
	{
		BiNODE* t = q[--top];
		cout << t->data << endl;
		if (t->lchild)
			q[top++] = t->lchild;
		if (t->rchild)
			q[top++] = t->rchild;
	}
}

  2. 递归前序遍历

    void preorderRecursive(BiNODE* root)
{
	if (root)
	{
		cout << root->data << endl;
		preorderRecursive(root->lchild);
		preorderRecursive(root->rchild);
	}
}

  3. 非递归中序遍历

    void inorder(BiNODE* root)
{
	if (!root) return;
	BiNODE* t = root;
	SNODE* top = NULL;

	while (t||top)
	{
		while (t)  // 子树根节点连续入栈，沿左孩子向下
		{
			SNODE* p = new SNODE;
			p->addr = t;
			p->link = top;
			top = p;
			t = t->lchild;  // 遍历到最后一个左孩子为止
		}
		if (top)
		{
			t = top->addr;
			cout << t->data << endl;
			SNODE* p = top;
			top = top->link;
			delete p;  // pop栈顶
			//if(top) cout << "top=" << top->addr->data << endl;
			t = t->rchild;  // 处理右子树
			//if (t) cout << "t=" << t->data << endl;
		}
	}
}

  4. 递归中序遍历

    void inorderRecursive(BiNODE* root)
{
	if (root)
	{
		inorderRecursive(root->lchild);
		cout << root->data << endl;
		inorderRecursive(root->rchild);
	}
}

  5. 非递归后序遍历

    void postorder(BiNODE* root)
{
	BiNODE* s[MAXN];
	int mark[MAXN], top = -1;
	if (root == NULL) return;
	s[++top] = root;
	mark[top] = 0;
	while (top >= 0) {
		if (mark[top] == 0) 
		{
			BiNODE* p = s[top];
			mark[top] = 1;
			if (p->rchild != NULL) 
			{
				s[++top] = p->rchild;
				mark[top] = 0;
			}
			if (p->lchild != NULL) 
			{
				s[++top] = p->lchild;
				mark[top] = 0;
			}

		}
		if (mark[top] == 1)
			cout << s[top--]->data << endl;
	}
}

  6. 递归后序遍历

    void postorderRecursive(BiNODE* root)
{
	if (root)
	{
		postorderRecursive(root->lchild);
		postorderRecursive(root->rchild);
		cout << root->data << endl;
	}
}

  7. 层次遍历

    void layerOrder(BiNODE* root)
{
	if (!root) return;
	BiNODE* q[MAXN];
	int head = 0, tail = 1;
	q[head] = root;
	while (head<tail)
	{
		BiNODE* p = q[head++];
		cout << p->data << endl;
		if (p->lchild)
			q[tail++] = p->lchild;
		if (p->rchild)
			q[tail++] = p->rchild;
	}
}

应用

  1. 求给定的二叉树的结点的个数

    int getNodeNum(BiNODE* root)
{
	if (!root) return 0;
	return 1 + getNodeNum(root->lchild) + getNodeNum(root->rchild);
}

  2. 求给定的二叉树的高度

    // 记仅有根节点的树高度为0
int getTreeHeight(BiNODE* root)
{
	if (!root) return -1;
	int hl = getTreeHeight(root->lchild);
	int hr = getTreeHeight(root->rchild);
	int hc = hl > hr ? hl : hr;
	return 1 + hc;
}

  3. 判断给定的一棵二叉树是否是满树

    bool isFull(BiNODE* root)
{
	if (!root)
		return true;
	return isFull(root->lchild) && isFull(root->rchild) && getTreeHeight(root->lchild) == getTreeHeight(root->rchild);
}

  4. 判断给定的一个二叉树是否是完全二叉树

    bool isComplete(BiNODE* root)
{
	if (!root)
		return true;
	BiNODE* q[MAXN];
	int head = 0, tail = 1;
	bool restLeaf = false;
	q[head] = root;
	while (head<tail)
	{
		BiNODE* p = q[head++];
		BiNODE* left = p->lchild;
		BiNODE* right = p->rchild;
		if (restLeaf && (left || right) ||
			!left && right)
			return false;
		if (left)
			q[tail++] = left;
		if (right)
			q[tail++] = right;
		if (!left || !right)
			restLeaf = true;
	}
	return true;
}

  5. 如果二叉树的结点的值不允许重复，且是可比较大小的。判断一棵二叉树是否满足以下条件：左子树上的所有结点的值都小于根结点的值，右子树上的所有结点的值都大于根结点的值。

    int former = -1;
// 判断是否二叉搜索树
bool isBinarySearchTree(BiNODE* root)
{
	if (!root)
		return true;
	if (!isBinarySearchTree(root->lchild))
		return false;
	if (root->data < former)
		return false;
	former = root->data;
	if (!isBinarySearchTree(root->rchild))
		return false;
	return true;
}

附录

前序+附加两个标志位：
测试数据：
第一组 //只有根结点
1
1 2 1
第二组：//每个结点上只有一个子结点
5
0 1 1
0 2 1
1 3 0
0 4 1
1 5 1
第三组： //完全二叉树
6
0 3 0
0 2 0
1 1 1
1 6 1
0 4 1
0 5 0
第四组：//满树
7
0 1 0
0 2 0
1 4 1
1 5 1
0 3 0
1 6 1
1 7 1
第五组： //空树
0

前序+中序：在buildTree_pre_in()中对左右子树分别调用函数Build_pre_in_re(int pre[],int l,int r,int mid[])递归建树
测试数据：
第一组： //空树
0
第二组：//只有根结点
1
2
2
第三组：//每个结点上只有一个子结点
5
1 2 3 4 5
3 5 4 2 1
第四组：//完全二叉树
6
3 2 1 6 4 5
1 2 6 3 5 4
第五组： //满树
7
1 2 4 5 3 6 7
4 2 5 1 6 3 7

后序+中序：在buildTree_post_in()中对左右子树分别调用Build_post_in_re(int post[],int l,int r,int mid[])函数递归建树
测试数据与上面相同，只不过用后序输入
第一组： //空树
0
第二组：//只有根结点
1
2
2
第三组：//每个结点上只有一个子结点
5
5 4 3 2 1
3 5 4 2 1
第四组：//完全二叉树
6
1 6 2 5 4 3
1 2 6 3 5 4
第五组： //满树
7
4 5 2 6 7 3 1
4 2 5 1 6 3 7

第二部分： 遍历.cpp，我的main函数中采用了第一部分中的前序+中序建树
测试数据与第一部分相同：
第一组： //空树
0
第二组：//只有根结点
1
2
2
第三组：//每个结点上只有一个子结点
5
1 2 3 4 5
3 5 4 2 1
第四组：//完全二叉树
6
3 2 1 6 4 5
1 2 6 3 5 4
第五组： //满树
7
1 2 4 5 3 6 7
4 2 5 1 6 3 7

第三部分： 应用.cpp中同样采用前序+中序的方式建树，输出五个函数的判断
第一组： //空树
0
第二组：//只有根结点
1
2
2
第三组：//每个结点上只有一个子结点
5
1 2 3 4 5
3 5 4 2 1
第四组：//完全二叉树，但不是满树和二叉线索树
6
3 2 1 6 4 5
1 2 6 3 5 4
第五组： //满树，也是完全二叉树，但不是二叉线索树
7
1 2 4 5 3 6 7
4 2 5 1 6 3 7
第六组：//既是完全二叉树又是二叉搜索树但不是满树
8
5 3 2 1 4 7 6 8
1 2 3 4 5 6 7 8

标签：BiNODE,结点,return,int,top,第五章,2021,数据结构,root
来源： https://blog.csdn.net/rd142857/article/details/121638926