1. Toy模板网首页
  2. > Toy博客

数据结构day2（2023.7.15）

9月前 作者：小徐今天认真学习了嘛 分类：Toy博客 阅读(41) 违法举报

这篇具有很好参考价值的文章主要介绍了数据结构day2（2023.7.15）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、Xmind整理：

数据结构day2（2023.7.15）,数据结构 文章来源地址https://www.toymoban.com/news/detail-571366.html

二、课上练习：

练习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};

到了这里，关于数据结构day2（2023.7.15）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 数据结构day5（2023.7.19）

    数据结构day5（2023.7.19）

      双向链表的插入与删除：    练习1：单链表任意元素删除 练习2： 单链表任意元素查找 练习3： 单链表逆置 练习4：单链表排序（冒泡排序） 练习5： 单链表释放 练习6：单向循环链表节点创建  练习7：单向循环链表头插  练习8：单向循环链表的尾插 练习9：单向循环链

    2024年02月16日
    浏览(32)

  • 15.动态规划：数据结构优化DP

    数据结构优化DP有前缀和、滑动窗口、树状数组、线段树、单调栈、单调队列 中等 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如， [3,6,2,7] 是数组 [0,3,1,6,2,2

    2024年02月03日
    浏览(46)
  • 【数据结构和算法15】二叉树的实现

    【数据结构和算法15】二叉树的实现

    二叉树是这么一种树状结构：每个节点最多有两个孩子，左孩子和右孩子 重要的二叉树结构 完全二叉树（complete binary tree）是一种二叉树结构，除最后一层以外，每一层都必须填满，填充时要遵从先左后右 平衡二叉树（balance binary tree）是一种二叉树结构，其中每个节点的左

    2024年02月16日
    浏览(33)
  • 数据结构—基础知识（15）：哈夫曼树

    数据结构—基础知识（15）：哈夫曼树

    哈夫曼（Huffman）树 又称最优树，是一类带权路径长度最短的树，在实际中有广泛的用途。哈夫曼树的定义，涉及路径、路径长度、权等概念，下面先给出这些概念的定义，然后再介绍哈夫曼树 路径 ：从树中一个结点到另一个结点之间的分支构成这两个结点之间的路径。 路

    2024年02月19日
    浏览(44)

  • 数据结构与算法入门书籍推荐(15本)

    1.《算法图解》 本书适合刚开始学习算法的初学者，它使用非常通俗易懂的语言，详细解释了各种基础算法的实现方法，包括快速排序、图论、动态规划和贪心算法等。 2.《算法导论》 这是一本通用的算法指南，涵盖了所有重要的算法和数据结构。尽管它可能对初学者来说过

    2024年02月11日
    浏览(44)

  • 菜鸟教程《Python 3 教程》笔记（15）：数据结构

    笔记带有个人侧重点，不追求面面俱到。 出处： 菜鸟教程 - Python3 数据结构 在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。 遍历字典： 遍历列表： 遍历多个序列： 反向遍历：

    2024年02月10日
    浏览(42)

  • 【数据结构】15 队列应用实例：多项式加法运算

    我们准备采用不带头节点的单向链表结构表示一元多项式，并按照指数递减的顺序排列各项。 对列表存放的两个多项式进行加法运算时，可以使用两个指针p1和p2。初始时的p1和p2分别指向这两个多项式第1个节点（指数的最高项）。通过循环不断比较p1和p2所指的节点，比较结

    2024年02月21日
    浏览(52)
  • 数据结构 day1

    数据结构 day1

    1x.mind  2间接定义结构体数组，进行4种方式的定义和初始化  3定义结构体存储10辆车（车的信息：品牌、单价、颜色）         1.定义函数，实现循环输入         2.定义函数，实现排序         3.定义函数，计算红色车的个数  

    2024年02月11日
    浏览(40)
  • 数据结构 day6

    数据结构 day6

    1-xmind 2-递归实现程序：输入一个数，输出该数的每一位

    2024年02月10日
    浏览(37)
  • 数据结构day1

    数据结构day1

    1.思维导图 2.定义一个简单宏或宏函数，实现两个数交换。 3.定义字符类型指针，指针指向n个连续堆区内存，输入，计算字符串长度 定义函数，实现内存申请 定义函数，解释字符串长度 定义函数，释放内存

    2024年01月20日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包