SDUT---数据结构---链表部分题目

最新推荐文章于 2024-05-23 18:35:33 发布
最新推荐文章于 2024-05-23 18:35:33 发布
阅读量235 收藏 1
点赞数
分类专栏： C/C++/数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ccccvvvvvcv/article/details/115057963
版权
这篇博客详细介绍了数据结构中的链表操作，包括顺序建立、逆序建立、链表逆置、有序链表归并等。特别讨论了C/C++中地址和空间管理的难点，以及如何实现单链表的拆分、有序链表的建立和删除重复元素。还提及了双向链表的实现，认为其不过是链表的变形。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据结构实验之链表一：顺序建立链表

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
}*head,*p,*tail;
int main()
{
    int n;
    scanf("%d",&n);
    head=new struct yyh();
    head->next=NULL;
    tail=head;
    for(int i=1; i<=n; i++)
    {
        p=new struct yyh();
        scanf("%d",&p->data);
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
    p=head->next;
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
    return 0;
}

数据结构实验之链表二：逆序建立链表

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
}*head,*p;
int main()
{
    int n;
    scanf("%d",&n);
    head=new struct yyh();
    head->next=NULL;
    while(n--)
    {
        p=new struct yyh();
        scanf("%d",&p->data);
        p->next=head->next;
        head->next=p;
    }
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
    return 0;
}

数据结构实验之链表三：链表的逆置

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
}*head,*p;
int main()
{
    int n;
    head=new struct yyh();
    head->next=NULL;
    while(~scanf("%d",&n)&&n!=-1)
    {
        p=new struct yyh();
        p->data=n;
        p->next=head->next;
        head->next=p;
    }
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
    return 0;
}

数据结构实验之链表四：有序链表的归并

这个题很有意思，尤其是mergeSort里的备注，关于地址和开空间的问题，是C/C++最有意思也挺有难度的地方，正是因为地址这种东西，C/C++才屹立不倒；

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
};

struct yyh* create(int w)
{
    struct yyh* head=new struct yyh();
    struct yyh* tail;
    head->next=NULL;
    tail=head;
    while(w--)
    {
        struct yyh* p=new struct yyh();
        scanf("%d",&p->data);
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
    return head;
}
struct yyh* mergeSort(struct yyh* head1,struct yyh* head2)
{
    struct yyh* p,* q,* tail,* head;
    head=new struct yyh();
    //这里注意，我们要建立一个新的链表，他的头是head，但是这个head没有给它开辟空间
    //所以我们必须先给head开辟一块新空间，mergeSort结束再把这个head的地址传给主函数里的head
    //注意，这里的head和主函数里的head不是一个head，主函数里的head呢
    //只是一个没有开辟它指向的struct yyh类型空间的指针。
    //另外也不要给主函数里的head开辟空间，因为这里的head是我们新建出来的，他不能指向主函数里
    //那个head指向的空间，依旧需要重新建立空间;
    //当然，如果你非要用主函数里的那个head，可以看下面一个代码
    //那个就是把主函数里的head传到这里来了;
    p=head1->next;
    q=head2->next;
    head->next=NULL;
    tail=head;
    delete(head1);
    delete(head2);
    while(p!=NULL&&q!=NULL)
    {
        if(p->data<=q->data)
        {
            tail->next=p;
            tail=p;
            p=p->next;
            tail->next=NULL;
        }
        else
        {
            tail->next=q;
            tail=q;
            q=q->next;
            tail->next=NULL;
        }
    }
    //注意下面的操作
    if(p!=NULL)
    {
        tail->next=p;
    }
    if(q!=NULL)
    {
        tail->next=q;
    }
    //因为链表之间的链接已经在重新排序之前连接好了，所以
    //当一个链表的所有成员都连上，而另一个还有N个成员没法
    //连上时，只需要连已和前边结点断开链接的那个结点,其后面的结点就一起连到总链表最后了
    return head;
}
void display(struct yyh* head)
{
    struct yyh* p;
    p=head->next;
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
}
int main()
{
    int n,m;
    struct yyh* head1,*head2,*head;
    scanf("%d %d",&n,&m);
    head1=create(n);
    head2=create(m);
    head=mergeSort(head1,head2);
    display(head);
    return 0;
}

这种也可以：

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
};

struct yyh* create(int w)
{
    struct yyh* head=new struct yyh();
    struct yyh* tail;
    head->next=NULL;
    tail=head;
    while(w--)
    {
        struct yyh* p=new struct yyh();
        scanf("%d",&p->data);
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
    return head;
}
struct yyh* mergeSort(struct yyh* head1,struct yyh* head2,struct yyh* head)
{
    struct yyh* p,* q,* tail;
    head=new struct yyh();
    p=head1->next;
    q=head2->next;
    head->next=NULL;
    tail=head;
    delete(head1);
    delete(head2);
    while(p!=NULL&&q!=NULL)
    {
        if(p->data<=q->data)
        {
            tail->next=p;
            tail=p;
            p=p->next;
            tail->next=NULL;
        }
        else
        {
            tail->next=q;
            tail=q;
            q=q->next;
            tail->next=NULL;
        }
    }
    if(p!=NULL)
    {
        tail->next=p;
    }
    if(q!=NULL)
    {
        tail->next=q;
    }
    return head;
}
void display(struct yyh* head)
{
    struct yyh* p;
    p=head->next;
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
}
int main()
{
    int n,m;
    struct yyh* head1,*head2,*head;
    scanf("%d %d",&n,&m);
    head1=create(n);
    head2=create(m);
    head=new struct yyh();
    head=mergeSort(head1,head2,head);
    display(head);
    return 0;
}

下面这种是就地取材，把head1当做head，不需要再为head开辟空间。而head1在create函数里已经开辟了空间，不需要再开辟空间了

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
};

struct yyh* create(int w)
{
    struct yyh* head=new struct yyh();
    struct yyh* tail;
    head->next=NULL;
    tail=head;
    while(w--)
    {
        struct yyh* p=new struct yyh();
        scanf("%d",&p->data);
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
    return head;
}
struct yyh* mergeSort(struct yyh* head1,struct yyh* head2)
{
    struct yyh* p,* q,* tail;
    p=head1->next;
    q=head2->next;
    head1->next=NULL;
    tail=head1;
    delete(head2);
    while(p!=NULL&&q!=NULL)
    {
        if(p->data<=q->data)
        {
            tail->next=p;
            tail=p;
            p=p->next;
            tail->next=NULL;
        }
        else
        {
            tail->next=q;
            tail=q;
            q=q->next;
            tail->next=NULL;
        }
    }
    if(p!=NULL)
    {
        tail->next=p;
    }
    if(q!=NULL)
    {
        tail->next=q;
    }
    return head1;
}
void display(struct yyh* head)
{
    struct yyh* p;
    p=head->next;
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
}
int main()
{
    int n,m;
    struct yyh* head1,* head2;
    scanf("%d %d",&n,&m);
    head1=create(n);
    head2=create(m);
    head1=mergeSort(head1,head2);
    display(head1);
    return 0;
}

数据结构实验之链表五：单链表的拆分

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
};

struct yyh* create(int w)
{
    struct yyh* head=new struct yyh();
    struct yyh* tail;
    head->next=NULL;
    tail=head;
    while(w--)
    {
        struct yyh* p=new struct yyh();
        scanf("%d",&p->data);
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
    return head;
}
void splitAndDisplay(struct yyh* head)
{
    struct yyh* p,* head1,* head2,* tail1,* tail2;
    int k1=0,k2=0;
    head1=new struct yyh();
    head2=new struct yyh();
    p=head->next;
    tail1=head1;
    tail2=head2;
    while(p->next!=NULL)
    {
        if(p->data%2==0)
        {
            tail1->next=p;
            tail1=p;
            k1++;
        }
        else
        {
            tail2->next=p;
            tail2=p;
            k2++;
        }
        p=p->next;
    }
    if(p->data%2==0)
    {
        k1++;
        tail1->next=p;
        tail2->next=NULL;
    }
    else
    {
        k2++;
        tail2->next=p;
        tail1->next=NULL;
    }
    printf("%d %d\n",k1,k2);
    head1=head1->next;
    head2=head2->next;
    while(head1!=NULL)
    {
        if(head1->next==NULL)
        {
            printf("%d\n",head1->data);
        }
        else
        {
            printf("%d ",head1->data);
        }
        head1=head1->next;
    }
    while(head2!=NULL)
    {
        if(head2->next==NULL)
        {
            printf("%d\n",head2->data);
        }
        else
        {
            printf("%d ",head2->data);
        }
        head2=head2->next;
    }
}
int main()
{
    int n;
    struct yyh* head;
    scanf("%d",&n);
    head=create(n);
    splitAndDisplay(head);
    return 0;
}

数据结构实验之链表六：有序链表的建立

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
};

struct yyh* create(int w)
{
    struct yyh* head=new struct yyh();
    struct yyh* tail,* q,* t;
    head->next=NULL;
    tail=head;
    while(w--)
    {
        struct yyh* p=new struct yyh();
        scanf("%d",&p->data);
        p->next=NULL;
        int flag;
        if(head->next==NULL)
        {
            tail->next=p;
            tail=p;
        }
        else
        {
            flag=1;
            q=head;
            t=head->next;
            while(t!=NULL)
            {
                if(p->data>t->data)
                {
                    q=q->next;
                    t=t->next;
                }
                else
                {
                    p->next=q->next;
                    q->next=p;
                    flag=0;
                    break;
                }
            }
        }
        if(flag==1)
        {
            tail->next=p;
            tail=p;
        }
    }
    return head;
}

void display(struct yyh* head)
{
    struct yyh* p;
    p=head->next;
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
}
int main()
{
    int n;
    struct yyh* head;
    scanf("%d",&n);
    head=create(n);
    display(head);
    return 0;
}

数据结构实验之链表七：单链表中重复元素的删除

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
};

int n;
struct yyh* create(int w)
{
    struct yyh* head,* p;
    head=new struct yyh();
    head->next=NULL;
    while(w--)
    {
        p=new struct yyh();
        scanf("%d",&p->data);
        p->next=head->next;
        head->next=p;
    }
    return head;
}

struct yyh * Delete(struct yyh* head)
{
    struct yyh * p,* q,* t;
    for(p=head->next; p!=NULL; p=p->next)
    {
        t=p;
        q=t->next;
        while(q!=NULL)
        {
            if(q->data==p->data)
            {
                t->next=q->next;
                q=t->next;
                n--;
            }
            else
            {
                t=t->next;
                q=q->next;
            }
        }
    }
    return head;
}

void display(struct yyh* head)
{
    struct yyh* p;
    p=head->next;
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
}

int main()
{
    struct yyh* head;
    scanf("%d",&n);
    head=create(n);
    printf("%d\n",n);
    display(head);
    head=Delete(head);
    printf("%d\n",n);
    display(head);
    return 0;
}

数据结构实验之链表九：双向链表

加一个prior前置指针即可，双向链表也好，循环链表也好，没有什么难的，就是变形罢了；

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* prior;
    struct yyh* next;
};

int n,m;
struct yyh* create(int w)
{
    struct yyh* head,* p,* tail;
    head=new struct yyh();
    head->next=NULL;
    tail=head;
    while(w--)
    {
        p=new struct yyh();
        scanf("%d",&p->data);
        p->next=NULL;
        tail->next=p;
        p->prior=tail;
        tail=p;
    }
    return head;
}

void display(struct yyh* head)
{
    while(m--)
    {
        int t;
        scanf("%d",&t);
        struct yyh* p=head->next;
        while(p!=NULL)
        {
            if(p->data==t)
            {
                break;
            }
            p=p->next;
        }
        if(p->next!=NULL&&p->prior!=head)//注意头结点的问题，前置指针摸到头结点就算到头了
        {
            printf("%d %d\n",p->prior->data,p->next->data);
        }
        else if(p->prior!=head&&p->next==NULL)
        {
            printf("%d\n",p->prior->data);
        }
        else if(p->next!=NULL&&p->prior==head)
        {

            printf("%d\n",p->next->data);
        }
    }
}

int main()
{
    struct yyh* head;
    scanf("%d %d",&n,&m);
    head=create(n);
    display(head);
    return 0;
}

数组操作

有一说一这个题还是很考验基础功的。

#include <bits/stdc++.h>
using namespace std;

struct yyh
{
    int data;
    struct yyh* next;
};
int n,m;

struct yyh* create(int n)
{
    struct yyh* head,* p,* tail;
    head=new struct yyh();
    head->next=NULL;
    tail=head;
    for(int i=0; i<n; i++)
    {
        p=new struct yyh();
        scanf("%d",&p->data);
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
    return head;
}

void first(struct yyh* head,int a,int b)
{
    struct yyh* q;
    q=head;
    struct yyh* t=new struct yyh();
    t->data=b;
    int flag=0;
    while(flag<a)
    {
        q=q->next;
        flag++;
    }
    t->next=q->next;
    q->next=t;
}

void second(struct yyh* head,int a)
{
    struct yyh* q;
    q=head;
    int flag=0;
    while(flag<a)
    {
        q=q->next;
        flag++;
    }
    q->next=q->next->next;
}

void third(struct yyh* head,int a,int b)
{
    struct yyh* q;
    q=head;
    int flag=0;
    while(flag<a)
    {
        q=q->next;
        flag++;
    }
    q->next->data=b;
}

void display(struct yyh* head)
{
    struct yyh* p;
    p=head->next;
    while(p!=NULL)
    {
        if(p->next!=NULL)
        {
            printf("%d ",p->data);
        }
        else
        {
            printf("%d\n",p->data);
        }
        p=p->next;
    }
}

int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        struct yyh* head;
        head=create(n);
        int num,a,b;
        while(m--)
        {
            scanf("%d",&num);
            if(num==1)
            {
                scanf("%d %d",&a,&b);
                first(head,a,b);
            }
            else if(num==2)
            {
                scanf("%d",&a);
                second(head,a);
            }
            else if(num==3)
            {
                scanf("%d %d",&a,&b);
                third(head,a,b);
            }
            else if(num==4)
            {
                display(head);
            }
        }
    }
    return 0;
}
PTA 7-5 C语言链表的逆置--两种实现代码
程序员早早的博客
04-09 3320
题目 C语言代码实现 关于单链表的头节点有两种方式，一种头节点直接保存数据，另外一种头节点只是作为哨兵占位。两种方式均实现一遍，掌握任何一种均可。 头节点保存数据 # include <stdio.h> # include <stdlib.h> //单链表逆置，head保存数据 typedef struct Node *node; struct Node { int data; node next; }; node createList() { no
SDUT---OJ《程序设计基础（B）II》实验2--链表
m0_46062697的博客
11-06 1790
A - 数据结构实验之链表一：顺序建立链表 Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample Input 8 12 56 4 6 55 15 33 62 Output 12 56 4 6 55 15 33 62 #include<stdio.h> #include<stdlib.h> st..
SDUT OJ----数据结构----链表习题
weixin_55812984的博客
07-20 942
A - 数据结构实验之链表一：顺序建立链表 Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample Input 8 12 56 4 6 55 15 33 62 Output 12 56 4 6 55 15 33 62 Hint 不得使用数组！ #include<stdio.h> #include<..
SDUT-1466 双向队列
Leslie's Blog
05-13 402
双向队列Time Limit: 1000MS Memory Limit: 65536KB    Problem Description      想想双向链表……双向队列的定义差不多，也就是说一个队列的队尾同时也是队首；两头都可以做出队，入队的操作。现在给你一系列的操作，请输出最后队列的状态；命令格式：LIN X  X表示一个整数，命令代表左边进队操作；RIN X  表示右边进队操作；ROUTLO...
9-20 sdut-C语言实验-链表的结点插入
xxn66666666的博客
12-28 626
给出一个只有头指针的链表和 n 次操作，每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数则将x放在链表的最后。
sdut 链表10------7-10 sdut-C语言实验-不敢死队问题
2302_80130040的博客
05-23 417
7-10 sdut-C语言实验-不敢死队问题分数 20全屏浏览切换布局作者 马新娟单位 山东理工大学说到“敢死队”，大家不要以为我来介绍电影了，因为数据结构里真有这么道程序设计题目，原题如下：有M个敢死队员要炸掉敌人的一个碉堡，谁都不想去，排长决定用轮回数数的办法来决定哪个战士去执行任务。如果前一个战士没完成任务，则要再派一个战士上去。现给每个战士编一个号，大家围坐成一圈，随便从某一个战士开始计数，当数到5时，对应的战士就去执行任务，且此战士不再参加下一轮计数。
SDUT-3331_数据结构实验之链表八：Farey序列
weixin_34194379的博客
09-29 114
数据结构实验之链表八：Farey序列 Time Limit: 10 ms Memory Limit: 600 KiB Problem Description Farey序列是一个这样的序列：其第一级序列定义为（0/1，1/1），这一序列扩展到第二级形成序列（0/1，1/2，1/1），扩展到第三极形成序列（0/1，1/3，1/2，2/3，1/1），扩展到第四级则形成序列（0/1，1/4，1/3，1/...
9-21 sdut-C语言实验-单链表的顺序建立与结点的删除
xxn66666666的博客
12-28 2676
分数 15全屏浏览题目切换布局作者 马新娟单位 山东理工大学输入n个整数，先按照数据输入的顺序建立一个带头结点的单链表，再输入一个数据m,将单链表中的值为m的结点全部删除。分别输出建立的初始单链表和完成删除后的单链表。
SDUT - 2121 数据结构实验之链表六：有序链表的建立
Miracle_QSH的博客
08-15 265
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; struct node { int data; struct node *next; }; int main() { int n, i; scanf("%d", &amp;n); struct node *h, *q, *p; h = (struc...
SDUT OJ----数据结构----线性表习题
weixin_55812984的博客
07-19 846
表应用1：多余元素删除之移位算法 Description 一个长度不超过10000数据的顺序表，可能存在着一些值相同的“多余”数据元素（类型为整型），编写一个程序将“多余”的数据元素从顺序表中删除，使该表由一个“非纯表”（值相同的元素在表中可能有多个）变成一个“纯表”（值相同的元素在表中只保留第一个）。 要求： 1、必须先定义线性表的结构与操作函数，在主函数中借助该定义与操作函数调用实现问题功能； 2、本题的目标是熟悉顺序表的移位算法，因此题目必须要用元素的移位实现删除； Input 第一..
7-1 sdut-C语言实验-顺序建立链表 分数 20 全屏浏览 作者 马新娟 单位 山东理工大学 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 输入格式: 第
03-08
好的，让我们一起来了解一下如何通过 C 语言实现按顺序建立链表并遍历输出这些数据的功能。 ## 题目解析 ### 输入说明 你需要从标准输入读取两行内容： - 第一行是一个正整数 N (1 ≤ N ≤ 100)，表示将要输入的...
sdut pta数据结构链表
最新发布
03-15
### 山东科技大学PTA 数据结构 链表 练习题 解法 #### 关于链表的基础知识点 链表是一种常见的线性数据结构，其特点是通过指针连接节点形成序列。相比于数组，链表具有动态扩展的优势，在插入和删除操作上效率更高...
数据结构实验之链表一：顺序建立链表 SDUT
weixin_43892738的博客
01-15 536
数据结构实验之链表一：顺序建立链表 SDUT Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Problem Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample I...
c++ ＜＜和＞＞的意思
热门推荐
ccccvvvvvcv的博客
08-24 3万+
<<<<<<是左移运算符的意思，左移运算符是用来将一个数的各二进制位全部左移若干位,右补0。高位左移后溢出，舍弃。 例如： 将a的二进制数左移2位，右补0。若a=15，即二进制数00001111，左移2位得00111100，即十进制数60。 语法格式：需要移位的数字 << 移位的次数 例如： 3 << 2，则是将数字3左移2位。即00000011----->00001100(12); >>>>>>右移运算符
无穷大无穷小的写法总结（持续补充~~~）
ccccvvvvvcv的博客
05-29 3767
1.我们可以使用系统提供的常量： 　　　如果是int型，可以用INT_MAX表示正无穷，INT_MIN表示负无穷，需要包含头文件limits.h； 　　如果是double型，可以用DBL_MAX表示正无穷，-DBL_MAX表示负无穷(注意不是DBL_MIN)，需要包含头文件float.h。 2.我们也可以自己设置一个很大的值作为无穷大： ①.0x7fffffff 但是这个值在相加时会溢出，这样两个无穷大数相加会变成负数。 ②.0x3f3f3f3f 为了尽量避免以上的错误，我们可以将0x3f3f3f3f设为无
switch case 嵌套（禁止套娃接手动滑稽）
ccccvvvvvcv的博客
04-26 1288
import java.util.*; public class Main { public static void main(String[] args) { int a=Integer.parseInt(args[0]); int b=Integer.parseInt(args[1]); if((a!=1&&a!=2&&am...
getline（cin,s）与cin.getline(s,n)的分辨
ccccvvvvvcv的博客
09-14 1287
cin.getline(s,n) 用法:接收一个字符串，可以接收空格并输出 #include <iostream> using namespace std; main () { char m[20]; cin.getline(m,5); cout<<m<<endl; } 输入：jkljkljkl 输出：jklj 如果把5改成20： 输入：jkljkljkl 输出：jkljkljkl 接收5个字符到m中，其中最后一个为’\0’，所以只看到4个字符输出； 1、cin.get
二叉树基础——六个重要性质（国内考试常考）
ccccvvvvvcv的博客
04-14 1154
性质1：二叉树第i层上的结点数目最多为2i-1(i>=1) 性质2：深度为i的二叉树至多有2i-1个结点（i>=1） 性质3：包含n个结点的二叉树的高度至少为(log2log_2log2​n)+1 性质4：在任意一棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则n0=n2+1 证明： n为总结点数，n1为度为1的结点总数，n0,n2同理； 由（1）（2） n=n0+n1+n2 (1) n=n00+n11+n22+1即n=n1+2n2+1 (2)* 得：n0=n2+1 性质5：具有n个
山东理工大学2020年全国天梯赛赛前个人专题强化赛---B（排序2）
ccccvvvvvcv的博客
09-21 532
这题的n<m这个测试点可以说坑了一大波人，其他没什么就是个水题 #include <bits/stdc++.h> using namespace std; const int manx=1e6+10; int n,m; long long a[manx]; bool cmp(long long x,long long y) { return x>y; } int main() { scanf("%d %d",&n,&m); for(int .
7-17 sdut-JAVA-encrypted data
03-10
### Java 加密数据 对于Java加密数据的操作，通常会涉及到多种不同的算法和技术。在Java中实现加密功能主要依赖于`javax.crypto`包以及相关的类库。 #### 使用AES进行加密解密操作 下面是一个简单的例子展示如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值