PTA合集

最新推荐文章于 2024-09-06 16:35:02 发布
最新推荐文章于 2024-09-06 16:35:02 发布
阅读量137 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Treasuredd/article/details/127602383
版权

堆栈操作合法性
#include<stdio.h>

int main()
{
    //输入栈容量和操作数，用length表示栈内现有元素个数
    int Ssize, oper, counter, length = 0,flag = 0;
    scanf("%d %d ",&oper, &Ssize);
    for(counter = 0; counter < oper; counter ++) {
        char chr;
        //s入栈，length加一,x出栈，length减一
        while((chr = getchar()) != '\n') {
            if(chr == 'S') {
                length++;
                if(length > Ssize)
                    flag = 1;
            }
            if(chr == 'X') {
                length--;
                if(length < 0)
                    flag = 1;
            }
        }
        if(length == 0 && flag == 0)
            printf("YES\n");
        else
            printf("NO\n");
        length = 0;
        flag = 0;
    }
    return 0;
}
求链式线性表的倒数第K项
#include<stdio.h>
#include<malloc.h>
struct Node{
    int data;
    struct Node *next;
};
int main()
{
    int k,t,i;
    scanf("%d",&k);
    struct Node *head,*p;
    head=(struct Node *)malloc(sizeof(struct Node));
    head->next=NULL;
    while(scanf("%d",&t)&&t>=0)
    {
        p=(struct Node *)malloc(sizeof(struct Node));
        p->data=t;
        p->next=head->next;
        head->next=p; 
    }
    for(i=0;i<k;i++)
    head=head->next;
    if(head) printf("%d",head->data);
    else printf("NULL");
}
————————————————
两个有序链表序列的交集
//库函数头文件包含
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

//函数状态码定义
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
typedef int ElemType; //假设线性表中的元素均为整型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

//打印链表中的数据
void ListPrint_L(LinkList &L)
{
    if (L->next == NULL)
    {
        printf("NULL");
        return;
    }
    //输出单链表
    LNode *p = L->next; // p指向第一个元素结点
    while (p != NULL)
    {
        if (p->next != NULL)
            printf("%d ", p->data);
        else
            printf("%d", p->data);
        p = p->next;
    }
}
//为链表添加结点，需要传入直接前驱
LNode *addLNode(LinkList &L, ElemType e)
{
    L->next = (LinkList)malloc(sizeof(LNode));
    if (!(L->next))
    {
        exit(OVERFLOW);
    }
    L->next->data = e;
    L->next->next = NULL;
    return L->next;
}

Status ListCreate_L(LinkList &L)
{
    L = (LNode *)malloc(sizeof(LNode));
    L->next = NULL;
    if (!L)
    {
        exit(OVERFLOW);
    }
    LNode *p = L;
    int num = 0;
    while (scanf("%d", &num) != EOF)
    {
        if (num == -1)
        {
            break;
        }
        p = addLNode(p, num);
    }
    return OK;
}

LNode *LinkOrderList(LinkList &L1, LinkList &L2)
{
    LNode *head = (LNode *)malloc(sizeof(LNode));
    head->next = NULL;
    //列表有一个为空的情况
    if ((L1->next) && (L2->next))
    {
        LNode *s = L1, *t = L2, *p = head;
        while ((s->next) && (t->next))
        {
            if ((s->next->data) > (t->next->data))
            {
                t = t->next;
            }
            else if ((s->next->data) < (t->next->data))
            {
                s = s->next;
            }
            else
            {
                p = addLNode(p, s->next->data);
                s = s->next;
                t = t->next;
            }
        }
    }
    return head;
}

int main()
{
    LNode *L1 = (LNode *)malloc(sizeof(LNode)), *L2 = (LNode *)malloc(sizeof(LNode));
    ListCreate_L(L1);
    ListCreate_L(L2);
    LNode *head = LinkOrderList(L1, L2);
    ListPrint_L(head);
    return 0;
}
两个有序链表序列的合并
//库函数头文件包含
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

//函数状态码定义
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
typedef int ElemType; //假设线性表中的元素均为整型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

Status ListCreate_L(LinkList &L)
{
    L = (LNode *)malloc(sizeof(LNode));
    if (!L)
    {
        exit(OVERFLOW);
    }
    L = (LNode *)malloc(sizeof(LNode));
    LNode *tmp = L;
    int n = 0, num = 0;
    while (scanf("%d", &num) != EOF)
    {
        if (num == -1)
        {
            break;
        }
        tmp->next = (LNode *)malloc(sizeof(LNode));
        tmp->next->data = num;
        tmp = tmp->next;
        n++;
    }
    tmp->next = NULL;
    L->data = n;
    return OK;
}

void ListPrint_L(LinkList &L)
{
    if (L->next==NULL) {
        printf("NULL");
        return ;
    }
    //输出单链表
    LNode *p = L->next; // p指向第一个元素结点
    while (p != NULL)
    {
        if (p->next != NULL)
            printf("%d ", p->data);
        else
            printf("%d", p->data);
        p = p->next;
    }
}

LNode *LinkOrderList(LinkList &L1, LinkList &L2)
{
    //确定头部最小的序列
    if (!(L1->next)) {
        return L2;
    }
    if (!(L2->next)) {
        return L1;
    }
    LinkList p = L1->next, t = L2->next;
    if ((L1->next->data) > (L2->next->data))
    {
        p = L2->next, t = L1->next;
    }
    while (p->next != NULL && t != NULL)
    {
        if ((p->next->data) > (t->data))
        {
            LinkList s = p->next;
            p->next = t;
            t = s;
        }
        else
        {
            p = p->next;
        }
    }
    p->next = t;
    return L1;
}

int main()
{
    LinkList L1, L2;

    if (ListCreate_L(L1) != OK)
    {
        printf("表创建失败！！！\n");
        return -1;
    }
    if (ListCreate_L(L2) != OK)
    {
        printf("表创建失败！！！\n");
        return -1;
    }
    LNode *head = LinkOrderList(L1, L2);
    ListPrint_L(head);
    return 0;
}
————————————————
带头结点的单链表就地逆置
void ListReverse_L(LinkList &L)//L为头结点
{
    LinkList p,q;
    p = L->next;
    L->next = NULL;
    while(p)
    {
        //向后挪
        q = p;//
        p = p->next;
        //头插
        q->next = L->next;//非常重要，相当于p和q之间没有了指针连接
        L->next = q;//把q接到头的后面
    }
}
7-2 jmu-ds-顺序表区间元素删除
#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;

//顺序表的存储结构定义
#define LIST_INIT_SIZE 11
#define LISTINCREMENT 10
typedef int ElemType; //假设线性表中的元素均为整型
typedef struct
{
    ElemType *elem; //存储空间基地址
    int length;     //表中元素的个数
    int listsize;   //表容量大小
} SqList;           //顺序表类型定义

Status InitList_Sq(SqList &L)
{
    //初始化L为一个空的有序顺序表
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if (!L.elem)
        exit(OVERFLOW);
    L.listsize = LIST_INIT_SIZE;
    L.length = 0;
    return OK;
}

Status ListInsert_Sq(SqList &L, int pos, ElemType e)
{
    if (L.length == L.listsize)
    {
        ElemType *tmp = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if (!tmp)
            exit(OVERFLOW);
        L.elem = tmp;
    }
    if (pos > L.length + 1 || pos < 1)
    {
        return ERROR;
    }
    for (int i = L.length; i > pos - 1; i--)
    {
        L.elem[i] = L.elem[i - 1];
    }
    L.elem[pos - 1] = e;
    L.length++;
    return OK;
}

Status ListDelete_Sq(SqList &L, int pos)
{
    for (int i = pos - 1; i < L.length; i++)
    {
        L.elem[i] = L.elem[i + 1];
    }
    L.length--;
    return OK;
}

void ListPrint_Sq(SqList L)
{
    for (int i = 0; i < L.length - 1; i++)
    {
        printf("%d ", L.elem[i]);
    }
    printf("%d\n", L.elem[L.length - 1]);
}

int main()
{
    SqList L;
    if (InitList_Sq(L) != OK)
    {
        printf("InitList_Sq: 初始化失败！！！\n");
        return -1;
    }
    int n = 0;
    int tmp = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &tmp);
        ListInsert_Sq(L, i, tmp);
    }
    ElemType min = 0, max = 0;
    scanf("%d", &min);
    scanf("%d", &max);
    // if (min > max)
    // {
    //     tmp = min;
    //     min = max;
    //     max = tmp;
    // }

    for (int i = 0; i < L.length;)
    {
        if (min <= L.elem[i] && L.elem[i] <= max)
        {
            ListDelete_Sq(L, i + 1);
        }
        else
        {
            i++;
        }
    }
    ListPrint_Sq(L);
    return 0;
}
————————————————
版权声明：本文为CSDN博主「Treasuredd」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Treasuredd/article/details/127593118

有序顺序表的插入
Status ListInsert_SortedSq(SqList &L, ElemType e)
{
    if (L.length == L.listsize)
    {
        L.elem = (ElemType *)realloc(L.elem, (1 + L.length) * sizeof(ElemType));
    }
    int j = L.length;
    for (; j > 0; j--)
    {
        if (e > L.elem[j - 1])
        {
            break;
        }
        else
        {
            L.elem[j] = L.elem[j - 1];
        }
    }
    L.elem[j] = e; 
    L.length = L.length + 1;

    return OK;
}
————————————————
版权声明：本文为CSDN博主「Treasuredd」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Treasuredd/article/details/127593105
顺序表创建和就地逆置
Status ListCreate_Sq(SqList &L) {
        //初始化L为一个空的有序顺序表
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if (!L.elem)
        exit(OVERFLOW);
    L.listsize = LIST_INIT_SIZE; //顺序表的容量
    L.length = 0;                //顺序表的元素个数
    int n = 0;
    
    scanf("%d",&n);
    for (int i=0;i<n;i++) {
        scanf("%d",&(L.elem[i]));
        L.length ++;
    }
    return OK;
}

void ListReverse_Sq(SqList &L) {
    for (int i=0;i<L.length/2;i++) {
        ElemType tmp = L.elem[i];
        L.elem[i] = L.elem[L.length-1-i];
        L.elem[L.length-1-i] = tmp;
    }
}
————————————————
版权声明：本文为CSDN博主「Treasuredd」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Treasuredd/article/details/127593099
循环单链表区间删除
Status ListCreate_CL(LinkList &CL)
{
    CL = (LinkList)malloc(sizeof(LNode));
    LinkList rear = CL;
    rear->next = NULL;
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        LNode *t = (LNode*)malloc(sizeof(LNode));
        scanf("%d",&t->data);
        t->next = rear->next;
        rear->next=t;
    }
    rear->next = CL;
    return OK;
}

void ListDelete_CL(LinkList &CL,ElemType min,ElemType max)
{
    LNode *p = CL;
    LNode *q;
    while(p->next !=CL)
    {
        q=p->next;
        if(p->data>min&&p->data<max)
        {
            p-next = q-next;
            free(q);
        }
        else
            p=p->next;
    }
}
————————————————
版权声明：本文为CSDN博主「Treasuredd」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Treasuredd/article/details/127593030
顺序表基本操作
Status ListInsert_Sq(SqList &L, int pos, ElemType e)
{
    if (L.length == L.listsize)
    {
        ElemType *tmp = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if (!tmp)
            exit(OVERFLOW);
        L.elem = tmp;
    }
    if (pos > L.length + 1 || pos < 1)
    {
        return ERROR;
    }
    for (int i = L.length; i > pos - 1; i--)
    {
        L.elem[i] = L.elem[i - 1];
    }
    L.elem[pos - 1] = e;
    L.length++;
    return OK;
}

void ListPrint_Sq(SqList L)
{
    for (int i = 0; i < L.length - 1; i++)
    {
        printf("%d ", L.elem[i]);
    }
    printf("%d\n", L.elem[L.length - 1]);
}

Status ListDelete_Sq(SqList &L, int pos, ElemType &e)
{
    e = L.elem[pos - 1];
    for (int i = pos - 1; i < L.length; i++)
    {
        L.elem[i] = L.elem[i + 1];
    }
    L.length--;
    return OK;
}

int ListLocate_Sq(SqList L, ElemType e)
{
    for (int i = 0; i < L.length; i++)
    {
        if (L.elem[i] == e)
        {
            return i + 1;
        }
    }
    return 0;
}
 
————————————————
版权声明：本文为CSDN博主「Treasuredd」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Treasuredd/article/details/127592982

Treasuredd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python练习6——PTA
晚风微凉的博客
11-19 1万+
7-1 重复元素查找 (100 分) 每一个列表中只要有一个元素出现两次，那么该列表即被判定为包含重复元素。 编写程序：对n行字符串进行处理，一行字符串构成一个列表。程序判定每一个列表中是否包含重复元素。最后统计包含重复元素的行数与不包含重复元素的行数。 输入格式: 输入n，代表接下来要输入n行字符串。 然后输入n行字符串，字符串之间的元素以空格相分隔。 输出格式: True=包含重复元素的行数 False=不包含重复元素的行数 输入样例: 5 1 a 3 c 5 a 3 c 5 d
python PTA合集
神威的博客
10-17 8847
**************传送门**************可逆素数 (30 分)把字符串中十六进制字符转换成十进制整数 (25 分)Python-任意多行字符串拆分数值求和 (20 分)统计并输出字符串中小写元音字母的个数 (30 分)JMU-Python-分段函数 (20 分)集合和列表，按从小到大的顺序组合成一个字典 (10 分)字符串判等 (10 分)字符串相减 (100 分)能被3,5和7整除的数的个数（用集合实现） (30 分)字典输入输出 (15 分)统计字符频次 (10 分)统计字符串中每
C语言版数据结构与算法pta合集：7-8 汉诺塔（Lanqiao）
我就知道你会来，我们一起进步吧！
01-07 757
汉诺塔是一个古老的数学问题：有三根杆子 A，B，C。A 杆上有 N 个 (N>1) 穿孔圆盘，盘的尺寸由下到上依次变小。要求按下列规则将所有圆盘移至 C 杆：每次只能移动一个圆盘大盘不能叠在小盘上面提示：可将圆盘临时置于B杆，也可将从A杆移出的圆盘重新移回A杆，但都必须遵循上述两条规则。问：如何移？最少要移动多少次？
C语言版数据结构与算法pta合集:6-1 字符串copy---最简方法
我就知道你会来，我们一起进步吧！
01-10 524
在这里描述函数接口。例如： void fun(char str1[],char str2[ ]);将str2中内容拷贝到str1.
PTA 中文题目题解合集
幸愉编程·信奥编程私教1v1
01-31 2478
文章目录1001 害死人不偿命的(3n+1)猜想1002 写出这个数1003 我要通过！1004 成绩排名1005 继续(3n+1)猜想 1001 害死人不偿命的(3n+1)猜想 #include <cstdio> using namespace std; int main() { int n; scanf("%d",&n); int step = 0; while(n != 1) { if(n&1) n = n*3 +
PTA甲级总合集
qq_61793850的博客
08-15 388
PTA甲级题单 题号 标题（题解） 相关算法 做题时间 易错点 1001 A+B Format (20分) 字符串处理 23.8.14 第一个字符不能是逗号 1002 A+B for Polynomials (25分) 字符串中等模拟 23.8.14 输出保留一位有效数字 1003 Emergency (25 分) Dij图最短路 23.8.14 最短路的条数问题 1004 Countin
PTA L2 题目合集
LJR的博客
03-21 1310
PTA L2 家庭房产 最长对称子串树的遍历集合相似度列车调度 愿天下有情人都是失散多年的兄妹人以群分 多项式A除以B 悄悄关注 功夫传人紧急救援链表去重 这是二叉搜索树吗？月饼 总结 题解 整理 并查集
PTA L1 题目合集
LJR的博客
03-20 830
天梯 PTA 题解 全部 L1 谁是赢家 L1-056 猜数字 20 L1-057 PTA使我精神焕发 L1-058 6翻了 L1-059 敲笨钟 L1-060 心理阴影面积 L1-061 新胖子公式 L1-049 天梯赛座位分配 L1-025 正整数A+B L1-059 敲笨钟 L1-023 输出GPLT L1-006 连续因子
C语言版数据结构与算法pta合集：7-3 括号匹配
我就知道你会来，我们一起进步吧！
01-08 1307
本题目要求读入n个字符串，每个字符串是一个括号序列，如“{[()]}”，然后判断每个括号序列是否匹配。
[选择题合集] FZU2023 PTA 面向对象程序设计错题合集
qq_37001721的博客
05-17 379
D.编写一个类时，至少要写一个成员函数（错误，一个类可以没有成员函数和属性）B.一个类的私有成员函数内部不能访问本类的私有成员函数（错误，可以访问）B.成员函数内的this指针指向成员函数所作用的对象。A.const成员函数内部不可以使用this指针。2.以下关于this指针的说法不正确的是（A）3.下列关于构造函数的描述中，错误的是（D）A.每个对象内部都有成员函数的实现代码。D.在析构函数内部可以使用this指针。C.类的成员函数之间可以相互调用。C.要执行的函数的内部结构。B.要执行的函数的名字。
PTA 复习 6-6 带头结点的链式表操作集 (知识点总结)
weixin_44640697的博客
12-19 901
PTA 复习 6-6 带头结点的链式表操作集 本题要求实现带头结点的链式表操作集。 文章目录PTA 复习 6-6 带头结点的链式表操作集本题要求实现带头结点的链式表操作集。函数接口定义：裁判测试程序样例：输入样例：输出样例：解题代码：一、细节分析：二、知识点总结：1、有表头和没有表头的的区别：链表的基础知识：需要注意的情况：带有头结点遍历输出数据时`while (Head->Next != NULL)`不带有头结点的链表输出数据时`while (Head != NULL)`2
【PTA】L1-016 验证身份(C++)_c++l1-016 查验身份证
2401_84620303的博客
04-26 781
首先对前17位数字加权求和，权重分配为：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
pta乙级题库答案c语言1004
08-10
你可以参考题解合集来获得该题的具体答案。1 #### 引用[.reference_title] - *1* [<em>PTA乙级题解(112)](https://blog.csdn.net/qq_51774501/article/details/127828525)[target="_blank" data-report-click={"spm...
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 305
AVL树
栈—数据结构
weixin_63722559的博客
09-06 708
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
【数据结构-二维前缀和】力扣1277. 统计全为 1 的正方形子矩阵
sjsjs11的博客
09-06 160
该题和力扣221.最大正方形类似，以某一格为右下角能形成最大正方形的边长，就是以该格为右下角的正方形数量。给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。正方形的总数 = 10 + 4 + 1 = 15.正方形的总数 = 6 + 1 = 7.边长为 1 的正方形有 10 个。边长为 2 的正方形有 4 个。边长为 3 的正方形有 1 个。边长为 1 的正方形有 6 个。边长为 2 的正方形有 1 个。输入：matrix =
数据结构之“双向链表”
最新发布
2402_83250773的博客
09-06 626
双向链表，顺序表与链表的比较
PTA甲级英语词汇解析
"PTA甲级英语单词.txt" 是一份针对PTA甲级考试中可能出现的高难度英语词汇的集合，旨在帮助考生更好地理解题目，提高解题速度。这份资源包含了一些关键的数学和计算机科学相关的术语。 1. **Polynomials**: 多项式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值