数据结构复习 | 选填板子

已于 2024-06-28 15:17:50 修改
阅读量220 收藏 2
点赞数 6
文章标签： 数据结构
于 2024-06-28 15:15:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79402731/article/details/140044042
版权

整理了数据结构课程期末常考的选填题，用C实现求解，方便考试快速解答~

一、二叉树的恢复

前+中->后

已知树的前序遍历和中序遍历序列，输出后序遍历序列。

例题：

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
struct TreeNode{
    int val;
    struct TreeNode *left,*right;
};

//接收一个子根，创造左右子树
void createTree(struct TreeNode **T,int *preOrder,int preStart,int preEnd,int *inOrder,int inStart,int inEnd)
{
    if(inStart>inEnd)
        return ;
    (*T)=(struct TreeNode *)malloc(sizeof(struct TreeNode));
    (*T)->val=preOrder[preStart];
    (*T)->left=(*T)->right=NULL;
    if(preStart==preEnd)
        return ;
    int headVal=preOrder[preStart];
    int index=0;
    while(inOrder[index]!=headVal)      //index指向子根
        index++;
    int n=index-inStart;
    createTree(&(*T)->left,preOrder,preStart+1,preStart+n,inOrder,inStart,index-1);
    createTree(&(*T)->right,preOrder,preStart+n+1,preEnd,inOrder,index+1,inEnd);
}
struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize)
{
    struct TreeNode *root=NULL;
    createTree(&root,preorder,0, preorderSize-1,inorder,0,inorderSize-1);
    return root;
}
void postTravel(struct TreeNode *root)
{
    if(root)
    {
        postTravel(root->left);
        postTravel(root->right);
        printf("%d ",root->val);
    }
}

int main(int argc, const char * argv[]) {
    
    int pre[100],in[100];
    int preSize,inSize;
    scanf("%d%d",&preSize,&inSize);     //先输入数组元素个数
    int i;
    for(i=0;i<preSize;i++)
        scanf("%d",&pre[i]);            //再输入前序序列
    for(i=0;i<inSize;i++)
        scanf("%d",&in[i]);             //再输入中序序列
    struct TreeNode *root=buildTree(pre,preSize,in,inSize);
    postTravel(root);                   //输出后序遍历结果
    
    return 0;
}

中+后->前

例题：

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
struct TreeNode{
    int val;
    struct TreeNode *left,*right;
};

struct TreeNode *travelTree(int *inorder, int inBegin, int inEnd, int *postorder, int postBegin, int postEnd){
    if(postBegin>postEnd)
        return NULL;    //没有元素

    struct TreeNode *root=(struct TreeNode *)malloc(sizeof(struct TreeNode));
    root->val=postorder[postEnd];
    root->left=NULL;
    root->right=NULL;
    
    if(postBegin==postEnd)
        return root;    //只有一个元素，就是根节点
 
    int inRoot;
    for(inRoot=inBegin;inorder[inRoot]!=postorder[postEnd];inRoot++)
        ;
    root->left=travelTree(inorder,inBegin,inRoot-1,postorder,postBegin,postBegin+inRoot-inBegin-1);
    root->right=travelTree(inorder,inRoot+1,inEnd,postorder,postBegin+inRoot-inBegin,postEnd-1);
    return root;
}
struct TreeNode* buildTree2(int* inorder, int inorderSize, int* postorder, int postorderSize){
    struct TreeNode *root=NULL;
    if(inorderSize)
        root=travelTree(inorder,0,inorderSize-1,postorder,0,postorderSize-1);
    return root;
}
void preTravel(struct TreeNode *root)
{
    if(root)
    {
        printf("%d ",root->val);
        preTravel(root->left);
        preTravel(root->right);
    }
}

int main(int argc, const char * argv[]) {
    
    int in[100],post[100];
    int inSize,postSize;
    scanf("%d%d",&inSize,&postSize);     //先输入数组元素个数
    int i;
    for(i=0;i<inSize;i++)
        scanf("%d",&in[i]);              //再输入中序序列
    for(i=0;i<postSize;i++)
        scanf("%d",&post[i]);            //再输入后序序列
    struct TreeNode *root=buildTree2(in,inSize,post,postSize);
    preTravel(root);                     //输出前序遍历结果
    
    return 0;
}

二、堆排序

下标从1起，输入一组数据，输出构成的大顶堆并排序。

例题：

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

void adjust(int a[],int i,int n)        //调整堆，i要调整的堆（可以是一小部分）的root下标
{
    int j,temp;
    temp=a[i];
    j=2*i;                          //j是i的左孩子
    while(j<=n)
    {
        if(j<n && a[j]<a[j+1])      //j是较大的那个子结点
            j++;
        if(temp>=a[j])              //已满足堆
            break;
        a[j/2]=a[j];                //父亲比孩子小，需要交换
        j=2*j;
    }
    a[j/2]=temp;
}
void heapSort(int a[],int n)
{
    int i,temp;
    for(i=n/2;i>=1;i--)     //初始化堆
        adjust(a,i,n);
    for(i=1;i<=n;i++)
        printf("%d ",a[i]);     //输出大顶堆
    for(i=n-1;i>=1;i--)
    {
        temp=a[i+1];
        a[i+1]=a[1];        //最大元素放队尾
        a[1]=temp;
        adjust(a,1,i);
    }
}

int main(int argc, const char * argv[]) {
    
    int dui[100];
    int n;
    scanf("%d",&n); //先输入元素个数
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&dui[i]);    //逐个输入
    }
    heapSort(dui,n);    //实现堆排序，过程中可以输出首次成的大顶堆//
    
    return 0;
}

三、出栈合理性判断

给出入栈出栈序列，判断出栈顺序是否合理，如果合理，求栈需要开多大。

例题：

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

int in[105];    //入栈序列
int out[105];   //出栈序列
int stack3[105];
int top3=-1;

int main(int argc, const char * argv[]) {
    
    int n;
    scanf("%d",&n); //输入元素个数
    int i,j,cnt=0;
    for(i=0;i<n;i++)
        scanf("%d",&in[i]); //输入入栈元素，保证各不相同
    for(j=0;j<n;j++)
        scanf("%d",&out[j]);//输入出栈元素，保证各不相同
    j=0;
    for(i=0;i<n;i++)
    {
        stack3[++top3]=in[i]; //当前元素进栈
        if(top3+1>cnt)
            cnt=top3+1;  //更新cnt
        while(top3>=0 && out[j]==stack3[top3])
        {
            printf("%d ",stack3[top3]);   //输出实际出栈序列
            j++;
            top3--;
        }
    }
    if(top3==-1)
        printf("\n%d",cnt); //输出最大栈容量
    else 
        printf("\n不合法"); //没有全部出栈，不合法
        
    return 0;
}

四、Josephus问题

n个人，从编号为k的人开始报数，数到m的人出列，他的下一个人从1开始报数，直到全部出列。输出淘汰序列。

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

typedef struct jnode{
    int num;
    struct jnode *next;
}*NodePtr;

void JosephusNode(int n,int m,int k)    //n个人，从编号为k的人开始报数，数到m的人出列
{
    NodePtr list=NULL,p=NULL,r=NULL;
    int i;
    for(i=1;i<=n;i++)
    {
        p=(NodePtr)malloc(sizeof(struct jnode));
        p->num=i;
        if(list==NULL)
            list=p;
        else
            r->next=p;
        r=p;
    }
    p->next=list;
    p=list;     //建立一个循环链表
    
    for(i=1;i<k;i++)    //p指向第一个出发结点
    {
        r=p;
        p=p->next;
    }
    
    while(p->next!=p)       //跳出循环时只剩一个结点
    {
        for(i=1;i<m;i++)    //该把p指的删掉
        {
            r=p;
            p=p->next;
        }
        r->next=p->next;
        printf("%4d",p->num);   //输出被删掉的结点号
        free(p);
        p=r->next;
    }
    printf("\nlast out: %4d\n",p->num);
}

int main(int argc, const char * argv[]) {
    
    int n,m;
    scanf("%d%d",&n,&m);    //输入
    JosephusNode(n,m,1);    //过程中输出淘汰成员
    
    return 0;
}

五、哈夫曼树

以一组权值构建哈夫曼树，求带权路径和。

例题：

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

struct hnode{  //树结点
    int val;    //自身值，也即权值
    struct hnode *lchild,*rchild;
    struct hnode *next;     //按频率（由小到大）排的链表
};

struct hnode *hroot;     //哈夫曼树根
struct hnode *hhead;     //head指向头节点，便于建树
int hcnt;

struct hnode *createHNode(int val)
{
    struct hnode *p=(struct hnode *)malloc(sizeof(struct hnode));
    p->val=val;
    p->lchild=p->rchild=p->next=NULL;
    return p;
}
void insertHLink(struct hnode *p)
{
    struct hnode *q;
    for(q=hhead;q->next && p->val>=q->next->val;q=q->next)
        ;
    p->next=q->next;
    q->next=p;
}
void hdfs(struct hnode *r,int step)     //当前在第step层，root为第1层
{
    if(r==NULL)
        return ;
    if(r->lchild==NULL && r->rchild==NULL)
    {
        hcnt+=(step-1)*r->val;
    }
    hdfs(r->lchild,step+1);
    hdfs(r->rchild,step+1);
}

int main(int argc, const char * argv[]) {
    
    int n;
    scanf("%d",&n);     //输入数据数
    int i,tmp;
    hhead=createHNode(824);
    for(i=0;i<n;i++)
    {
        scanf("%d",&tmp);   //依次输入数据
        struct hnode *p=createHNode(tmp);
        insertHLink(p);
    }
    while(hhead->next->next)
    {
        struct hnode *q1,*q2,*qq;
        q1=hhead->next;
        q2=hhead->next->next;
        qq=createHNode(q1->val+q2->val);
        qq->lchild=q1;
        qq->rchild=q2;
        hhead->next=q2->next;
        insertHLink(qq);
    }
    hroot=hhead->next;
    hdfs(hroot,1);
    printf("%d",hcnt);      //打印带权路径总和
    
    return 0;
}

六、队列个数

例题：

#include <stdio.h>

int main(int argc,const char *argv[]){
    int n;
    scanf("%d",&n);         //输入数据总数
    int in[105],out[105];   //out[i]是第i个出队元素对应的进队下标0~n-1

    //进队序列是：e1,e2,e3,e4,e5,e6,e7,e8,e9
    int i,j,k,w,temp;
    for(i=1;i<=n;i++)
        scanf("%d",&in[i]);  //输入入队序列
    for(i=1;i<=n;i++)        //出队序列是e8,e4,e2,e5,e3,e9,e1,e6,e7
    {
        scanf("%d",&temp);   //输入出队序列
        for(j=1;j<=n;j++)
        {
            if(temp==in[j])
            {
                out[i]=j;
                break;
            }
        }
    }
    int queue[25][25];
    int qtop=-1;
    for(i=0;i<25;i++)
    {
        for(j=0;j<25;j++)
            queue[i][j]=0;
    }
    queue[++qtop][0]=out[1];
    for(i=2;i<=n;i++)
    {
        k=-1;
        for(j=0;j<=qtop;j++)
        {
            w=0;
            while(queue[j][w+1])
                w++;
            if(out[i]>queue[j][w])
            {
                if(k==-1 || queue[j][0]>queue[k][0])    //更优，更新k
                    k=j;
            }
        }
        if(k==-1)       //需要新建队
            queue[++qtop][0]=out[i];
        
        else    //入已存在的队
        {
            j=1;
            while(queue[k][j]!=0)       //一定是插在队尾
                j++;
            queue[k][j]=out[i];
        }
    }
    for(i=0;i<=qtop;i++)
    {
        j=0;
        while(queue[i][j]!=0)
        {
            printf("%d ",queue[i][j]);      //把输出序列按队输出
            j++;
        }
        puts("");
    }
    return 0;
}

  • 测试样例

    输入：

    9
1 2 3 4 5 6 7 8 9
8 4 2 6 3 9 1 5 7

    输出：

    8 9 
4 6 7
2 3 5
1
Chase Tsai
关注
  • 6
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
王道数据结构课后选填汇总
02-19
本汇总主要基于"王道数据结构"教材，旨在为考研复习提供帮助，特别是针对那些正在二刷数据结构的学生。下面将对第二章和第三章的主要知识点进行详尽的解析。 第二章通常涵盖线性结构，特别是数组和链表这两种基本的...
Web前端技术（期末复习 选填、判断、简答、编程等超全总结）.zip
07-17
这份名为"Web前端技术（期末复习 选填、判断、简答、编程等超全总结）.zip"的压缩包文件包含了全面的Web前端学习资源，适合期末复习和备考。以下是基于该压缩包文件可能包含的知识点的详细说明： 1. HTML...
北航数据结构与程序设计第五次作业选填题复习
zxy13149285776的博客
06-11 1306
满二叉树的深度和结点个数关系：n=2^h-1,则h=log(n+1),可得深度为：log(2048)=11,最后一层的节点个数，也就是叶结点个数为n=2 ^ (h-1)=2 ^ 10 = 1024。注意，当二叉查找树退化时，也就是说，差不多快变成一个链表的时候（左右子树深度之差过大），那么这个时候查找的时间复杂度就和在链表里查找的时间复杂度差不多了，就变成O(n)了。建立好的二叉查找树如上图，62先和54比，再和73比，再和62比，发现找到，结束比较，工比较三次。
北航数据结构与程序设计第四次作业选填题复习
zxy13149285776的博客
06-05 600
BUAA数据结构与程序设计第4次作业选填题
BUAA 数据结构总结
热门推荐
Schrodinger007的博客
07-05 1万+
概要 2021春 数据结构课程 上机作业编程题 各章知识点总结 期中期末考试题 编程代码超详细注释 目录 BUAA 数据结构总结——第1节 BUAA 数据结构总结——第2节 BUAA 数据结构总结——第3节 BUAA 数据结构总结——第4节（栈和队） BUAA 数据结构总结——第5节（树） BUAA 数据结构总结——第6节（查找与排序） BUAA 数据结构总结——第7节（图） BUAA 数据结构总结——大作业（文本摘要生成） 2020级期末考试 ......
BUAA数据结构第三次作业2023
weixin_50567399的博客
04-13 3829
BUAA数据结构第三次上机作业
太原理工期末数据结构复习（划重点）
m0_60416689的博客
12-23 997
第一章 P5 4类基本结构 P6 数据元素的两种不同表示方法：顺序影响和非顺序映像->两种不同的存储结构：顺序存储结构和链式存 储结构 非链式存储映像借助指示元素存储地址的指针表示数据元素之间的逻辑关系 P9 三元组的定义、多型数据结构 P10 预定义常量和类型 P12 抽象数据类型 P13 算法的5个重要特性：输入、输出、可行性、确定性、有穷性 算法目标：正确性、可读性、健壮性、效率与低存储量需求 P15 时间复杂度、空间复杂度 P17 原地工作：若额外空间相
数据库期末复习选填 题知识点
06-30
- **Database (DB)**：一组相关数据的集合，具有一定的组织结构。 - **Database Management System (DBMS)**：用于创建、管理和维护数据库的软件系统，如Oracle、MySQL、SQL Server等。 - **Database System (DBS...
python选填，复习资料
06-19
**列表**是一种非常常用的数据结构，在Python中列表可以包含多种不同类型的元素。例如： ```python Ls = [12, 34.5, [True, 'test'], 3+5j] ``` 在这个例子中，`Ls`是一个列表，其中包含了整数、浮点数、另一个列表...
云南专版2019年中考化学总复习题型复习二多结论选填题习题
08-06
【知识点详解】 1. 质量守恒定律：题目中提到1...综上所述，这些题目涉及了化学中的多个核心概念，包括基本化学定律、反应类型、物质性质、化学反应条件、溶液与溶解度、原子结构、物质鉴别和化学反应中的定量关系等。
【数据结构】—— 树和二叉树
mist的博客
08-26 708
树和二叉树、堆（顺序结构）、二叉树链式结构
【Redis】Redis 底层的数据结构（结合源码）
秋玄的博客
08-22 905
Redis 底层数据结构详解
数据结构：用栈实现队列（232）LeetCode
最新发布
2303_81073778的博客
08-26 222
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
重新理解操作系统（linux）、编程语言和算法与数据结构
crawer
08-23 411
怎样理解操作系统（linux）、编程语言和算法与数据结构
算法的学习笔记—二叉搜索树的后序遍历序列(牛客JZ33)
业精于勤，荒于嬉
08-22 840
通过递归地判断数组的子序列是否满足二叉搜索树的性质，我们可以有效地判断一个数组是否是某二叉搜索树的后序遍历序列。这个方法在逻辑上比较直观，并且能够处理复杂的情况，尽管其时间复杂度为O(n^2)，但在实际应用中仍然是一个实用的算法。希望通过这篇文章，大家能够更加深入地理解二叉搜索树及其后序遍历的相关概念，并掌握如何通过编程来解决这类问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVC。
数据结构-KMP算法
m0_37564426的博客
08-25 108
前缀与后缀串的最长匹配长度信息。
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 315
浅谈【数据结构】树与二叉树之哈夫曼树
数据结构（邓俊辉）学习笔记】优先级队列 08——左式堆：结构
weixin_44399845的博客
08-23 955
学习左式堆的结构
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 654
KMP算法：理解next[]表
计算机组成原理选填笔记：解题与体系结构详解
"这份计算机组成原理选填做题笔记是针对计算机组成原理课程的学习资料，主要针对期末复习和理解巩固。笔记内容包括计算机系统概述、运算方法与运算器、存储系统、指令系统、中央处理器等多个章节，涵盖了重要的概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值