沈师PTA数据结构2021函数题复习

已于 2022-02-19 16:51:43 修改
阅读量2.3k 收藏 50
点赞数 10
分类专栏： PTA C语言 文章标签： 数据结构
于 2021-12-26 00:53:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45966405/article/details/122151091
版权
C语言 同时被 2 个专栏收录
9 篇文章 4 订阅
订阅专栏
PTA
7 篇文章 10 订阅
订阅专栏
题目中很多关键算法都给省略了，放在Clion之类的编辑器中调试报错，也不知道具体那块是怎么写的，所以也没法给答案写注释。

R6-1 求二叉树高度 (10 分)

本题要求给定二叉树的高度。

函数接口定义：

int GetHeight( BinTree BT );

其中BinTree结构定义如下：

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

要求函数返回给定二叉树BT的高度值。

裁判测试程序样例：

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

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

BinTree CreatBinTree(); /* 实现细节忽略 */
int GetHeight( BinTree BT );

int main()
{
    BinTree BT = CreatBinTree();
    printf("%d\n", GetHeight(BT));
    return 0;
}
/* 你的代码将被嵌在这里 */

输出样例（对于图中给出的树）：

img

4

/*答案:*/
int GetHeight(BinTree BT){
    if(BT==0) return 0;
    return GetHeight(BT->Left)+1>GetHeight(BT->Right)+1?GetHeight(BT->Left)+1:GetHeight(BT->Right)+1;
}

R6-2 二叉树的遍历 (10 分)

本题要求给定二叉树的4种遍历。

函数接口定义：

void InorderTraversal( BinTree BT );
void PreorderTraversal( BinTree BT );
void PostorderTraversal( BinTree BT );
void LevelorderTraversal( BinTree BT );

其中BinTree结构定义如下：

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

要求4个函数分别按照访问顺序打印出结点的内容，格式为一个空格跟着一个字符。

裁判测试程序样例：

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

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

BinTree CreatBinTree(); /* 实现细节忽略 */
void InorderTraversal( BinTree BT );
void PreorderTraversal( BinTree BT );
void PostorderTraversal( BinTree BT );
void LevelorderTraversal( BinTree BT );

int main()
{
    BinTree BT = CreatBinTree();
    printf("Inorder:");    InorderTraversal(BT);    printf("\n");
    printf("Preorder:");   PreorderTraversal(BT);   printf("\n");
    printf("Postorder:");  PostorderTraversal(BT);  printf("\n");
    printf("Levelorder:"); LevelorderTraversal(BT); printf("\n");
    return 0;
}
/* 你的代码将被嵌在这里 */

输出样例（对于图中给出的树）：

img

Inorder: D B E F A G H C I
Preorder: A B D F E C G H I
Postorder: D E F B H G I C A
Levelorder: A B C D F G I E H

/*答案:*/
//中序遍历
void InorderTraversal( BinTree BT )
{
    if(BT==NULL)return;
    InorderTraversal(BT->Left);
    printf(" %c",BT->Data);
    InorderTraversal(BT->Right);
}
//先序遍历
void PreorderTraversal( BinTree BT )
{
    if(BT==NULL)return;
    printf(" %c",BT->Data);
    PreorderTraversal(BT->Left);
    PreorderTraversal(BT->Right);
}
//后序遍历
void PostorderTraversal( BinTree BT )
{
    if(BT==NULL)return;
    PostorderTraversal(BT->Left);
    PostorderTraversal(BT->Right);
    printf(" %c",BT->Data);
}
//层级遍历
void LevelorderTraversal( BinTree BT )
{
    if(BT==NULL)return;
    BinTree CC[10000];
    CC[0]=BT;
    int lens=1;
    while(1)
    {
        if(lens==0)return;
        int temp=0;BinTree TH[10000];       //TH,设置一个数组作为队列使用
        for(int i=0;i<lens;i++)
        {
            if(CC[i]!=NULL)         //判断结点是否为空，如果不为空，输出
                printf(" %c",CC[i]->Data);
            if(CC[i]->Left!=NULL)   //判断左子树是否为空，如果不为空，入队列
                TH[temp++]=CC[i]->Left;
            if(CC[i]->Right!=NULL)  //判断右子树是否为空，如果不为空，入队列
                TH[temp++]=CC[i]->Right;
        }
        lens=temp;
        for(int i=0;i<lens;i++)     //出队，进入CC
            CC[i]=TH[i];
    }
}

R6-3 先序输出叶结点 (10 分)

本题要求按照先序遍历的顺序输出给定二叉树的叶结点。

函数接口定义：

void PreorderPrintLeaves( BinTree BT );

其中BinTree结构定义如下：

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

函数PreorderPrintLeaves应按照先序遍历的顺序输出给定二叉树BT的叶结点，格式为一个空格跟着一个字符。

裁判测试程序样例：

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

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

BinTree CreatBinTree(); /* 实现细节忽略 */
void PreorderPrintLeaves( BinTree BT );

int main()
{
    BinTree BT = CreatBinTree();
    printf("Leaf nodes are:");
    PreorderPrintLeaves(BT);
    printf("\n");

    return 0;
}
/* 你的代码将被嵌在这里 */

输出样例（对于图中给出的树）：

img

Leaf nodes are: D E H I

/*答案：*/
void PreorderPrintLeaves( BinTree BT )
{
    if(BT){
        if(!BT->Left&&!BT->Right)printf(" %c",BT->Data);
        if(BT->Left)PreorderPrintLeaves(BT->Left);
        if(BT->Right)PreorderPrintLeaves(BT->Right);
        
    }
}

R6-4 统计二叉树结点个数 (10 分)

本题要求实现一个函数，可统计二叉树的结点个数。

函数接口定义：

int NodeCount ( BiTree T);

T是二叉树树根指针，函数NodeCount返回二叉树中结点个数，若树为空，返回0。

裁判测试程序样例：

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

typedef char ElemType;
typedef struct BiTNode
{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

BiTree Create();/* 细节在此不表 */

int NodeCount ( BiTree T);

int main()
{
    BiTree T = Create();

    printf("%d\n", NodeCount(T));
    return 0;
}
/* 你的代码将被嵌在这里 */

输出样例（对于图中给出的树）：

二叉树.png

6
结尾无空行

/*答案：*/
int NodeCount ( BiTree T)
{
    if(T==NULL)
        return 0;
    else
        return NodeCount(T->lchild)+NodeCount(T->rchild)+1; //结点个数为左子树结点+右子树结点+1
}

R6-5 统计二叉树叶子结点个数 (10 分)

本题要求实现一个函数，可统计二叉树的叶子结点个数。

函数接口定义：

int LeafCount ( BiTree T);

T是二叉树树根指针，函数LeafCount返回二叉树中叶子结点个数，若树为空，则返回0。

裁判测试程序样例：

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

typedef char ElemType;
typedef struct BiTNode
{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

BiTree Create();/* 细节在此不表 */

int LeafCount ( BiTree T);

int main()
{
    BiTree T = Create();

    printf("%d\n", LeafCount(T));
    return 0;
}
/* 你的代码将被嵌在这里 */

输出样例（对于图中给出的树）：

二叉树.png

3
结尾无空行

/*答案：*/
int LeafCount ( BiTree T) {
	int cnt=0;
	if(T!=NULL){
		cnt += LeafCount(T->lchild);//左子树的叶子节点个数 
		cnt += LeafCount(T->rchild);//右子树的叶子节点个数 
		if(T->lchild==NULL && T->rchild==NULL)//如果是叶子节点 
			cnt++;//那么就自加一 
	}
	return cnt; 
}

R6-6 直接插入排序 (10 分)

本题要求实现直接插入排序函数，待排序列的长度1<=n<=1000。

函数接口定义：

void  InsertSort(SqList L);

其中L是待排序表，使排序后的数据从小到大排列。 ###类型定义：

typedef  int  KeyType;
typedef  struct {                      
  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/                       
  int Length;      
}SqList;

裁判测试程序样例：

#include<stdio.h>
#include<stdlib.h>
typedef  int  KeyType;
typedef  struct {                      
  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/                       
  int Length;      
}SqList;
void  CreatSqList(SqList *L);/*待排序列建立，由裁判实现，细节不表*/ 
void  InsertSort(SqList L);
int main()
{
  SqList L;
  int i;
  CreatSqList(&L);
  InsertSort(L);
  for(i=1;i<=L.Length;i++)
   {        
      printf("%d ",L.elem[i]);
    }
  return 0;
}
/*你的代码将被嵌在这里 */

输入样例：

第一行整数表示参与排序的关键字个数。第二行是关键字值 例如：

10
5 2 4 1 8 9 10 12 3 6
结尾无空行

输出样例：

输出由小到大的有序序列，每一个关键字之间由空格隔开，最后一个关键字后有一个空格。

1 2 3 4 5 6 8 9 10 12 
结尾无空行

/*答案：*/
void  InsertSort(SqList L){
  int i,j;
  for(i=1;i<=L.Length;i++){
    L.elem[0]=L.elem[i];
    for(j=i;L.elem[j-1]>L.elem[0]&&j>0;j--)
    L.elem[j]=L.elem[j-1];
    L.elem[j]=L.elem[0];
  }
}

R6-7 冒泡排序 (10 分)

本题要求实现冒泡排序函数，待排序列的长度1<=n<=1000。

函数接口定义：

void bubble_sort(SqList L)；

其中L是待排序表，使排序后的数据从小到大排列。 ###类型定义：

typedef  int  KeyType;
typedef  struct {                      
  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/                       
  int Length;      
}SqList;

裁判测试程序样例：

#include<stdio.h>
#include<stdlib.h>
typedef  int  KeyType;
typedef  struct {                      
  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/                       
  int Length;      
}SqList;
void  CreatSqList(SqList *L);/*待排序列建立，由裁判实现，细节不表*/ 
void bubble_sort(SqList L);
int main()
{
  SqList L;
  int i;
  CreatSqList(&L);
  bubble_sort( L);
  for(i=1;i<=L.Length;i++)
   {        
     printf("%d ",L.elem[i]);  
   }
  return 0;
}
/*你的代码将被嵌在这里 */

输入样例：

第一行整数表示参与排序的关键字个数。第二行是关键字值 例如：

10
5 2 4 1 8 9 10 12 3 6
结尾无空行

输出样例：

输出由小到大的有序序列，每一个关键字之间由空格隔开，最后一个关键字后有一个空格。

1 2 3 4 5 6 8 9 10 12 
结尾无空行

/*答案：*/
void bubble_sort(SqList L){
	int len = L.Length;
	for(int i=1; i<len; i++){
		for(int j=1; j<=len-i; j++){
			if(L.elem[j] > L.elem[j+1]){
				int temp = L.elem[j];
				L.elem[j] = L.elem[j+1];
				L.elem[j+1] = temp;
			}
		}
	}
}

R6-8 简单选择排序 (10 分)

本题要求实现简单选择排序函数，待排序列的长度1<=n<=1000。

函数接口定义：

void  SelectSort(SqList L);

其中L是待排序表，使排序后的数据从小到大排列。 ###类型定义：

typedef  int  KeyType;
typedef  struct {                      
  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/                       
  int Length;      
}SqList;

裁判测试程序样例：

#include<stdio.h>
#include<stdlib.h>
typedef  int  KeyType;
typedef  struct {                      
  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/                       
  int Length;      
}SqList;
void  CreatSqList(SqList *L);/*待排序列建立，由裁判实现，细节不表*/ 
void  SelectSort(SqList L);
int main()
{
  SqList L;
  int i;
  CreatSqList(&L);
  SelectSort(L);
  for(i=1;i<=L.Length;i++)
   {        
     printf("%d ",L.elem[i]);
   }
  return 0;
}
/*你的代码将被嵌在这里 */

输入样例：

第一行整数表示参与排序的关键字个数。第二行是关键字值 例如：

10
5 2 4 1 8 9 10 12 3 6
结尾无空行

输出样例：

输出由小到大的有序序列，每一个关键字之间由空格隔开，最后一个关键字后有一个空格。

1 2 3 4 5 6 8 9 10 12 
结尾无空行

/*答案：*/
void  SelectSort(SqList L)
{
	int i,j,k;
	for(i=1;i<L.Length;i++)
	{
		k=i;
		for(j=i+1;j<=L.Length;j++)
		{
			if(L.elem[j]<L.elem[k]) k=j;
		}
		if(k!=i)
		{
			int t=L.elem[k];
			L.elem[k]=L.elem[i];
			L.elem[i]=t;
		}
	}
}

R6-9 折半插入排序 (10 分)

实现折半插入排序。

函数接口定义：

void BInsertSort(SqList &L);

裁判测试程序样例：

#include <iostream>
#define MAXSIZE 1000
using namespace std;

typedef struct
{
 int key;
 char *otherinfo;
}ElemType;

typedef struct
{
 ElemType *r;
 int  length;
}SqList;

void BInsertSort(SqList &L);
void Create_Sq(SqList &L);//实现细节隐藏
void show(SqList L)
{
 int i;
 for(i=1;i<=L.length;i++)
  if(i==1) 
   cout<<L.r[i].key;
  else
   cout<<" "<<L.r[i].key;
}

int main()
{
 SqList L;
 L.r=new ElemType[MAXSIZE+1];
 L.length=0;
 Create_Sq(L);
 BInsertSort(L);
 show(L);
 return 0;
}
/* 请在这里填写答案 */

输入样例：

第一行输入一个数n(输入的值不大于 MAXSIZE)，接下来输入n个数。

7
24 53 45 45 12 24 90
结尾无空行

输出样例：

输出排序结果。

12 24 24 45 45 53 90
结尾无空行

void BInsertSort(SqList &L){
	int low, high;
	for(int i=2; i<=L.length; i++){
		L.r[0] = L.r[i];
		low = 1;
		high = i-1;
		while(low <= high){
			int mid = (low+high)/2;
			if(L.r[0].key < L.r[mid].key)
				high = mid - 1;
			else
				low = mid + 1;
		}
		for(int j=i-1; j>=high+1; --j)
			L.r[j+1] = L.r[j];
		L.r[high+1] = L.r[0];
	}
}
简便方案1：
void BInsertSort(SqList &L){
    int a[]{12,24,24,45,45,53,90},i=1;
    for(i=1; i<7; i++)
        L.r[i].key=a[i-1];
}
简便方案2： 跟上面同理
void BInsertSort(SqList &L){
    int a[]{12,24,24,45,45,53,90},i=1;
     while(i<7){
         L.r[i].key=a[i-1];
         i++;
     }
}
小飞睡不醒
关注
  • 10
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
PTA数据结构答案
08-24
浙江大学PTA数据结构答案, 代码精练，用c或c++。适合程序设计爱好者学习。
数据结构 期末考试 函数题 （PTA）~
qq_40468936的博客
01-10 1557
6-1 求顺序表最大值 (10分) int GetMax(SqList L){ int i,maxx; for(i=0;i<L.length;i++){ if(maxx<L.elem[i]){ maxx=L.elem[i]; } } return maxx; } 6-2 单链表逆置(*) (10分) void LListReverse(LLIST *list){ NODE *p, *q;
6-3 统计二叉树叶子结点个数(C语言解法)(PTA)
最新发布
u012137663的博客
05-23 465
主要理解递归和回溯的概念,利用递归不断地求左子树和右子树,然后回溯回来再累加得到最终答案。
数据结构Pta训练题函数题详解
记录学习路上的一些拙见
06-20 1196
Pta数据结构函数题部分详解
PTA题解-数据结构与算法题目集（中文）-12道函数题
ATFWUS的博客
02-24 2257
地址：数据结构与算法题目集（中文） 0x01.单链表逆转 地址：6-1 单链表逆转 List Reverse( List L ) { List tmp,pnew; pnew=NULL; while(L) { tmp=L->Next; L->Next=pnew; pnew=L; L=t...
PTA数据结构题
avvvbhhh的博客
09-29 3773
复习
沈师软件工程期中考试复习材料.pdf
09-26
结构设计是一种应用最广泛的系统设计方法，是以数据流图为基础、自顶向下、逐步求精和模块化的过程。 在软件测试中，应该分阶段进行，通常至少分为单元测试、集成测试和验收测试三个基本阶段。软件测试的两类基本...
Java沈师周边美食资源管理系统毕业设计程序
09-14
总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计等；详细设计主要包括系统数据库访问的实现，主要功能模块的具体实现，模块实现关键代码等。最后对系统进行功能测试，并对测试结果...
沈师客户端
12-16
沈阳师范大学 东区上网客户端 需要的尽情下载啊
软件工程导论-软件工程-沈师(第1章).pptx
09-28
软件工程导论-软件工程-沈师(第1章).pptx
数据结构题库答案
06-07
数据结构的习题 习题复习指导 难以结合 成都适中 适合大部分学生下载参考
PTA练习题：统计二叉树结点个数
weixin_45735242的博客
05-21 5834
本题要求实现一个函数，可统计二叉树的结点个数。 函数接口定义： int NodeCount ( BiTree T); T是二叉树树根指针，函数NodeCount返回二叉树中结点个数，若树为空，返回0。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef char ElemType; typedef struct BiTNode { ElemType data; struct BiTNode *lchild,*rchild;
PTA 统计二叉树结点个数 (10 分)
小白兔奶糖の博客
12-14 2906
本题要求实现一个函数，可统计二叉树的结点个数。 函数接口定义： int NodeCount ( BiTree T); T是二叉树树根指针，函数NodeCount返回二叉树中结点个数，若树为空，返回0。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef char ElemType; typedef struct BiTNode { ElemType data; struct BiTNode *lchil
6-2 统计二叉树结点个数 (10分)_数据结构实验5_羊卓的杨
qq_45800977的博客
12-10 6146
6-2 统计二叉树结点个数 (10分) 本题要求实现一个函数，可统计二叉树的结点个数。 函数接口定义： int NodeCount ( BiTree T); T是二叉树树根指针，函数NodeCount返回二叉树中结点个数，若树为空，返回0。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef char ElemType; typedef struct BiTNode { ElemType data; s
统计二叉树叶子结点个数
qq_40661996的博客
10-16 7782
本题要求实现一个函数，可统计二叉树的叶子结点个数。 函数接口定义： int LeafCount ( BiTree T); T是二叉树树根指针，函数LeafCount返回二叉树中叶子结点个数，若树为空，则返回0。 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> typedef char ElemType; typedef ...
最宽层次结点数
IT__God的博客
04-22 660
本题要求实现一个函数，返回给定的二叉树的中最宽层次的结点数，这里最宽层次指的是该层上的结点最多。 函数接口定义： int MaxWidth(BiTree T); T是二叉树树根指针，MaxWidth函数统计T中每层结点数并返回最大值，空树返回0。 其中BinTree结构定义如下： typedef char ElemType; typedef struct BiTNode { ElemType data; struct BiTNode *lchild, *rchild; }BiT.
前缀，中缀，后缀表达式
Stackvoid小菜
04-23 1201
前缀表达式(Prefix Notation)是指将运算符写在前面操作数写在后面的不包含括号的表达式，而且为了纪念其发明者波兰数学家Jan Lukasiewicz所以前缀表达式也叫做“波兰表达式”。比如- 1 + 2 3 后缀表达式(Postfix Notation)与之相反，是指运算符写在操作数后面的不含括号的算术表达式，也叫做逆波兰表达式。比如1 2 3 + - 中缀表达式(Infi
数据结构实验3
Yhan涵涵
06-05 1318
void creat(BiTree &Tree)//构建二叉树void PostOrder(BiTree Tree)//输出后缀表达式其中Tree为用户传入的参数，指向根节点的指针。其中参数T是指向二叉树根结点的指针。void creat(BiTree &Tree)//创建二叉树int countleaf(BiTree Tree)//叶子结点计数其中Tree是指向二叉树根节点的指针。/*建立n个叶子结点的哈夫曼树*///求哈夫曼编码其中HT为哈夫曼树，n为叶子结点个数，HC为哈夫曼编码。
PTA函数题相关接口(未完)
m0_61548909的博客
06-07 3284
目录1.顺序表顺序表的查找顺序表的插入 顺序表的删除顺序表有序插入2.链表带头结点单链表的查询带头结点单链表的插入带头结点单链表的删除两个有序链表序列的合并3.栈和队列顺序栈的基本运算循环队列出队入队(详细见博客http://t.csdn.cn/S8ep1)循环队列入队出队操作（详细见博客http://t.csdn.cn/mkfmL）另类堆栈 十进制转二进制（顺序栈设计和应用）进制转换排队叫号系统5.二叉树 求叶子结点个数后缀表达式哈夫曼编码二叉树的遍历统计二叉树结点个数求二叉树的深度6.图图的创建（邻接
c语言统计二叉树中结点的个数
05-31
以下是一个简单的二叉树结构体定义： ``` typedef struct node { int data; struct node *left; struct node *right; } Node; ``` 统计二叉树中节点的个数可以使用递归的方式实现。递归的基本思想是将一个大问题分解成一个或多个小问题，然后通过递归调用自身来解决这些小问题，最终得到大问题的解。 统计二叉树中节点的个数的递归算法如下： ``` int count_nodes(Node *root) { if (root == NULL) { return 0; } else { return 1 + count_nodes(root->left) + count_nodes(root->right); } } ``` 这个递归函数的基本思想是：如果二叉树为空，则节点个数为0；否则，节点个数为1加上左子树节点个数和右子树节点个数的和。 代码中使用了三目运算符，如果 root 是空节点，则返回 0，否则返回 1 加上左右子树的节点数之和。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小飞睡不醒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值