【牛客编码】指针航行，链表魔法，解锁结构体和类的编程幻境

已于 2024-04-16 10:05:43 修改
阅读量1.5w 收藏 34
点赞数 31
分类专栏： # C/C++刷题库 文章标签： c语言 数据结构 算法 链表 指针
于 2023-12-12 06:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57532432/article/details/134834903
版权

📋 前言

 🌈个人主页：Sarapines Programmer

 🔥 系列专栏：本期文章收录在《C语言闯关笔记》，大家有兴趣可以浏览和关注，后面将会有更多精彩内容！

 ⏰翰墨致赠：文墨扬长风，情随碧波舞。江山孕雄心滚滚，志立云霄梦遨游。

​

 🎉欢迎大家关注🔍点赞👍收藏⭐️留言📝
 🔔作者留言：

欢迎来到我的​​编程学习笔记！这里是一个探索编程世界的秘境，我的学习笔记为你揭开C/C++语言的神秘面纱。在这个学习笔记中，我不仅分享C/C++的基础知识和高级技巧，还包含实用技术和项目经验的宝贵经验。无论你是初学者还是经验丰富的程序员，这个学习笔记将为你呈现出奇妙的编程魔法，帮助你在C/C++的编程森林中展开一场精彩的学习之旅。你准备好了吗？跟着我，一起编织属于我们自己的编程魔法吧！

题库地址：牛客网在线编程_语法篇_C语言入门

目录

📋 前言

🌐第一部分 指针篇

😎1.1 获取字符串长度

😎1.2 复制部分字符串

😎1.3 编写函数实现两数交换（指针方式）

😎1.4 利用指针遍历数组

😎1.5 牛牛的新数组求和

😎1.6 牛牛的排序

🌐第二部分 链表篇

2.0 单链表程序示例（掌握了再继续）：

😎2.1 牛牛的单向链表

😎2.2 牛牛的链表交换

😎2.3 牛牛的单链表求和

😎2.4 牛牛的双链表求和

😎2.5 牛牛的链表删除

😎2.6 牛牛的链表添加节点

🌐第三部分 结构体与类篇

😎3.1 KiKi定义电子日历类

😎3.2 KiKi设计类继承

😎3.3 牛牛的书

😎3.4 牛牛的平面向量

😎3.5 牛牛的时钟

😎3.6 结构体简单使用

🌐第一部分 指针篇

😎1.1 获取字符串长度

描述

键盘输入一个字符串，编写代码获取字符串的长度并输出，要求使用字符指针实现。

输入描述：

键盘输入一个字符串

输出描述：

输出字符串的长度

示例1

输入：
helloworld
输出：
10

💡解决如下：

解法一：

#include <iostream>

using namespace std;

int main(){
    char str[100];
    cin.getline(str,sizeof(str));

    char *ptr=str;
    int count=0;
    while (*ptr!='\0')
    {
        count++;
        ptr++;
    }
    cout<<count<<endl;
    
}

解法二：

#include <iostream>

using namespace std;

int main(){
    string s;
    getline(cin,s);

    char *p=&s[0];
    int count=0;
    for(int i=0;p[i] !='\0';i++){
        count++;
    }
    cout<<count<<endl;

    return 0;
}

😎1.2 复制部分字符串

描述

键盘输入一个长度为len（1 <= len < 30）的字符串，再输入一个正整数 m（1 <= m <= len），将此字符串中从第 m 个字符开始的剩余全部字符复制成为另一个字符串，并将这个新字符串输出。要求用指针处理字符串。

输入描述：

键盘输入一个长度为len（1 <= len < 30）的字符串，再输入一个正整数 m（1 <= m <= len）

输出描述：

输出复制的新字符串

示例1

输入：
helloworld
6
输出：
world

💡解决如下：

#include <iostream>

using namespace std;

int main(){
    char str[100];
    cin.getline(str,sizeof(str));
    
    int n;
    cin>>n;
    
    char *ptr=str;
    for(int i=0;i<n-1;i++,ptr++){
    }
    while(*ptr!='\0'){
        cout<<*ptr;
        ptr++;
    }
    cout<<endl;
    
}

解法二：

#include <iostream>

using namespace std;

int main(){
    string s,t;
    getline(cin,s);

    int n;
    cin>>n;

    char *p=&s[0];
    for(int i=n-1;p[i]!='\0';i++){
        t+=p[i];
    }
    cout<<t<<endl;

    return 0;
}

😎1.3 编写函数实现两数交换（指针方式+引用方式）

描述

编写一个函数，实现两个整数的交换，要求采用指针的方式实现。

输入描述：

键盘输入2个整数 m 和 n

输出描述：

输出交换后m 和 n 的值，中间使用空格隔开

示例1

输入:
2
3
输出:
3 2

💡解决如下（指针方式）：

#include <iostream>

using namespace std;

void swap(int *p1,int *p2);

int main(){    
    int n,m;
    cin>>n;
    cin>>m;
    
    int *p1,*p2;
    p1=&n;
    p2=&m;
    swap(p1,p2);
    cout<<n<<" "<<m<<endl;
}

void swap(int *p1,int *p2){
    int t=*p1;
    *p1=*p2;
    *p2=t;
}

💡解决如下（引用方式）：

#include <iostream>

using namespace std;

void Swap(int *p1,int *p2){
    int t=*p1;
    *p1=*p2;
    *p2=t;
}

void Swap2(int &x,int &y){
    int t=x;
    x=y;
    y=t;
}
int main(){
    int m,n;
    cin>>m>>n;

    int *p1=&m,*p2=&n;
    int &x=m,&y=n;
    //Swap(p1,p2);
    Swap2(x,y);

    cout<<m<<" "<<n<<endl;
    
    return 0;
}

😎1.4 利用指针遍历数组

描述

键盘随机输入 6 个整数，将这些数据保存到数组中，利用指针遍历数组中的元素并打印。

输入描述：

键盘随机输入 6 个整数

输出描述：

输出数组中的所有元素，每个元素中间使用空格隔开

例如：10 20 30 40 50 60

示例1

输入：
10
20
30 
40
50
60
输出：
10 20 30 40 50 60

💡解决如下：

#include <iostream>

using namespace std;

int main(){
    int MaxSize=6;
    int *arr=new int[MaxSize];
    int *p=arr;

    for(int i=0;i<MaxSize;i++){
        cin>>*(p+i);
    }
    p=arr;//重定向

    for(int i=0;i<MaxSize;i++){
        cout<<*(p+i)<<" ";
    }
    cout<<endl;
    delete [] arr;

    return 0;
}

💡一般思路：

#include <iostream>

using namespace std;

int main(){
    int MaxSize=6;
    int *arr=new int[MaxSize];
    for(int i=0;i<MaxSize;i++){
        cin>>arr[i];
    }

    for(int i=0;i<MaxSize;i++){
        cout<<arr[i]<<" ";
    }
    cout<<endl;
    delete [] arr;
    
    return 0;
}

😎1.5 牛牛的新数组求和

描述

牛牛学习了指针相关的知识，想实现一个 int cal(int *array,int n) 的函数求出长度为 n 的数组的和。

输入描述：

第一行输入一个正整数 n ，表示数组的长度

第二行输入 n 个正整数，表示数组中每个数字的值

输出描述：

实现 int cal(int *array,int n) 求出数组array的和

示例1

输入：
5
2 8 1 9 5
输出：
25

💡解决如下：

#include <iostream>

using namespace std;

int cal(int *array,int n);

int main(){    
    int n;
    cin>>n;

    int arr[100];
    //int len=sizeof(arr)/sizeof(int);
    
    for(int i=0;i<n;i++){
        cin>>arr[i];
    }

    cout<<cal(arr,n)<<endl;

}

 int cal(int *array,int n) {
    int sum=0;
    for(int i=0;i<n;i++){
        sum+=array[i];
    }
    return sum;
 }

解法二(new)：

#include <iostream>

using namespace std;

int cal(int *array,int n) {
    int sum=0;
    for(int i=0;i<n;i++){
        sum+=array[i];
    }
    return sum;
}
int main(){
    int maxSize;
    cin>>maxSize;
    int *a=new int[maxSize];
    for(int i=0;i<maxSize;i++){
        cin>>a[i];
    }
    cout<<cal(a,maxSize)<<endl;
    delete [] a;
    
    return 0;
}

解法三（vector）：

#include <iostream>
#include <vector>

using namespace std;

int cal(vector<int> array,int n) {
    int sum=0;
    for(int i=0;i<n;i++){
        sum+=array[i];
    }
    return sum;
}
int main(){
    int maxSize;
    cin>>maxSize;
    vector <int> a;
    for(int i=0;i<maxSize;i++){
        int k;
        cin>>k;
        a.push_back(k);
    }
    cout<<cal(a,maxSize)<<endl;

    return 0;
}

😎1.6 牛牛的排序

描述

牛牛试图给一个长度为 n 整数数组排序，即实现一个 void sort(int *array,int n) 

输入描述：

第一行输入一个正整数 n ，表示数组长度。

第二行输入 n 个正整数，表示数组中每个元素的值

输出描述：

输出排序后的数组

示例1

输入：
5
2 9 8 1 3
输出：
1 2 3 8 9

💡解决如下：

#include <iostream>

using namespace std;

void sort(int *array, int n);

int main()
{
    int n;
    cin >> n;

    int arr[100];
    // int len=sizeof(arr)/sizeof(int);

    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }

    sort(arr, n);
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

void sort(int *array, int n) 
{
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (array[j] > array[j + 1])
            {
                int t = array[j];
                array[j] = array[j + 1];
                array[j + 1] = t;
            }
        }
    }
}

解法二（new）：

#include <iostream>

using namespace std;

void sort(int *array,int n) {
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-1;j++){
            if(array[j]>array[j+1]){
                int t=array[j];
                array[j]=array[j+1];
                array[j+1]=t;
            }
        }
    }
}
int main(){
    int maxSize;
    cin>>maxSize;
    int *a=new int[maxSize];
    for(int i=0;i<maxSize;i++){
        cin>>a[i];
    }
    sort(a,maxSize);
    for(int i=0;i<maxSize;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl;
    
    return 0;
}

解法三（vector）：
 

#include <iostream>
#include <vector>

using namespace std;

void sort(vector <int> &array,int n) {
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-1;j++){
            if(array[j]>array[j+1]){
                int t=array[j];
                array[j]=array[j+1];
                array[j+1]=t;
            }
        }
    }
}
int main(){
    int maxSize;
    cin>>maxSize;
    vector <int> a;
    for(int i=0;i<maxSize;i++){
        int k;
        cin>>k;
        a.push_back(k);
    }

    sort(a,maxSize);
    for(int value:a){
        cout<<value<<" ";
    }
    cout<<endl;

    return 0;
}

🌐第二部分 链表篇

知识回顾：【数据结构】链表—C/C++实现-CSDN博客

2.0 单链表程序示例（掌握了再继续）：

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

//定义单链表
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;

//创建单链表
void CreateLNode(LNode **L,int a[],int n){
    LNode *s,*r;
    *L=(LNode *)malloc(sizeof(LNode));
    r=*L;
    for(int i=0;i<n;i++){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//输出单链表
void DispLNode(LNode **L){
    LNode *p=*L;
    while (p->next!=NULL){
        printf("%d ",p->next->data);
        p=p->next;
    }
    printf("\n");
}

//插入
void InsertLNode(LNode **L,int i,int e){
    LNode *p=*L,*s,*q;
    for(int j=0;j<i-1 && p->next!=NULL;){//定位到被插位置的前一个
        p=p->next;
        j++;
    }

    if(p==NULL){
        printf("error!\n");
    }
    else{
        s=(LNode *)malloc(sizeof(LNode));
        s->data=e;

        q=p->next;
        s->next=q;
        p->next=s;
    }
}

//删除
void DelLNode(LNode **L,int i){
    LNode *p=*L;
    for(int j=0;j<i-1 && p->next!=NULL;){//定位到被删除位置的前一个
        p=p->next;
        j++;
    }

    if(p==NULL){
        printf("error!\n");
    }
    else{
        p->next=p->next->next;
    }
}

//销毁
void DestroyLNode(LNode **L){
    LNode *p=*L,*q=(*L)->next;
    while (p!=NULL){
        free(p);
        p=q;
        q=q->next;
    }
}


int main(){
    int arr[]={0,1,2,3,4,5};
    int n=sizeof(arr)/sizeof(arr[0]);

    LNode *L;

    //测试创建    
    CreateLNode(&L,arr,n);
    DispLNode(&L);

    //测试插入
    InsertLNode(&L,2,3);
    DispLNode(&L);

    //测试删除
    DelLNode(&L,2);
    DispLNode(&L);

    //测试销毁
    DestroyLNode(&L);
    DispLNode(&L);

    return 0;
}

/*输出
0 1 2 3 4 5 
0 3 1 2 3 4 5
0 1 2 3 4 5
*/

😎2.1 牛牛的单向链表

描述

牛牛从键盘输入一个长度为 n 的数组，问你能否用这个数组组成一个链表，并顺序输出链表每个节点的值。

输入描述：

第一行输入一个正整数 n ，表示数组的长度

输出描述：

制作一个链表然后输出这个链表的值

示例1

输入：
4
5 4 2 1
输出：
5 4 2 1

💡解决如下：

#include <iostream>
#include <stdlib.h>

using namespace std;

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

//创建
void CreateLNode(LNode **L,int *a,int n){
    LNode *r,*s;
    *L=(LNode *)malloc(sizeof(LNode));
    r=*L;
    for(int i=0;i<n;i++){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}
//输出
void DispLNode(LNode **L){
    LNode *p=*L;
    while(p->next!=NULL){
        cout<<p->next->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

int main(){
    int maxSize;
    cin>>maxSize;

    int *a=new int[maxSize];
    for(int i=0;i<maxSize;i++){
        cin>>a[i];
    }

    LNode *L;
    CreateLNode(&L,a,maxSize);
    DispLNode(&L);

    delete [] a;
    return 0;
}

😎2.2 牛牛的链表交换

描述

牛牛尝试把一个长度为 n 的数组转换成链表并把链表前两个节点交换位置和把链表最后两个节点交换位置。

输入描述：

第一行输入一个正整数 n 表示数组的长度

第二行输入 n 个正整数，表示数组中各个元素的值

输出描述：

把数组转换成链表后输出交换位置后的链表

示例1

输入：
4
2 3 4 5
输出：
3 2 5 4

💡解决如下：

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

//链表定义
typedef struct LNode {
    int data;
    struct LNode* next;
} LNode;

//创建链表
void CreateLNode(LNode** L, int a[], int n) {
    LNode* s, *r;
    *L = (LNode*)malloc(sizeof(LNode));
    r = *L;
    for (int i = 0; i < n; i++) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

//链表输出
void DispLNode(LNode** L) {
    LNode* p = *L;
    while (p->next != NULL) {
        printf("%d ", p->next->data);
        p = p->next;
    }
}

//链表交换
void SwapLNode(LNode **L){
    LNode *p=*L,*q=(*L)->next,*s;//p:头节点，q:首结点
    
    //1.交换前两个节点的值
    int t=q->next->data;
    q->next->data=q->data;
    q->data=t;

    //2.交换最后两个节点值分成2.1定位倒数第二个节点 2.2交换值
    while(p->next->next!=NULL){
        p=p->next;
    }
    q=p;//故技重施哈哈
    t=q->next->data;
    q->next->data=q->data;
    q->data=t;
}
int main() {
    int a[100];
    int n;

    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }

    LNode* L;

    CreateLNode(&L, a, n);
    SwapLNode(&L);
    DispLNode(&L);

    return 0;
}

😎2.3 牛牛的单链表求和

描述

牛牛输入了一个长度为 n 的数组，他想把这个数组转换成链表，链表上每个节点的值对应数组中一个元素的值，然后遍历链表并求和各节点的值。

输入描述：

第一行输入一个正整数 n ，表示数组的长度。

第二行输入 n 个正整数，表示数组中各个元素的值。

输出描述：

把数组转换成链表然后对其求和并输出这个值。

示例1

输入：
5
5 2 3 1 1
输出：
12

💡解决如下：

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

//链表定义
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;

//创建链表
void CreateLNode(LNode **L,int a[],int n){
    LNode *s,*r;
    *L=(LNode *)malloc(sizeof(LNode));
    r=*L;
    for(int i=0;i<n;i++){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//链表求和
int DispLNode(LNode **L){
    LNode *p=*L;
    int sum=0;
    while (p->next!=NULL) {
        sum+=p->next->data;
        p=p->next;
    }
    return sum;
}

int main(){
    int a[100];
    int n;

    scanf("%d",&n);

    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
    }

    LNode *L;

    CreateLNode(&L, a, n);
    printf("%d\n",DispLNode(&L));
    
    return 0;
}

😎2.4 牛牛的双链表求和

描述

牛牛输入了两个长度相同的数组分别是 a 和 b ，然后把数组 a 和 b 转换成链表 a 和链表 b 。把链表 a 中的全部值按顺序加到链表 b 中。    

输入描述：

第一行输入一个正整数 n ，表示数组的长度。

第二行和第三行分别输入 n 个正整数，表示数组 a 和 数组 b 的值。

输出描述：

把数组 a 和数组 b 转换成链表，然后把链表 a 中的值加到链表 b 中，然后输出加和后的链表。

示例1

输入：
5
5 4 2 1 3
2 4 5 8 9
输出：
7 8 7 9 12

💡解决如下：

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

//链表定义
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;

//创建链表
void CreateLNode(LNode **L,int a[],int n){
    LNode *s,*r;
    *L=(LNode *)malloc(sizeof(LNode));
    r=*L;
    for(int i=0;i<n;i++){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//链表输出
void DispLNode(LNode **L){
    LNode *p=*L;
    while (p->next!=NULL) {
        printf("%d ",p->next->data);
        p=p->next;
    }
}

//两个链表相加
void AddLNode(LNode **L1,LNode **L2){
    LNode *p1=*L1,*p2=*L2;
    while(p1->next!=NULL){
        p2->next->data+=p1->next->data;
        p1=p1->next;
        p2=p2->next;
    }
}

int main(){
    int a[100],b[100];
    int n;

    scanf("%d",&n);

    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
    }
    for(int i=0;i<n;i++){
        scanf("%d",&b[i]);
    }

    LNode *L1,*L2;

    CreateLNode(&L1, a, n);
    CreateLNode(&L2, b, n);

    AddLNode(&L1, &L2);
    DispLNode(&L2);
    
    return 0;
}

😎2.5 牛牛的链表删除

描述

牛牛从键盘输入了一个长度为 n 的数组，把这个数组转换成链表然后把链表中所有值是 x 的节点都删除。

输入描述：

第一行输入两个正整数 n 和 x 表示数组的长度和要删除的链表节点值 x 。

第二行输入 n 个正整数表示数组中每个元素的值。

输出描述：

把数组转换成链表然后删除所有值是 x 的节点，删除后输出这个链表。

示例1

输入：
5 3
1 5 3 2 3
输出：
1 5 2

💡解决如下：

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

//链表定义
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;

//创建链表
void CreateLNode(LNode **L,int a[],int n){
    LNode *s,*r;
    *L=(LNode *)malloc(sizeof(LNode));
    r=*L;
    for(int i=0;i<n;i++){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//链表输出
void DispLNode(LNode **L){
    LNode *p=*L;
    while (p->next!=NULL) {
        printf("%d ",p->next->data);
        p=p->next;
    }
}

//删去对应值的链表元素
void DelLNode(LNode **L,int e){
    LNode *p=*L;
    while (p->next!=NULL) {
        if(p->next->data==e){
            p->next=p->next->next;
        }
        p=p->next;
    }
}

int main(){
    int a[100];
    int n,e;

    scanf("%d %d",&n,&e);

    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
    }

    LNode *L;

    CreateLNode(&L, a, n);
    DelLNode(&L, e);
    DispLNode(&L);
    
    return 0;
}

😎2.6 牛牛的链表添加节点

描述

牛牛输入了一个长度为 n 的数组，他把这个数组转换成链表并在第 i 个节点的后面添加一个值为 i 的新节点

输入描述：

第一行输入两个正整数分别是 n 和 i ，表示数组的长度、需要添加节点的位置和节点的值

第二行输入 n 个正整数表示数组中每个元素的值。

输出描述：

把数组转换成链表并在第 i 个节点后的添加一个新节点值，新节点的值是 i。

示例1

输入：
5 3
5 4 8 6 3
输出：
5 4 8 3 6 3

💡解决如下：

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

//链表定义
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;

//创建链表
void CreateLNode(LNode **L,int a[],int n){
    LNode *s,*r;
    *L=(LNode *)malloc(sizeof(LNode));
    r=*L;
    for(int i=0;i<n;i++){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//链表输出
void DispLNode(LNode **L){
    LNode *p=*L;
    while (p->next!=NULL) {
        printf("%d ",p->next->data);
        p=p->next;
    }
}

//插入
void InsertLNode(LNode **L,int i,int e){
    LNode *p=*L,*s,*q;
    for(int j=0;j<i && p->next!=NULL;){
        p=p->next;
        j++;
    }
    if(p==NULL){
        printf("error!\n");
    }
    else{
        s=(LNode *)malloc(sizeof(LNode));
        s->data=e;
        
        q=p->next;
        s->next=q;
        p->next=s;
    }
}
int main(){
    int a[100];
    int n,e;

    scanf("%d %d",&n,&e);

    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
    }

    LNode *L;

    CreateLNode(&L, a, n);

    InsertLNode(&L, e,  e);
    DispLNode(&L);
    
    return 0;
}

🌐第三部分 结构体与类篇

😎3.1 KiKi定义电子日历类

描述

KiKi学习了面向对象技术，学会了通过封装属性（变量）和行为（函数）定义类，现在他要设计一个电子日历类TDate。

它有3个私有数据成员：Month,Day,Year和若干个公有成员函数，要求：

（1）带有默认形参值的构造函数，默认值为0, 0, 0；
（2）输出日期函数，用“日/月/年”格式输出日期；
（3）设置日期函数，从键盘输入年、月、日。

输入描述：

一行，三个整数，用空格分隔，分别表示年、月、日。

输出描述：

一行，用“日/月/年”格式输出日期。

示例1

输入：
2019 12 30
输出：
30/12/2019

💡解决如下：

#include <iostream>

using namespace std;

class TDate{
    private:
    int Month;
    int Day;
    int Year;

    public:
    //带有默认形参值的构造函数，默认值为0, 0, 0
    TDate(int Year=0,int Month=0,int Day=0){}

    void SetValue(int a,int b,int c){
        Year=a;
        Month=b;
        Day=c;
    }
    void Disp(){
        cout<<Day<<"/"<<Month<<"/"<<Year<<endl;
    }
};
int main(){
   TDate today;
   int Year, Month, Day;
   cin>>Year>>Month>>Day;

   today.SetValue(Year,Month,Day);
   today.Disp();

   return 0;
}

😎3.2 KiKi设计类继承

描述

KiKi理解了继承可以让代码重用，他现在定义一个基类shape，私有数据为坐标点x,y,  由它派生Rectangle类和Circle类，它们都有成员函数GetArea()求面积。派生类Rectangle类有数据：矩形的长和宽；派生类Circle类有数据：圆的半径。Rectangle类又派生正方形Square类，定义各类并测试。输入三组数据，分别是矩形的长和宽、圆的半径、正方形的边长，输出三组数据，分别是矩形、圆、正方形的面积。圆周率按3.14计算。

输入描述：

输入三行，

第一行为矩形的长和宽，

第二行为圆的半径，

第三行为正方形的边长。

输出描述：

三行，分别是矩形、圆、正方形的面积。

示例1

输入：
7 8
10
5
输出：
56
314
25

💡解决如下：

#include <iostream>

using namespace std;

class Shape{//基类
    private:
    int x,y;

    public:
    virtual double GetArea() const = 0;
};

class Rectangle :public Shape{
    private:
    int l,w;

    public:
    //需要提供一个默认构造函数，因为square继承后需要调用Rectangle的构造，不提供则出错
    Rectangle(){}

    Rectangle(int l1,int l2){
        l=l1;
        w=l2;
    }
    virtual double GetArea() const {
        return l*w;
    }
    void Disp(){
        cout<<GetArea()<<endl;
    }
};

class Circle:public Shape{
    private:
    int r;

    public:
    Circle(int l){
        r=l;
    }
    double GetArea() const{
        return 3.14*r*r;
    }
    void Disp(){
        cout<<GetArea()<<endl;
    }
};

class Square : public Rectangle{
    private:
    int len;

    public:
    Square(int l){
        len=l;
    }
    double GetArea() const{
        return len*len;
    }
    void Disp(){
        cout<<GetArea()<<endl;
    }
};

int main(){
    int x,y;
    cin>>x>>y;

    int r;
    cin>>r;

    int len;
    cin>>len;
    
    Rectangle rectangle(x,y);
    rectangle.Disp();

    Circle circle(r);
    circle.Disp();

    Square square(len);
    square.Disp();

    return 0;
}

😎3.3 牛牛的书

描述

牛牛正在买书，每本书都有名字和价格，牛牛想把书按照价格升序排序。

输入描述：

第一行输入一个正整数 n ，表示书的数量。

后续每行都输入一个字符串 str 和一个正整数 p 表示书价格。

输出描述：

把书名按照价格升序输出。

示例1

输入：
3
TheNowcoder 100
Abook 20
BBook 300
输出：
Abook
TheNowcoder
BBook

💡解决如下：

#include <iostream>
#include <string>

using namespace std;

struct Books{//C++不用typedef也可以直接使用Books
    string name;
    int price;
};

//输出
void DispBooks(Books books[],int n){
    for(int i=0;i<n;i++){
        cout<<books[i].name<<endl;
    }
}

//排序
void Sort(Books books[],int n){
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-1-i;j++){
            if(books[j].price>books[j+1].price){
                string str=books[j].name;
                int t=books[j].price;
                books[j].name=books[j+1].name;
                books[j].price=books[j+1].price;
                books[j+1].name=str;
                books[j+1].price=t;
             }
        }
    }
}

int main(){
    Books books[100];
    int n;cin>>n;

    for(int i=0;i<n;i++){
        cin>>books[i].name>>books[i].price;
    }

    Sort(books, n);
    DispBooks(books, n);

    return 0;
}

😎3.4 牛牛的平面向量

描述

牛牛有 n 个平面向量 (x1,y1)  ，牛牛把这几个向量相加并输出这个向量的值。

输入描述：

第一行输入一个正整数 n 

后续 n 行每行输入两个正整数分别是 x 和 y。

输出描述：

输出所有的向量相加的结果

示例1

输入：
3
1 2
2 1
3 3
输出：
6 6

💡解决如下：

#include <iostream>
using namespace std;

struct Shape{
    int x,y;
};

//输出
void Disp(Shape shape){
    cout<<shape.x<<" "<<shape.y<<endl;
}

//多个相加
Shape AddShape(Shape shape[],int n){
    Shape newshape;
    newshape.x=0;
    newshape.y=0;

    for(int i=0;i<n;i++){
        newshape.x+=shape[i].x;
        newshape.y+=shape[i].y;
    }
    return newshape;
}

int main() {
    int n;
    cin>>n;
    Shape shape[100];

    for(int i=0;i<n;i++){
        cin>>shape[i].x>>shape[i].y;
    }

    Disp(AddShape(shape,n));

    return 0;
}

😎3.5 牛牛的时钟

描述

牛牛在午夜12点（0点0分0秒）正在思考，在 t 秒之后是什么时间。他思考了 n 次这个问题。

输入描述：

第一行输入一个正整数 n。

第二行输入 n 个正整数 t ，表示 t 秒之后。    

输出描述：

输出 n 行，每行输出 t 秒之后的时间。

示例1

输入：
4
60 61 1 2
输出：
0 1 0
0 2 1
0 2 2
0 2 4

💡解决如下：

#include <iostream>
using namespace std;

//计算过去的时间
void Disp(int a[],int n){
    int sum=0;
    int h=0,m=0,s=0;
    for(int i=0;i<n;i++){
        sum+=a[i];
        h=sum/3600;
        m=(sum-h*3600)/60;
        s=sum%60;
        cout<<h<<" "<<m<<" "<<s<<endl;
    }
}

int main() {
    int n;
    cin>>n;

    int a[100];
    for(int i=0;i<n;i++){
        cin>>a[i];
    }

    Disp(a, n);

    return 0;
}

😎3.6 结构体简单使用

描述

设计一个学生结构体，该结构体具有三个成员，分别是：姓名name、年龄age、身高height。

键盘依次输入姓名、年龄和身高数据，将数据保存到学生结构体变量上，并输出学生信息。

输入描述：

键盘依次输入学生的姓名name、年龄age、身高height

输出描述：

输出学生的信息，例如：

张三 20 182.5

示例1

输入：
张三
20
182.5
输出：
张三 20 182.5

💡解决如下：

#include <iostream>
#include <string>
using namespace std;

struct Student{
    string name;
    double age;
    double height;

    //构造函数
    Student(){}
    Student(string n,double a,double h){
        name=n;
        age=a;
        height=h;
    }
};

void Disp(Student s){
    cout<<s.name<<" "<<s.age<<" "<<s.height<<endl;
}

int main() {
    string name;
    double age,height;

    cin>>name;
    cin>>age;
    cin>>height;

    Student student(name,age,height);

    Disp(student);
    return 0;
}

SarPro
关注
  • 31
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
牛客webserver服务器项目一个月速通
06-24
牛客webserver服务器项目一个月速通
牛客网上编程题的每日练习，使用语言Python、C++(部分).zip
01-03
【标题】"牛客网上编程题的每日练习，使用语言Python、C++(部分).zip" 描述了这个压缩包的主体内容，即它包含了在牛客网上的每日编程题目练习，这些练习主要针对的是Python和C++这两种编程语言。牛客网是一个知名的...
牛客-BM1 反转链表-快慢指针
junewgl
03-20 993
快慢指针
牛客BM11-链表相加（二）-C++
TLJava^v^的博客
04-05 1048
一、题目 二、思路 由于给的是单链表，计算相加的结果要从低位开始计算，所以需要从后向前遍历结点，所以首先要先将给出的两个链表逆转。 逆转链表后，从两个链表的新首结点（原链表尾结点）开始遍历相加，sum变量表示当前两个结点的值相加的和余10得到的结果，flag为进位标志。用sum的值创建一个新的链表节点，用头插法创建新结果链表（头插法会和逆置后的链表顺序相反，也就是和原链表的顺序相同），若所有节点相加完后仍有进位，则再创建一个节点（节点值必为1），插入到头结点的后面。 三、代码 class S
牛客BM2-链表内指定区间反转-C++
TLJava^v^的博客
04-08 1151
一、运行结果 二、题目 三、思路 要实现指定区间的反转，首先要找到要找到指定区间的首节点（p指针指向）及其前驱节点（pre指针指向），然后以pre指针指向的节点为头，对指定区间实行头插法，p指针始终指向原指定区间的首节点，不断将p的下一个节点插入到pre后，实现反转。 四、代码 class Solution { public: ListNode* reverseBetween(ListNode* head, int m, int n) { ListNode* du
牛客OR36 .链表的回文结构
番茄炒蛋不吃西红柿的博客
01-06 987
对于一个链表，请设计一个时间复杂度为O(n), 额外空间复杂度为O(1)的算法，判断其是否为回文结构。 给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。 思路1： 找到链表的中间结点，然后拆开链表，分成两部分，将后半部分逆置，后半部分和前部分比较是否相等，只要有一个走到NULL了，就结束 （1）偶数个 （2）奇数个 这种方法，要把链表拆开 思路2： 不拆链表 （1）偶数个 找到中间结点， 中间结点后的部分逆置，不要拆开 （2）奇数个 stru
牛客每日刷题之链表
m0_60264772的博客
08-04 1720
兄弟们，一起来刷题👉嘎嘎的写题。
牛客TOP101之链表篇（高效刷题，带你手撕算法）
qq_36317312的博客
05-04 2075
1、反转链表 1、给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 以上转换过程如下图所示： 输入：{1,2,3} 返回值：{3,2,1} 输入：{} 返回值：{} 说明：空链表则输出空 常规思路：迭代 具体细节：在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个
牛客: BM8 链表中倒数最后k个结点
https://gitee.com/zm50
09-16 1191
快指针比慢指针先走k个位置,链表链表,快指针和慢指针同时往下跳,知道快指针遍历完毕,此时的慢指针就是倒数的第k个节点。
牛客题霸面试真题——链表：JZ35 复杂链表的复制
qq_46126258的博客
03-15 962
文章目录1、原题链接：2、题目理解：3、解法一：4、解法二： 1、原题链接： https://www.nowcoder.com/practice/f836b2c43afc4b35ad6adc41ec941dba 2、题目理解： （1）要理解什么是深拷贝，什么是浅拷贝？ 假设B复制了A，修改A的时候，看B是否发生变化： 如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值） 如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值） 浅拷贝（shallowCopy）只是增加了一个指针
【牛客编码】解谜OOP：通过实战揭秘面向对象编程的奥秘
热门推荐
朝花夕拾
12-16 1万+
文章深入探讨了面向对象编程（OOP）的概念和在编程挑战中的应用。首先介绍了OOP的基本原则，包括封装、继承和多态，以及如何在C++中利用类和对象来实现这些概念。随后，文章提供了一系列实际面向对象编程的题目，并详细解释了解决每个问题的思路和方法。通过编码示例，读者能够学习如何设计和实现类，创建对象，以及如何利用继承和多态提高代码的灵活性和可维护性。文章还强调了OOP的优势，包括代码的可读性、可重用性和模块化等方面的优点。在解答每个问题的过程中，作者强调了设计良好的类和对象结构的重要性
offer_牛客_剑指offer_剑指Offer算法题编程代码解析汇总_
10-02
3. 编程实现：提供了不同编程语言（如C++、Java、Python）的代码实现，便于读者理解和学习不同的编程语法。 4. 代码注释：对关键代码段进行注解，解释代码的工作原理，帮助读者理解代码逻辑。 5. 时间复杂度与空间...
leetcode分类-OfferMe2020:整理计算机专业复习要点、面试题、以及牛客和LeetCode上在线编程题
06-30
整理计算机专业复习要点、面试题、以及牛客和 LeetCode 上在线编程题 计算机网络 Redis Redis 简介 Java java 入门 数据类型 基本数据类型 java 语言整型默认 int 类型，如果要定义 double 类型，必须在数字后面加上...
单链表的创建与遍历--C
2301_81266471的博客
07-18 353
【代码】单链表的创建与遍历--C。
【剑指offr--C/C++】JZ26 树的子结构
qq_41104439的博客
07-20 109
第一个：确定一个根节点，A树中任意一个节点都有可能是子树的根节点，若当前节点不是，那么就要将其左右子树分别作为根节点走相同的判断流程；第二个：选择一个节点之后，将以这个节点为根的整棵树取出来与B进行比较，比较时根节点与左右子节点比较的方式是相同的。要判断一个树是不是另一个树的子树，这里边存在两个递归–所以我们要写两个函数，来完成两个递归。
LeetCode //C - 235. Lowest Common Ancestor of a Binary Search Tree
最新发布
Made in Code
07-20 705
【代码】LeetCode //C - 235. Lowest Common Ancestor of a Binary Search Tree。
四、初识C语言（4）
m0_56351488的博客
07-16 425
4。
Java编程与MVC模式：理解public类、重载与重写
这些知识点涵盖了Java编程的基础，如类的可见性、主方法、MVC设计模式以及数学函数的使用，还包括了面向对象编程的关键概念——重载和重写，以及多态性的概念。通过理解和应用这些知识，开发者能够编写出结构良好、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

SarPro

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

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

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

打赏作者

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

抵扣说明：

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

余额充值