数据结构day2（2023.7.15）

最新推荐文章于 2024-11-05 00:21:35 发布
最新推荐文章于 2024-11-05 00:21:35 发布
阅读量495 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68542867/article/details/131742606
版权
该文提供了一系列C语言编程练习，涉及结构体的定义、初始化、赋值方法，包括直接初始化、按顺序初始化、不按顺序初始化、单个成员赋值，以及通过输入赋值。此外，还涵盖了结构体数组、结构体指针的使用，以及结构体在堆区的动态分配和释放。同时，文章还讨论了共用体的赋值方式以及结构体与共用体的结合应用。
摘要由CSDN通过智能技术生成

一、Xmind整理：

 

二、课上练习：

练习1：定义车的信息：品牌，单价，颜色，车牌号

struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }a;
    struct Car//结构体自定义类型
    struct Car a;
    struct Car arr[3]
    struct Car *p;

练习2：间接定义变量按顺序初始化

 struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car car={"大众",123456,"白色"};
    car.name

练习3： 间接定义变量不按顺序初始化

struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car car={.price=123456,.color="白色",.id="沪A1111"};

练习4： 间接定义变量，单个赋值

 struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car car;
    strcpy(car.name,"大众");
    car.price=123456;
    strcpy(car.color,"白色");
    strcpy(car.id,"沪A88888");

练习5： 间接定义变量，输入赋值

 struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car car;
    scanf("%s",car.name);
    scanf("%d",&car.price);
    scanf("%s",car.color);
    scanf("%s",car.id);

练习6：直接定义变量按顺序初始化

 struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }car={"大众",123456,"白色","沪A1111"};

练习7：直接定义变量不按顺序初始化 

   struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }car={.price=123456,.color="白色",.id="沪A1111",.name="大众"};

练习8：直接定义变量，单个赋值 

struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }car;
    strcpy(car.name,"大众");
    car.price=123456;
    strcpy(car.color,"白色");
    strcpy(car.id,"沪A88888");

练习9：直接定义变量，输入赋值 

        struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }car;
    scanf("%s",car.name);
    scanf("%d",&car.price);
    scanf("%s",car.color);
    scanf("%s",car.id);

练习10：只有直接定义可以省略结构体名，无名结构体 

 struct 
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }car;

练习11：间接定义变量按顺序初始化 

  struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car car[3]={"大众",123456,"白色","沪A1111",
                        "大众",123456,"白色","沪A2222",
                        "大众",123456,"白色","沪A33333"};

练习12：间接定义变量不按顺序初始化 

 struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car car[3]={[0]={.price=123456,.color="白色",.id="沪A1111",.name="大众"},
                       [2]={.price=123456,.color="白色",.id="沪A2222",.name="大众"},
                        [1]={.price=123456,.color="白色",.id="沪A3333",.name="大众"}};

练习13： 间接定义变量，单个赋值

    struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car car[3];
    car[0]:第一辆车的所有信息
    car[0].name:第一辆车的品牌
    car[2].id
    
    strcpy(car[0].name,"大众");
    car[0].price=123456;
    strcpy(car[0].color,"白色");
    strcpy(car[0].id,"沪A88888");
    
       strcpy(car[1].name,"大众");
    car[1].price=123456;
    strcpy(car[1].color,"白色");
    strcpy(car[1].id,"沪A88888");
    
       strcpy(car[2].name,"大众");
    car[2].price=123456;
    strcpy(car[2].color,"白色");
    strcpy(car[2].id,"沪A88888");

练习14： 间接定义变量，输入赋值

struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car car[3];
    for(int i=0;i<3;i++)
    {
        scanf("%s",car[i].name);
        scanf("%d",&car[i].price);
        scanf("%s",car[i].color);
        scanf("%s",car[i].id);
    }

练习15：直接定义变量按顺序初始化

  struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    } car[3]={"大众",123456,"白色","沪A1111",
                        "大众",123456,"白色","沪A2222",
                        "大众",123456,"白色","沪A33333"};

练习16：直接定义变量不按顺序初始化

  struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }car[3]={[0]={.price=123456,.color="白色",.id="沪A1111",.name="大众"},
                       [2]={.price=123456,.color="白色",.id="沪A2222",.name="大众"},
                        [1]={.price=123456,.color="白色",.id="沪A3333",.name="大众"}};

练习17：直接定义变量，单个赋值

    struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }car[3];
    car[0]:第一辆车的所有信息
    car[0].name:第一辆车的品牌
    car[2].id
    
    strcpy(car[0].name,"大众");
    car[0].price=123456;
    strcpy(car[0].color,"白色");
    strcpy(car[0].id,"沪A88888");
    
       strcpy(car[1].name,"大众");
    car[1].price=123456;
    strcpy(car[1].color,"白色");
    strcpy(car[1].id,"沪A88888");
    
       strcpy(car[2].name,"大众");
    car[2].price=123456;
    strcpy(car[2].color,"白色");
    strcpy(car[2].id,"沪A88888");

练习18： 直接定义变量，输入赋值

  struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    }car[3];
    for(int i=0;i<3;i++)
    {
        scanf("%s",car[i].name);
        scanf("%d",&car[i].price);
        scanf("%s",car[i].color);
        scanf("%s",car[i].id);
    }

练习19：结构体指针指向普通结构体变量的地址 

   struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car c={.price=123456,.color="白色",.id="沪A1111",.name="大众"};
    struct Car *p=&c;

练习20： 结构体指针指向结构体数组的地址

struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10]    //颜色
        char id[20]        //车牌号
    };
    struct Car  car[3]={"大众",123456,"白色","沪A1111",
                        "大众",123456,"白色","沪A2222",
                        "大众",123456,"白色","沪A33333"};
    struct Car *p=car;

练习21：结构体指针指向堆区空间的首地址

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
   struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10];    //颜色
        char id[20]    ;    //车牌号
    };
//输出对去空间内存
void Output(struct Car *p,int len)
{

    for(int i=0;i<len;i++)
    {
    //    printf("%s\t%d\t%s\t%s\n",(p+i)->name,(p+i)->price,(p+i)->color,(p+i)->id);

    printf("%s\t%d\t%s\t%s\n",(*(p+i)).name,(*(p+i)).price,(*(p+i)).color,(*(p+i)).id);
    }
}
//在堆区空间申请
struct Car * create()
{
    
    struct Car *p=(struct Car *)malloc(sizeof(struct Car)*3);//
    if(NULL == p)
    {
    return NULL;
    }
    return p;

}
//在堆区实现循环输入
void Input(struct Car *p ,int n)
{

    for(int i=0;i<3;i++)
    {
    scanf("%s",(p+i)->name);
    scanf("%d",&(p+i)->price);//(p+i)->price===>price
    scanf("%s",(p+i)->color);
    scanf("%s",(p+i)->id);
    }

}
//释放堆区空间
struct Car * free_space(struct Car *p)
{
    if(NULL==p)
    {
    return NULL;
    }
    free(p);
p=NULL;
    return p;
}
int main(int argc, const char *argv[])
{
    /*
    struct Car  car[3]={"大众",123456,"白色","沪A1111",
                        "大众",123456,"白色","沪A2222",
                        "大众",123456,"白色","沪A33333"};
    struct Car *p=car;
    Output(p,3);*/
    
    struct Car *p=create();

    Input(p,3);
    Output(p,3);
    p=free_space(p);

    return 0;
}

练习22：结构体的引用 

  struct Car
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10];    //颜色
        char id[20]    ;    //车牌号
    };
    struct Car a={"大众",123456,"白色","沪A1111"};
    struct Car b;
    //把a赋值给b
    strcpy(b.name,a.name);
    b.price=a.price;
    strcpy(b.color,a.color);
    strcpy(b.id,a.id);
    a:表示所有信息
    b=a;

练习23：typedef和结构体结合 

//typedef int a,arr[],p;

//typedef int arr[];

 typedef struct  
    {
        char name[20];    //品牌
        int price;        //单价
        char color[10];    //颜色
        char id[20]    ;    //车牌号
    }car_t,car_arr[3],*car_p ;//a==》car_p 
car_t:不是变量名，是普通结构体类型别名
car_arr：不是结构体数组名，是结构体数组的别名
car_p:不是结构体指针变量名，是结构体指针的别名
当typedef和结构体结合时，结构体名可以省略不写

练习24：结构体嵌套普通结构       

               定义一个学生：姓名、性别、出生日期【年月日】 

    typedef struct
    {
        int year,month,day;
    }Birthday;
    typedef struct
    {
        char name[10];
        char sex;
        Birthday bir;
    }Stu;
    Stu student={"张三",'M',2000,7,14};
    printf("%s %c %d年%d月%d日\n",student.name,studnet.sex,student.bir.year,student.bir.month,student.bir.day);

练习25：结构体嵌套结构体数组

               定义一个人的信息：姓名，性别，年龄，车辆多辆【品牌，单价】 

 typedef struct
    {
        char name[10];
        int price;    
    }Car_t;
    typedef struct
    {
        char name[10];
        char sex;
        int age;
        Car_t arr[2]; 
    }person;
    person per={"张三",'M',18,"奔驰",555555,"宝马",666666};
    printf("",per.name,per.sex,per.age,per.arr[0].name,per.arr[0].price,per.arr[1].name,per.arr[1].price);

练习26：结构体字节计算 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, const char *argv[])
{
    typedef struct
    {
    int a;
    float b;

    }A_t;
    A_t var;
    printf("&var=%p\t&var.a=%p\t&var.b=%p\n",&var,&var.a,&var.b);
    printf("sizeof(A_t)=%ld\n",sizeof(A_t));//8

    typedef struct{
    char a;
    double b;
    }B_t;
B_t var1;
    printf("&var1=%p\t&var1.a=%p\t&var1.b=%p\n",&var1,&var1.a,&var1.b);
    printf("sizeof(B_t)=%ld\n",sizeof(B_t));//16

    typedef struct
    {
    int a;
    char b;
    float c;
    char *p;
    char d;
    }C_t;
C_t c;
    printf("c.a=%p\n",&c.a);
    printf("c.b=%p\n",&c.b);
    printf("c.c=%p\n",&c.c);
    printf("c.p=%p\n",&c.p);
    printf("c.d=%p\n",&c.d);
    printf("sizeof(C_t)=%ld\n",sizeof(C_t));//32
    
    typedef char a_str[5];    
    typedef struct
    {
    a_str a;
    int b;
    }D_t;
    
    printf("sizeof(D_t)=%ld\n",sizeof(D_t));//12

    typedef struct{
    char a;
    double b;
    }E_t;
    typedef struct 
    {
    char a;
    short b;
    E_t c;
    }F_t;

    printf("sizeof(F_t)=%ld\n",sizeof(F_t));//24
    return 0;
}

 练习27：共用体：默认为第一个元素赋值

typedef union 
    {
    int a;
    char b;
    double c;
    }A_t;
A_t var={97};//默认为第一个成员赋值

练习28：指定某一个成员赋值

typedef union 
    {
    int a;
    char b;
    double c;
    }A_t;
A_t var1={.c=55.66};//指定为某一成员赋值

练习29：共用体和结构体结合【共用体在结构体外】

    typedef union
    {
        int a;
        double b;    
    }A_t;
    typedef struct
    {
        int a_v;
        A_t var;   
    }B_t;
    B_t a={100,20};//默认为共用体第一个成员a赋值
    B_t b={100,.var.b=55.66};//指定共用体成员b赋值
    a.a_v=100
    a.var.a=20
    
    b.a_v=100
    b.var.b=55.66

练习30： 共用体和结构体结合 【共用体在结构体内】不建议写共用体名

typedef struct
    {
        int a_v;
        union 
        {
            int a;
            double b;    
        };
    }B_t;
    B_t b={100,.b=55.66};
小徐今天认真学习了嘛
关注
专栏目录
Spark大数据处理讲课笔记1.6 掌握Scala数据结构
howard2005的专栏
03-01 1591
1. 掌握数组的使用； 2. 掌握列表的使用； 3. 掌握映射的使用； 4. 掌握集合的使用； 5. 掌握元组的使用
11.数据仓库搭建之DWS层搭建
Mmj666的博客
07-14 2787
11.数据仓库搭建之DWS层搭建
2023.08.15作业五十题
starry_night_summer的博客
08-15 1183
不相等，float是32位的单精度，double是64位双精度，精度越大表示的小数越精确注：回文数即正反读都是一个数，5位数的话，只要个位与万位相同，十位与千位相同就是一个回文数。i
自动化测试(一)：网页结构分析与Google翻译2023.7.18爬虫实例
a_beatiful_knife的博客
07-18 2900
day7.18了解爬虫
2023/1/6 直面数据结构:Day_03
m0_56593481的博客
01-08 667
原出处:https://space.bilibili.com/19658621/dynamic 该视频知识产权由Micro_Frank所有(B站可以搜到)，感谢您支持正版维护中国人版权权益。 淘宝店铺名：MicroFrank https://www.bilibili.com/video/BV1t14y1G7wn 1. 非传统数据结构教学 2. 非传统数据结构思想 3. 非传统数据结构方法 4. 非传统训练方法 5. 非传统价格
2023/1/12 直面数据结构:Day_08
m0_56593481的博客
01-12 366
原出处:https://space.bilibili.com/19658621/dynamic 该视频知识产权由Micro_Frank所有(B站可以搜到)，感谢您支持正版维护中国人版权权益。 淘宝店铺名：MicroFrank https://www.bilibili.com/video/BV1t14y1G7wn/ 1. 非传统数据结构教学 2. 非传统数据结构思想 3. 非传统数据结构方法 4. 非传统训练方法 5. 非传统价格
2023/1/3 ~ 2023/1/4 直面数据结构:Day_01
m0_56593481的博客
01-08 288
原出处:https://space.bilibili.com/19658621/dynamic 该视频知识产权由Micro_Frank所有(B站可以搜到)，感谢您支持正版维护中国人版权权益。 淘宝店铺名：MicroFrank https://www.bilibili.com/video/BV1t14y1G7wn 1. 非传统数据结构教学 2. 非传统数据结构思想 3. 非传统数据结构方法 4. 非传统训练方法 5. 非传统价格
机器学习周记（第二十周：文献阅读-TCN and LSTM）2023.12.4~2023.12.10
DominaterWE的博客
12-10 1767
本周阅读了一篇关于TCN和LSTM进行光伏功率预测的文章，光伏功率数据是非线性不平稳的数据，在一定程度上也能反应论文模型在水质预测方面的效果。论文模型可以通过单步或者多步对光伏功率进行预测，实验结果表明，其具有非常优异的表现。本周也针对论文模型进行了简单的复现，预测结果并不非常准确，仍需进一步优化和调参。
【2024提前批/秋招笔试汇总2】——大疆-嵌入式软件-2023.08.06
Sunny_Coder的博客
11-11 1879
A.GPU无法使用共享内存结构，提高通信速度B.GPU的并行数据处理可以大幅度提高运算能力C.GPU使用高速全局内存可以进一步提升运算速度D.GPU的计算能力比CPU强A.epoll相比于poll会随着fd的数目增长而降低效率B.边缘触融发模式（Edge Trigger）模式是epoll缺省的工作方式C.epoll工作在水平触发模式时如果用户不进行任何操作，该事件并不会丢失D.在大规模并发服务器场景中需要监听多个socket的时候，选择select比epoll高效。
【学习日记2023.4.10】IO之打印流、数据流、对象流的使用_IO框架_Properties_XML_日志
qq_42575689的博客
04-12 933
IO之打印流、数据流、对象流的使用_IO框架_Properties_XML_日志
2023年全国计算机二级等级考试VFP知识点提纲.docx
10-27
7. 值联接：按照字段值相应相等为条件进行的联接操作。 8. 自然联接：去掉反复属性的等值联接。 第二章 常量： 1. 数值常量：N（3E2）。 2. 货币常量：Y（$2.3456）。 3. 字符常量：C（[]）。 4. 逻辑常量：L。 5....
c语言程序设计基础7构造数据类型.ppt
09-28
结构体是一种复杂的数据结构，由多个不同类型的成员变量组成。定义结构体的关键字是`struct`，结构体定义包括结构体名、成员变量及其类型。例如： ```c struct Date { int year; int month; int day; }; ``` 定义...
Vue核心技术与实战--2023.7.4
weixin_65590235的博客
07-04 694
Vue+面经
2023.7.13-人力资源后台管理系统
weixin_65590235的博客
07-13 673
hr--人力资源后台管理项目
Vue--2023.6.23
weixin_65590235的博客
06-23 393
vue
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现
青山师
11-04 1035
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现。
【进阶】java基础之集合(2)数据结构＜树＞
最新发布
Y0UZI的博客
11-05 326
二叉查找树，又称二叉排序树或者二叉搜索树。:任意节点左右子树高度差不超过1。
Redis常见面试题：ZSet底层数据结构，SDS、压缩列表ZipList、跳表SkipList
qq_44700578的博客
11-02 980
String类型底层数据结构，List类型全面解析，ZSet底层数据结构；简单动态字符串SDS、压缩列表ZipList、哈希表、跳表SkipList、整数数组IntSet
【数据结构与算法】第8课—数据结构之二叉树(堆)
weixin_70620792的博客
11-02 800
树是一种非线性的数据结构，它是由n(n>=0)个有限节点组成一个具有层次关系的集合，一般是树根朝上，树叶朝下树有一个特殊的节点，叫做根节点，根节点没有前驱节点树的根节点下面又有很多子节点，但是这些子节点是不相交的除根节点外，每棵子树的根节点有且只有一个前驱，但是可以有0个或多个后继，因此，树是递归定义的。
pd.to_datetime 使用多列拼接为日期
09-29
'day': [15, 31, 18] } df = pd.DataFrame(data) # 将这三个列转换为日期 date_columns = ['year', 'month', 'day'] combined_date = pd.to_datetime(df[date_columns]) # 结果是一个包含 datetime64[ns] 类型的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值