• 数据结构大总结：有头单链表、循环链表、双线链表、栈、队列、递归、快速排序、树和哈希。

    一、什么是数据结构？

    1.1数据结构的概念

    数据：能够输入到计算机中的描述客观事物的信息集合 (需要计算机处理的对象)

    结构：数据之间的关系

    算法：对特定问题求解的一种描述

    数据结构是独立于计算机、不依赖开发语言

    数据结构是研究 数据逻辑关系、存储关系、及操作的知识

    1.2数据结构的三要素

     1.2.1逻辑结构：

    1.2.1.1概念:

            数据元素之间的关系，和存储无关，独立于计算机指数据之间在逻辑上的关系，主要指邻接关系逻辑关系在考虑数据间关系的时候会涉及直接前趋和直接后继的概念.

    1.2.1.2数据的逻辑结构:

            线性结构：一对一的关系，除了端点之外的每一个数据都有一个前驱和一个后继

            注意：线性结构要求数据是连续的

            

            非线性结构：              

                    树形结构：

                    一对多的关系，每个节点都有一个前驱和多个后继     

                    图形结构：

                    多对多的关系 

                    集合结构：

                    数据元素间除“同属于一个集合”外，无其它关系，一般编程时不考虑。

    1.2.2存储结构：

    1.2.2.1概念:        

            指数据在计算机内存中的分布方式.存储结构：逻辑结构在计算机中的具体实现方法，也就是说是数据在内存上实际的存储方式。存储结构是通过计算机语言所编制的程序来实现的，因而是依赖于具体的计算机语言的。

    1.2.2.2 顺序存储:

    将数据结构中各元素按照其逻辑顺序存放于存储器一片连续的存储空间中，如c语言的数组。

    5.2.2 链式存储:

    将数据结构中各元素分布到存储器的不同点，用指针方式建立它们之间的联系。

    5.2.3 索引存储:

    根据数据元素的特殊字段(称为关键字key)，计算数据元素的存放地址，然后数据元素按地址存放

    如：使用百家姓作为关键字来存储市民信息，访问时效率会比遍历所有市民高很多。

          

    1.3 算法相关的概念

    1.3.1 算法的定义

    所谓的算法，就是解决问题的一种方法。在有限步骤内解决数学问题的过程

    注意：计算机中处理的数据都是有限的，那些无限的概念只出现在数学模型中。

    算法是不依赖于编程语言的

    1.3.2 算法的特点

    1.有穷性 算法是由若干指令组成的有穷序列，总是在执行若干次后结束

    2.确定性 每条指令都有特定的含义 且 没有歧义，同样的输入要有同样的输出

    3.可行性 算法可以在当前环境下通过有限次运行实现

    4.输入输出 由 0 个输入或多个输入 有一个或多个输出

    1.3.3 好的算法标准：

    1.正确性 运行正常、结果正确

    2.易读性 简单、易读 遵循公司命名规则、适当的注释

    3.健壮性 对非法的数据和操作有良好的反应能力和处理能力

    4.高效性 执行效率高、运行时间短

    5.低存储 算法所占空间尽可能低

    1.3.4算法的复杂度

    1.3.4.1 概念

            算法的复杂度分为时间复杂度和空间复杂度空间复杂度：指的就是算法在实现的过程中需要用到的额外的临时内存的大小现在技术比较成熟了，内存空间一般都是够用的，所以空间复杂度一般不考虑时间复杂度：指的是算法实现的过程中，需要耗时的多少。如果只说算法的复杂度，一般情况下，指的都是时间复杂度。程序由三种结构构成：顺序结构、分支结构和循环结构。顺序结构和分支结构中的每段代码只运行一次；循环结构中的代码的运行时间要看循环的次数。由于是估算算法的时间复杂度，相比而言，循环结构对算法的执行时间影响更大。所以，算法的时间复杂度，主要看算法中使用到的循环结构中代码循环的次数（称为“频度”）。次数越少，算法的时间复杂度越低。

    1.3.4.2 时间复杂度的表示

    算法的时间复杂度定义为算法中可执行语句的频度之和 记作 T(n)

    语句频度是指同一代码执行的次数

    T(n)是算法所需时间的一种估值，n 表示问题的规模

    算法的时间复杂度的表示方式为：

    O(频度); 称为 大 O 表示法

    使用大O表示法的简化方式：

    1.去掉运行时间中的所有常数项。

    （例如 2+2n+2n^2，直接变为 2n^2+2n）

    2.保留最高次幂项。

    （2n^2+2n 变成 2n^2）

    3.最高次幂项存在但是系数不是1，把系数改成1。

    2n^2 变成 n^2

    所有，上述例子中算法的时间复杂度为 O(n^2)

    1.3.4.3常见的时间复杂度

    时间复杂度是 O(n):

    1. int i = 1;
    2. int sum = 0;
    3. for(i = 1; i <= n; i++){
    4.     sum+=i;
    5. }

    时间复杂度 O(1):

    1. int sum = 0;
    2. sum = (1+n)*n/2;

    时间复杂度 O(n^2):

    1. for(i = 0; i < n; i++){
    2.     for(j = 0; j < n; j++){
    3.         //时间复杂度为 O(1) 的语句
    4.     }
    5. }

    时间复杂度 O(n^3):

    1. for(i = 0; i < n; i++){
    2.     for(j = 0; j < n; j++){
    3.         for(k = 0; k < n; k++){
    4.             //时间复杂度为 O(1) 的语句
    5.         }
    6.     }
    7. }

    时间复杂度 O(logn):

    1. int i = 1;
    2. while(i
    3.     i *= 2;
    4. }

    时间复杂度优劣的排序：

    O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

    1.4顺序表

    1.4.1 概念:

    逻辑结构：线性结构

    存储结构：顺序存储（顺序表）--基础数组实现

    缺点：

    空间使用不够灵活，需要提前确定数组的大小

    插入和删除元素比较麻烦，因为需要批量的移动元素

    优点：

    按照位置查找元素比较快，因为可以通过数组下标来访问元素

    1.4.2 操作：

    创建线性表 

    插入数据元素(尾插、任意位置插入法) 

    删除数据元素(尾删法、任意位置删除法) 

    修改数据元素(根据位置、值修改) 

    在顺序表中查找元素(按位置查找) 

    顺序表的排序 --排序

    清空顺序表 

    释放顺序表 

    打印顺序表中的成员----实际用不到，我们写他是用来学习阶段看现象的 

    1.4.3代码实现

    头文件

    1. #ifndef __SEQ_LIST_H__
    2. #define __SEQ_LIST_H__
    3.  
    4. #include 
    5. #include 
    6.  
    7. #define N 5
    8.  
    9. typedef struct _Student{
    10.     int data;
    11. }stu_t;
    12.  
    13. typedef struct _Seq_list{
    14.     stu_t s[N];
    15.     int count;
    16. }seq_list_t;
    17.  
    18. seq_list_t *create_seq_list1();
    19. int create_seq_list2(seq_list_t **);
    20. int insert_seq_list_by_tail(seq_list_t *my_class, int in_data);
    21. int print_seq_list(seq_list_t *my_class);
    22. int insert_seq_list_by_pos(seq_list_t *my_class, int in_data, int pos);
    23. int delete_from_deq_list_by_pos(seq_list_t *my_class, int pos);
    24. int clean_seq_list(seq_list_t *my_class);
    25. int destroy_seq_list(seq_list_t **my_class);
    26. int search_data_from_seq_list(seq_list_t *my_class, int pos, int *out_data);
    27. int update_seq_list_by_pos(seq_list_t *my_class, int pos, int new_value);
    28. int sort_seq_list(seq_list_t *my_class, int flag);
    29.  
    30. #endif

    函数

    1. #include "seq_list.h"
    2.  
    3. //创建顺序表的方式1  使用指针函数创建
    4. seq_list_t *create_seq_list1(){
    5.     seq_list_t *temp = (seq_list_t *)malloc(sizeof(seq_list_t));
    6.     if(NULL == temp){
    7.         printf("内存分配失败\n");
    8.         exit(-1);//结束进程
    9.     }
    10.     temp->count = 0;
    11.     return temp;
    12. }
    13.  
    14. //创建顺序表的方式2  使用地址传参方式创建
    15. int create_seq_list2(seq_list_t **p){
    16.     if(NULL == p){
    17.         printf("入参为 NULL, 请检查\n");
    18.         return -1;
    19.     }
    20.     *p = (seq_list_t *)malloc(sizeof(seq_list_t));
    21.     if(NULL == *p){
    22.         printf("内存分配失败\n");
    23.         return -1;
    24.     }
    25.     (*p)->count = 0;
    26.     return 0;
    27. }
    28.  
    29. //向顺序表中插入数据的函数--尾插法
    30. int insert_seq_list_by_tail(seq_list_t *my_class, int in_data){
    31.     //入参合理性检查
    32.     if(NULL == my_class){
    33.         printf("入参为 NULL, 请检查\n");
    34.         return -1;
    35.     }
    36.     if(my_class->count == N){
    37.         printf("表已满，插入失败\n");
    38.         return -1;
    39.     }
    40.     my_class->s[my_class->count].data = in_data;
    41.     my_class->count++;
    42.     return 0;
    43. }
    44.  
    45. //打印顺序表中的元素
    46. int print_seq_list(seq_list_t *my_class){
    47.     if(NULL == my_class){
    48.         printf("入参为 NULL, 请检查\n");
    49.         return -1;
    50.     }
    51.     int i = 0;
    52.     for(i = 0; i < my_class->count; i++){
    53.         printf("%d  ", my_class->s[i].data);
    54.     }
    55.     printf("\n");
    56.     return 0;
    57. }
    58.  
    59. //向顺序表中插入数据的函数--任意位置插入
    60. int insert_seq_list_by_pos(seq_list_t *my_class, int in_data, int pos){
    61.     if(NULL == my_class){
    62.         printf("入参为 NULL, 请检查\n");
    63.         return -1;
    64.     }
    65.     if(my_class->count == N){
    66.         printf("表已满，插入失败\n");
    67.         return -1;
    68.     }
    69.     //对插入位置的合理性做检查
    70.     if(pos<0 || pos>my_class->count){
    71.         printf("插入位置不合理，请检查\n");
    72.         return -1;
    73.     }
    74.     //开始插入
    75.     //先将待插入位置后面的数据依次向后移动一步
    76.     int i = 0;
    77.     for(i = my_class->count-1; i >= pos; i--){
    78.         my_class->s[i+1] = my_class->s[i];
    79.     }
    80.     //将数据插入待插入位置
    81.     my_class->s[pos].data = in_data;
    82.     my_class->count++;
    83.     return 0;
    84. }
    85.  
    86. int delete_from_deq_list_by_pos(seq_list_t *my_class, int pos){
    87.     if(NULL == my_class){
    88.         printf("入参为 NULL, 请检查\n");
    89.         return -1;
    90.     }
    91.     if(my_class->count == 0){
    92.         printf("表已空，删除失败\n");
    93.         return -1;
    94.     }
    95.     if(pos<0 || pos>=my_class->count){
    96.         printf("删除位置不合理，请检查\n");
    97.         return -1;
    98.     }
    99.     //执行删除操作
    100.     //从待删除位置开始，后面的元素依次向前移动一步
    101.     int i = 0;
    102.     for(i = pos; i < my_class->count-1; i++){
    103.         my_class->s[i] = my_class->s[i+1];
    104.     }
    105.     my_class->count--;
    106.     return 0;
    107. }
    108.  
    109. //清空顺序表
    110. int clean_seq_list(seq_list_t *my_class){
    111.     if(NULL == my_class){
    112.         printf("入参为 NULL, 请检查\n");
    113.         return -1;
    114.     }
    115.     my_class->count = 0;
    116.     return 0;
    117. }
    118.  
    119. //释放顺序表
    120. int destroy_seq_list(seq_list_t **my_class){
    121.     if(NULL == my_class || NULL == *my_class){
    122.         printf("入参为 NULL, 请检查\n");
    123.         return -1;
    124.     }
    125.     free(*my_class);
    126.     *my_class = NULL;//之所以传二级指针 是为了这一步操作
    127.     return 0;
    128. }
    129.  
    130. //查找顺序表中指定位置的数据
    131. int search_data_from_seq_list(seq_list_t *my_class, int pos, int *out_data){
    132.     if(NULL == my_class || NULL == out_data){
    133.         printf("入参为 NULL, 请检查\n");
    134.         return -1;
    135.     }
    136.     if(pos<0 || pos>=my_class->count){
    137.         printf("查找位置不合理，请检查\n");
    138.         return -1;
    139.     }
    140.     *out_data = my_class->s[pos].data;
    141.     return 0;
    142. }
    143.  
    144. //按照位置修改元素
    145. int update_seq_list_by_pos(seq_list_t *my_class, int pos, int new_value){
    146.     if(NULL == my_class){
    147.         printf("入参为 NULL, 请检查\n");
    148.         return -1;
    149.     }
    150.     if(pos<0 || pos>=my_class->count){
    151.         printf("修改位置不合理，请检查\n");
    152.         return -1;
    153.     }
    154.     my_class->s[pos].data = new_value;
    155.     return 0;
    156. }
    157.  
    158. //顺序表排序
    159. // flag  0  升序   1  降序
    160. int sort_seq_list(seq_list_t *my_class, int flag){
    161.     if(NULL == my_class){
    162.         printf("入参为 NULL, 请检查\n");
    163.         return -1;
    164.     }
    165.     int i = 0;
    166.     int j = 0;
    167.     stu_t temp;
    168.     if(0 == flag){//升序
    169.         for(i = 0; i < my_class->count-1; i++){
    170.             for(j = 0; j < my_class->count-1-i; j++){
    171.                 if(my_class->s[j].data > my_class->s[j+1].data){
    172.                     temp = my_class->s[j];
    173.                     my_class->s[j] = my_class->s[j+1];
    174.                     my_class->s[j+1] = temp;
    175.                 }
    176.             }
    177.         }
    178.     }else if(1 == flag){//降序
    179.         for(i = 0; i < my_class->count-1; i++){
    180.             for(j = 0; j < my_class->count-1-i; j++){
    181.                 if(my_class->s[j].data < my_class->s[j+1].data){
    182.                     temp = my_class->s[j];
    183.                     my_class->s[j] = my_class->s[j+1];
    184.                     my_class->s[j+1] = temp;
    185.                 }
    186.             }
    187.         }
    188.     }
    189.     return 0;
    190. }


    main.c

    1. #include "seq_list.h"
    2.  
    3. int main(){
    4.     seq_list_t *my_class = NULL;
    5.     //my_class = create_seq_list1();
    6.     //创建顺序表
    7.     create_seq_list2(&my_class);
    8.  
    9.     //向顺序表中插入数据
    10.     insert_seq_list_by_tail(my_class, 10);
    11.     insert_seq_list_by_tail(my_class, 20);
    12.     insert_seq_list_by_tail(my_class, 30);
    13.     //打印顺序表中的元素
    14.     print_seq_list(my_class);
    15.  
    16.     int num = 0;
    17.     search_data_from_seq_list(my_class, 1, &num);
    18.     printf("num = %d\n", num);
    19.  
    20.     //将下标为1的元素的值修改成 520
    21.     update_seq_list_by_pos(my_class, 1, 520);
    22.     //打印顺序表中的元素
    23.     print_seq_list(my_class);
    24.     
    25.     //升序排序
    26.     sort_seq_list(my_class, 0);
    27.     //打印顺序表中的元素
    28.     print_seq_list(my_class);
    29.  
    30.     //升序排序
    31.     sort_seq_list(my_class, 1);
    32.     //打印顺序表中的元素
    33.     print_seq_list(my_class);
    34.  
    35.     delete_from_deq_list_by_pos(my_class, 1);
    36.  
    37.     //打印顺序表中的元素
    38.     print_seq_list(my_class);
    39.  
    40.     //清空顺序表
    41.     clean_seq_list(my_class);
    42.  
    43.     //打印顺序表中的元素
    44.     print_seq_list(my_class);
    45.  
    46.     //释放顺序表
    47.     destroy_seq_list(&my_class);
    48.  
    49.     printf("%p\n", my_class);
    50.  
    51.     return 0;
    52. }

    1.5链表

    1.5.1图示：

    1.5.2链表相关的操作：

    1.创建链表 

    2.清空链表 

    3.销毁链表 

    4.头插法 

    5.尾插法 

    6.任意位置插入法 

    7.头删法 

    8.尾删法 

    9.任意位置删除法 

    10.查询链表中是否有想要的数据(在链表中获取指定位置的数据) 

    11.按照位置修改链表中的数据 

    12.按照值修改链表中的数据 

    13.两个链表合并 

    14.链表的排序

    15.链表的翻转

    16.遍历链表的节点----学习阶段看现象用的 

    1.5.3操作示意图：

    1.5.3.1 链表插入数据示意图

     1.5.3.2链表删除数据示意图

     1.5.3.3链表翻转示意图

      1.5.3.4链表的排序示意图

    1.5.3.5 代码实现

    头文件

    1. #ifndef __LINK_LIST_H__
    2. #define __LINK_LIST_H__
    3.  
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. typedef struct __Node{
    9.     int data;//数据域 课上以int为例 实际开发过程中可以自己封装结构体
    10.     struct __Node *next;//指针域  注意此时还不认是  node_t 不能使用
    11. }node_t;
    12.  
    13. int create_node(node_t **p, int in_data);
    14. int insert_data_by_head(node_t *phead, int in_data);
    15. int print_link_list(node_t *phead);
    16. int insert_data_by_tail(node_t *phead, int in_data);
    17. int insert_data_by_pos(node_t *phead, int in_data, int pos);
    18. int del_from_list_by_head(node_t *phead);
    19. int del_from_list_by_tail(node_t *phead);
    20. int del_from_list_by_pos(node_t *phead, int pos);
    21. int get_data_from_list(node_t *phead, int pos, int *num);
    22. int update_list_by_pos(node_t *phead, int pos, int new_data);
    23. int update_list_by_value(node_t *phead, int old_value, int new_value);
    24. int clean_list(node_t *phead);
    25. int destroy_list(node_t **p);
    26. int merge_two_list(node_t *phead1, node_t **phead2);
    27. int overturn_list(node_t *phead);
    28. int sort_list(node_t *phead);
    29.  
    30. #endif

    函数:

    1. #include "link_list.h"
    2.  
    3. //创建节点的函数
    4. int create_node(node_t **p, int in_data){
    5.     if(NULL == p){
    6.         printf("入参为NULL, 请检查\n");
    7.         return -1;
    8.     }
    9.     *p = (node_t *)malloc(sizeof(node_t));
    10.     if(NULL == *p){
    11.         printf("内存分配失败\n");
    12.         exit(-1);
    13.     }
    14.     (*p)->data = in_data;
    15.     (*p)->next = NULL;
    16.     return 0;
    17. }
    18.  
    19. //头插法
    20. int insert_data_by_head(node_t *phead, int in_data){
    21.     if(NULL == phead){
    22.         printf("入参为NULL, 请检查\n");
    23.         return -1;
    24.     }
    25.     //创建新节点
    26.     node_t *pnew = NULL;
    27.     create_node(&pnew, in_data);
    28.     //执行头插操作
    29.     pnew->next = phead->next;
    30.     phead->next = pnew;
    31.     return 0;
    32. }
    33.  
    34. //遍历链表
    35. int print_link_list(node_t *phead){
    36.     if(NULL == phead){
    37.         printf("入参为NULL, 请检查\n");
    38.         return -1;
    39.     }
    40.     node_t *ptemp = phead;
    41.     while(NULL != ptemp->next){
    42.         ptemp = ptemp->next;
    43.         printf("%d  ", ptemp->data);
    44.     }
    45.     printf("\n");
    46.     return 0;
    47. }
    48.  
    49. //尾插法插入数据
    50. int insert_data_by_tail(node_t *phead, int in_data){
    51.     if(NULL == phead){
    52.         printf("入参为NULL, 请检查\n");
    53.         return -1;
    54.     }
    55.     //创建新节点
    56.     node_t *pnew = NULL;
    57.     create_node(&pnew, in_data);
    58.     //执行尾插操作
    59.     node_t *ptemp = phead;
    60.     //遍历链表找到链表的尾节点
    61.     while(ptemp->next != NULL){
    62.         ptemp = ptemp->next;
    63.     }
    64.     //让尾结点的指针域指向新节点
    65.     ptemp->next = pnew;
    66.     return 0;
    67. }
    68.  
    69. //任意位置插入法
    70. int insert_data_by_pos(node_t *phead, int in_data, int pos){
    71.     if(NULL == phead){
    72.         printf("入参为NULL, 请检查\n");
    73.         return -1;
    74.     }
    75.     if(pos<=0){
    76.         printf("插入位置不合理，请检查\n");
    77.         return -1;
    78.     }
    79.     //找到待插入位置的前一节点
    80.     node_t *ptemp = phead;
    81.     int i = 0;
    82.     for(i = 0; i < pos-1; i++){
    83.         ptemp = ptemp->next;
    84. 		if(NULL == ptemp){
    85. 			break;
    86. 		}
    87.     }
    88.     //如果是由于break导致的循环结束 说明位置不合理
    89.     if(i < pos-1){
    90.         printf("插入位置不合理，请检查\n");
    91.         return -1;
    92.     }
    93.  
    94.     //位置合理 创建新节点
    95.     node_t *pnew = NULL;
    96.     create_node(&pnew, in_data);
    97.  
    98.     //将新节点插入
    99.     pnew->next = ptemp->next;
    100.     ptemp->next = pnew;
    101.     return 0;
    102. }
    103.  
    104. //头删法
    105. int del_from_list_by_head(node_t *phead){
    106.     if(NULL == phead){
    107.         printf("入参为NULL, 请检查\n");
    108.         return -1;
    109.     }
    110.     //判断是否有数据用来删除
    111.     if(NULL == phead->next){
    112.         printf("链表中没有数据 头删失败\n");
    113.         return -1;
    114.     }
    115.     //定义一个指针 pdel 保存 第一个数据节点的地址
    116.     node_t *pdel = phead->next;
    117.     phead->next = phead->next->next;
    118.     free(pdel);
    119.     pdel = NULL;
    120.     return 0;
    121. }
    122.  
    123. //尾删法
    124. int del_from_list_by_tail(node_t *phead){
    125.     if(NULL == phead){
    126.         printf("入参为NULL, 请检查\n");
    127.         return -1;
    128.     }
    129.     //判断是否有数据用来删除
    130.     if(NULL == phead->next){
    131.         printf("链表中没有数据 尾删失败\n");
    132.         return -1;
    133.     }
    134.     //找到最后一个节点的前一节点
    135.     node_t *ptemp = phead;
    136.     while(NULL != ptemp->next->next){
    137.         ptemp = ptemp->next;
    138.     }
    139.     free(ptemp->next);
    140.     ptemp->next = NULL;
    141.     return 0;
    142. }
    143.  
    144. //任意位置删除法
    145. int del_from_list_by_pos(node_t *phead, int pos){
    146.     if(NULL == phead){
    147.         printf("入参为NULL, 请检查\n");
    148.         return -1;
    149.     }
    150.     if(pos <= 0 ){
    151.         printf("删除位置不合理 请检查\n");
    152.         return -1;
    153.     }
    154.     node_t *ptemp = phead;
    155.     int i = 0;
    156.     //找到待删除位置的前一节点
    157.     for(i = 0; i < pos-1; i++){
    158.         ptemp = ptemp->next;
    159.         if(ptemp->next == NULL){
    160.             break;
    161.         }
    162.     }
    163.     if(i < pos-1){
    164.         printf("删除位置不合理 请检查\n");
    165.         return -1;
    166.     }
    167.     //执行删除操作
    168.     node_t *pdel = ptemp->next;
    169.     ptemp->next = pdel->next;
    170.     free(pdel);
    171.     pdel = NULL;
    172.     return 0;
    173. }
    174.  
    175. //获取指定位置的数据
    176. int get_data_from_list(node_t *phead, int pos, int *num){
    177.     if(NULL == phead){
    178.         printf("入参为NULL, 请检查\n");
    179.         return -1;
    180.     }
    181.     if(pos <= 0 ){
    182.         printf("获取数据的位置不合理 请检查\n");
    183.         return -1;
    184.     }
    185.     node_t *ptemp = phead;
    186.     int i = 0;
    187.     //找到要获取数据的节点  并做位置合理性的检查
    188.     for(i = 0; i < pos; i++){
    189.         ptemp = ptemp->next;
    190.         if(NULL == ptemp){
    191.             printf("获取数据的位置不合理，请检查\n");
    192.             return -1;
    193.         }
    194.     }
    195.     //如果运行到这儿了 说明位置合理
    196.     *num = ptemp->data;
    197.     return 0;
    198. }
    199.  
    200. //按照位置修改链表中的数据
    201. int update_list_by_pos(node_t *phead, int pos, int new_data){
    202.     if(NULL == phead){
    203.         printf("入参为NULL, 请检查\n");
    204.         return -1;
    205.     }
    206.     if(pos <= 0 ){
    207.         printf("修改数据的位置不合理 请检查\n");
    208.         return -1;
    209.     }
    210.     node_t *ptemp = phead;
    211.     int i = 0;
    212.     //找到要修改数据的节点  并做位置合理性的检查
    213.     for(i = 0; i < pos; i++){
    214.         ptemp = ptemp->next;
    215.         if(NULL == ptemp){
    216.             printf("修改数据的位置不合理，请检查\n");
    217.             return -1;
    218.         }
    219.     }
    220.     //如果运行到这儿了 说明位置合理
    221.     ptemp->data = new_data;
    222.     return 0;
    223. }
    224.  
    225. //根据值修改链表中的数据
    226. int update_list_by_value(node_t *phead, int old_value, int new_value){
    227.     if(NULL == phead){
    228.         printf("入参为NULL, 请检查\n");
    229.         return -1;
    230.     }
    231.     //遍历链表
    232.     node_t *ptemp = phead;
    233.     while(ptemp->next != NULL){
    234.         ptemp = ptemp->next;
    235.         if(ptemp->data == old_value){
    236.             ptemp->data = new_value;
    237.         }
    238.     }
    239.     return 0;
    240. }
    241.  
    242. //清空链表 --释放所有数据节点  保留头结点
    243. int clean_list(node_t *phead){
    244.     if(NULL == phead){
    245.         printf("入参为NULL, 请检查\n");
    246.         return -1;
    247.     }
    248.     //循环头删所有数据节点
    249.     node_t *pdel = NULL;
    250.     while(phead->next != NULL){
    251.         pdel = phead->next;
    252.         phead->next = pdel->next;
    253.         free(pdel);
    254.     }
    255.     pdel = NULL;
    256.     return 0;
    257. }
    258.  
    259. //销毁链表
    260. int destroy_list(node_t **p){
    261.     if(NULL == p || NULL == *p){
    262.         printf("入参为NULL, 请检查\n");
    263.         return -1;
    264.     }
    265.     //防止先调用销毁没调用清空导致的内存泄漏
    266.     //可以在释放头结点之前  先调用一下清空的函数
    267.     clean_list(*p);
    268.  
    269.     free(*p);
    270.     *p = NULL;
    271.     return 0;
    272. }
    273.  
    274. //两个链表合并
    275. int merge_two_list(node_t *phead1, node_t **phead2){
    276.     if(NULL == phead1 || NULL == phead2 || NULL == *phead2){
    277.         printf("入参为NULL, 请检查\n");
    278.         return -1;
    279.     }
    280.     //先找到第一个链表的最后一个节点
    281.     node_t *ptemp = phead1;
    282.     while(ptemp->next != NULL){
    283.         ptemp = ptemp->next;
    284.     }
    285.     //让第一个链表的最后一个节点的指针域指向第二个链表的第一个数据节点
    286.     ptemp->next = (*phead2)->next;
    287.     //释放第二个链表的 头结点
    288.     free(*phead2);
    289.     *phead2 = NULL;
    290.     return 0;
    291. }
    292.  
    293. //链表的翻转
    294. int overturn_list(node_t *phead){
    295.     if(NULL == phead){
    296.         printf("入参为NULL, 请检查\n");
    297.         return -1;
    298.     }
    299.     if(phead->next == NULL){
    300.         printf("链表为空 无需翻转\n");
    301.         return -1;
    302.     }
    303.     if(phead->next->next == NULL){
    304.         printf("链表只有一个数据节点 无需翻转\n");
    305.         return -1;
    306.     }
    307.     node_t *p = phead->next;
    308.     node_t *q = p->next;
    309.     p->next = NULL;
    310.     while(NULL != q){
    311.         p = q->next;
    312.         q->next = phead->next;
    313.         phead->next = q;
    314.         q = p;
    315.     }
    316.     printf("翻转完成\n");
    317.     return 0;
    318. }
    319.  
    320. //链表的排序 --以升序为例
    321. int sort_list(node_t *phead){
    322.     if(NULL == phead){
    323.         printf("入参为NULL, 请检查\n");
    324.         return -1;
    325.     }
    326.     if(phead->next == NULL){
    327.         printf("链表为空 无需排序\n");
    328.         return -1;
    329.     }
    330.     if(phead->next->next == NULL){
    331.         printf("链表只有一个数据节点 无需排序\n");
    332.         return -1;
    333.     }
    334.     int temp = 0;
    335.     node_t *p = phead->next;
    336.     node_t *q = p->next;
    337.     while(NULL != p->next){
    338.         while(NULL != q){
    339.             if(q->data < p->data){
    340.                 //交换数据域
    341.                 temp = p->data;
    342.                 p->data = q->data;
    343.                 q->data = temp;
    344.             }
    345.             q = q->next;
    346.         }
    347.         p = p->next;
    348.         q = p->next;
    349.     }
    350.     printf("升序排序完成\n");
    351.     return 0;
    352. }

    main.c

    1. #include "link_list.h"
    2.  
    3. int main(){
    4.     node_t *phead = NULL;
    5.     //创建头结点
    6.     create_node(&phead, -1);
    7.  
    8.     //头插法插入数据
    9.     insert_data_by_head(phead, 10);
    10.     insert_data_by_head(phead, 20);
    11.     insert_data_by_head(phead, 30);
    12.     insert_data_by_head(phead, 40);
    13.     insert_data_by_head(phead, 50);
    14.  
    15.     //尾插法插入数据
    16.     insert_data_by_tail(phead, 520);
    17.     insert_data_by_tail(phead, 1314);
    18.  
    19.     //任意位置插入
    20.     insert_data_by_pos(phead, 111, 8);
    21.  
    22.     //遍历链表
    23.     print_link_list(phead);
    24.  
    25.     //头删法删除数据
    26.     del_from_list_by_head(phead);
    27.  
    28.     //遍历链表
    29.     print_link_list(phead);
    30.  
    31.     //尾删法删除数据
    32.     del_from_list_by_tail(phead);
    33.  
    34.     //遍历链表
    35.     print_link_list(phead);
    36.  
    37.     //任意位置删除数据
    38.     del_from_list_by_pos(phead,3);
    39.  
    40.     //遍历链表
    41.     print_link_list(phead); 
    42.  
    43.     int num = 0;
    44.     get_data_from_list(phead, 6, &num);
    45.     printf("num = %d\n", num);
    46.  
    47.     //根据位置修改数据
    48.     update_list_by_pos(phead, 4, 40);
    49.     //遍历链表
    50.     print_link_list(phead); 
    51.  
    52.     //根据值修改数据
    53.     update_list_by_value(phead, 40, 520);
    54.     //遍历链表
    55.     print_link_list(phead); 
    56.  
    57.     printf("-------------------------\n");
    58.     node_t *phead2 = NULL;
    59.     create_node(&phead2, -1);
    60.     insert_data_by_head(phead2, 111);
    61.     insert_data_by_head(phead2, 222);
    62.     insert_data_by_head(phead2, 333);
    63.     merge_two_list(phead, &phead2);
    64.     //遍历链表
    65.     print_link_list(phead); 
    66.     printf("phead2 = %p\n", phead2);
    67.     printf("-------------------------\n");
    68.     //链表翻转
    69.     overturn_list(phead);
    70.     //遍历链表
    71.     print_link_list(phead); 
    72.  
    73.     //链表升序排序
    74.     sort_list(phead);
    75.     //遍历链表
    76.     print_link_list(phead); 
    77.  
    78.     //清空链表
    79.     clean_list(phead);
    80.     //遍历链表
    81.     print_link_list(phead); 
    82.  
    83.     //销毁链表
    84.     destroy_list(&phead);
    85.     printf("phead = %p\n", phead);
    86.  
    87.     return 0;
    88. }

    1.6循环链表(基本上和单链表一样就不做各种操作，用一个练习代替了)

    1.6.1图解

     

     1.6.2练习

    循环链表练习：

    一位叫约瑟夫的将军，战斗中，连同手下士兵一起被敌人俘虏了，

    手下的士兵宁死不投降，所以，约瑟夫将军想出了一个办法，

    让大家站成一个圈，从第一个人开始数数，谁数到7了，谁就自杀，

    自杀之后，他的下一个人重新从1开始数，遇到7，再自杀，直到最后只能剩下一个人。

    最后活下来的是约瑟夫，然后他不想死，他投降了。

    这种圈，在现今社会中被叫做，"约瑟夫环"。

    要求，编写程序，命令行 输入 总人数(>=2) 及 数到几(>=2)自杀，

    程序自动计算，将第 n 次 杀掉的 第m个人输出

    最后再输出剩下的是几号

    例如：

    输入 5人 数到3 自杀，

    程序输出：

    第 1 次杀的人是 3 号；

    第 2 次杀的人是 1 号；

    第 3 次杀的人是 5 号；

    第 4 次杀的人是 2 号；

    最后剩下的是 4 号

    1.6.2.1代码实现:

    头文件：

    1. #ifndef _MYHEAD_H__
    2. #define __MYHEAD_H__
    3.  
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. typedef struct _XUN_HU{
    9.     int data;
    10.     struct _XUN_HU *next;
    11. }xun_hun_t;
    12.  
    13. int create_xun_hun(xun_hun_t **phead);
    14. int insert_xun_hun(xun_hun_t *phead,int in_data);
    15. int printf_xun_hun(xun_hun_t *phead);
    16. int yue_se_fu_xun_hun(xun_hun_t *phead,int n,int m);
    17. #endif

    函数:

    1. #include "myhead.h"
    2.  
    3. int create_xun_hun(xun_hun_t **phead)
    4. {
    5.     if(phead==NULL){
    6.         printf("1地址传参错误，请检查\n");
    7.         return -1;
    8.     }
    9.  
    10.     *phead=(xun_hun_t *)malloc(sizeof(xun_hun_t));
    11.  
    12.     (*phead)->next=*phead;
    13.     (*phead)->data=1;
    14.  
    15.     return 0;
    16. }
    17.  
    18. int insert_xun_hun(xun_hun_t *phead,int in_data)
    19. {
    20.     if(phead==NULL){
    21.         printf("2地址传参错误，请检查\n");
    22.         return -1;
    23.     }
    24.  
    25.     xun_hun_t *temp=(xun_hun_t *)malloc(sizeof(xun_hun_t));
    26.     temp->next=NULL;
    27.     
    28.  
    29.     temp->next=phead->next;
    30.     phead->next=temp;
    31.     temp->data=in_data;
    32.  
    33.     return 0;
    34. }
    35.  
    36. int printf_xun_hun(xun_hun_t *phead)
    37. {
    38.    if(phead==NULL){
    39.         printf("3地址传参错误，请检查\n");
    40.         return -1;
    41.    }
    42.  
    43.    xun_hun_t *flags=phead;
    44.  
    45.    while(phead->next!=flags){
    46.         printf("%d ",phead->data);
    47.         phead=phead->next;
    48.    } 
    49.  
    50.    printf("%d\n",phead->data);
    51.    return 0;
    52. }
    53. //n表示从几开始数，m表示数多少个数
    54. int yue_se_fu_xun_hun(xun_hun_t *phead,int n,int m)
    55. {
    56.    if(phead==NULL){
    57.         printf("3地址传参错误，请检查\n");
    58.         return -1;
    59.    }
    60.     
    61.     xun_hun_t *flags=phead;
    62.     int i=0;
    63.     while(phead->next!=phead&&i-1){
    64.         phead=phead->next;
    65.         i++;
    66.     }
    67.  
    68.     //printf("%d\n",phead->data);
    69.     i=0;
    70.     while(phead!=phead->next){
    71.         phead=phead->next;
    72.         i++;
    73.  
    74.         if(i==m-2){
    75.             xun_hun_t *temp=phead->next;
    76.             phead->next=phead->next->next;
    77.             
    78.             printf("%d ",temp->data);
    79.             free(temp);
    80.             temp=NULL;
    81.             i=0;
    82.             phead=phead->next;
    83.         }
    84.     }
    85.     printf("%d\n",phead->data);
    86.     return 0;
    87. }

    main.c:

    1. #include "myhead.h"
    2.  
    3. int main(int argc, char const *argv[])
    4. {
    5.     xun_hun_t *phead=NULL;
    6.  
    7.     create_xun_hun(&phead);
    8.  
    9.     insert_xun_hun(phead,8);
    10.     insert_xun_hun(phead,7);
    11.     insert_xun_hun(phead,6);
    12.     insert_xun_hun(phead,5);
    13.     insert_xun_hun(phead,4);
    14.     insert_xun_hun(phead,3);
    15.     insert_xun_hun(phead,2);
    16.     
    17.  
    18.     printf_xun_hun(phead);
    19.  
    20.     yue_se_fu_xun_hun(phead,3,3);
    21.  
    22.     printf_xun_hun(phead);
    23.     return 0;
    24. }

    1.7双向循环链表（由于步骤和前面差不多，就只讲解一下思路）

    1.7.1 双向链表示意图

     1.7.2双向链表插入节点流程图

     1.7.3双向链表删除节点流程图

     1.8栈

    1.8.1 概念

    栈是一种 先进后出 的数据结构 FILO(first in last out)

    1.8.2栈的存储结构

    顺序存储的栈，我们称之为顺序栈，

    是基于数组实现的，一般会配合一个 "栈顶指针" top 来使用

    顺序栈本身相当于对顺序表操作的一个约束：只允许在同一端插入和删除元素。

    顺序栈的操作：

    创建栈

    清空栈

    销毁栈

    向栈中插入元素：入栈/压栈(push)

    判断栈是否为满

    获取栈中的元素：出栈/弹栈(pop)

    判断栈是否为空

    打印栈中所有元素--学习阶段看现象用的

    1.8.3代码实现

    头文件

    1. #ifndef __SEQ_STACK_H__
    2. #define __SEQ_STACK_H__
    3.  
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define N 3
    9.  
    10. typedef struct _STACK{
    11.     int s[N];//栈的数组 课上以int为例
    12.     int top;//栈顶指针  作为数组下标使用
    13. }stack_t;
    14.  
    15. int create_stack(stack_t **p);
    16. int print_stack(stack_t *my_stack);
    17. int is_full(stack_t *my_stack);
    18. int push_stack(stack_t *my_stack, int value);
    19. int pop_stack(stack_t *my_stack, int *num);
    20. int is_empty(stack_t *my_stack);
    21. int clean_stack(stack_t *my_stack);
    22. int destroy_stack(stack_t **my_stack);
    23.  
    24. #endif

    函数:

    1. #include "seq_stack.h"
    2.  
    3. //创建栈
    4. int create_stack(stack_t **p){
    5.     if(NULL == p){
    6.         printf("入参为NULL 请检查\n");
    7.         return -1;
    8.     }
    9.     *p = (stack_t *)malloc(sizeof(stack_t));
    10.     if(NULL == *p){
    11.         printf("内存分配失败\n");
    12.         exit(-1);
    13.     }
    14.     (*p)->top = 0;
    15.     return 0;
    16. }
    17.  
    18. //入栈
    19. int push_stack(stack_t *my_stack, int value){
    20.     if(NULL == my_stack){
    21.         printf("入参为NULL 请检查\n");
    22.         return -1;
    23.     }
    24.     if(is_full(my_stack)){
    25.         printf("栈已满 入栈失败\n");
    26.         return -1;
    27.     }
    28.     my_stack->s[my_stack->top] = value;
    29.     my_stack->top++;
    30.     return 0;
    31. }
    32.  
    33. //判断栈是否为满  返回 1 满   返回 0 未满
    34. int is_full(stack_t *my_stack){
    35.     if(NULL == my_stack){
    36.         printf("入参为NULL 请检查\n");
    37.         return -1;
    38.     }
    39.     return my_stack->top==N?1:0;
    40. }
    41.  
    42. //出栈
    43. int pop_stack(stack_t *my_stack, int *num){
    44.     if(NULL == my_stack){
    45.         printf("入参为NULL 请检查\n");
    46.         return -1;
    47.     }
    48.     if(is_empty(my_stack)){
    49.         printf("栈已空 出栈失败\n");
    50.         return -1;
    51.     }
    52.     my_stack->top--;
    53.     *num = my_stack->s[my_stack->top];
    54.     return 0;
    55. }
    56.  
    57. //判断栈是否为空  返回 1 空   返回 0 非空
    58. int is_empty(stack_t *my_stack){
    59.     if(NULL == my_stack){
    60.         printf("入参为NULL 请检查\n");
    61.         return -1;
    62.     }
    63.     return my_stack->top==0?1:0;
    64. }
    65.  
    66. //打印栈中所有元素
    67. int print_stack(stack_t *my_stack){
    68.     if(NULL == my_stack){
    69.         printf("入参为NULL 请检查\n");
    70.         return -1;
    71.     }
    72.     int i = 0;
    73.     for(i = 0; i < my_stack->top; i++){
    74.         printf("%d  ", my_stack->s[i]);
    75.     }
    76.     printf("\n");
    77.     return 0;
    78. }
    79.  
    80. //清空栈 ---top置0 即可
    81. int clean_stack(stack_t *my_stack){
    82.     if(NULL == my_stack){
    83.         printf("入参为NULL 请检查\n");
    84.         return -1;
    85.     }
    86.     my_stack->top = 0;
    87.     return 0;
    88. }
    89.  
    90. //销毁栈
    91. int destroy_stack(stack_t **my_stack){
    92.     if(NULL == my_stack || NULL == *my_stack){
    93.         printf("入参为NULL 请检查\n");
    94.         return -1;
    95.     }
    96.     free(*my_stack);
    97.     *my_stack = NULL;
    98.     return 0;
    99. }

    main.c:

    1. #include "seq_stack.h"
    2.  
    3. int main(){
    4.     stack_t *my_stack = NULL;
    5.     //创建栈
    6.     create_stack(&my_stack);
    7.  
    8.     //元素入栈
    9.     push_stack(my_stack, 10);
    10.     push_stack(my_stack, 20);
    11.     push_stack(my_stack, 30);
    12.     push_stack(my_stack, 40);//这次会失败  因为栈已经满了
    13.  
    14.     //遍历栈
    15.     print_stack(my_stack);
    16.  
    17.     int num = 0;
    18.     pop_stack(my_stack, &num);
    19.     printf("num = %d\n", num);
    20.  
    21.     pop_stack(my_stack, &num);
    22.     printf("num = %d\n", num);
    23.  
    24.     pop_stack(my_stack, &num);
    25.     printf("num = %d\n", num);
    26.  
    27.     pop_stack(my_stack, &num);//会失败 因为栈已经空了
    28.     printf("num = %d\n", num);
    29.  
    30.     //在入栈两个元素
    31.     push_stack(my_stack, 10);
    32.     push_stack(my_stack, 20);
    33.     //遍历栈
    34.     print_stack(my_stack);
    35.     //清空栈
    36.     clean_stack(my_stack);
    37.     //遍历栈
    38.     print_stack(my_stack);
    39.  
    40.     //销毁栈
    41.     destroy_stack(&my_stack);
    42.     printf("my_stack = %p\n", my_stack);
    43.  
    44.     return 0;
    45. }

    1.8.3链式栈

    1.8.4.1概念

    链式存储的栈，我们称之为链式栈，

    是基于链表实现的

    链式栈本身相当于对链表表操作的一个约束：只允许在同一端插入和删除元素。

    如果采用链表尾作为入栈和出栈的端点，那么入栈和出栈都需要遍历，时间复杂度都是O(n)

    所以一般链式栈都是 使用链表头部进行 入栈和出栈 时间复杂度是 O(1)

    1.8.4.2顺序栈的操作：

    创建栈

    清空栈

    销毁栈

    向栈中插入元素：入栈/压栈(push)

    获取栈中的元素：出栈/弹栈(pop)

    判断栈是否为空

    打印栈中所有元素--学习阶段看现象用的

    1.8.4.3顺序栈代码实现：

    头文件:

    1. #ifndef __LINK_STACK_H__
    2. #define __LINK_STACK_H__
    3.  
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. typedef struct _Node{
    9.     int data;
    10.     struct _Node *next;
    11. }node_t;
    12.  
    13. typedef struct _Stack{
    14.     unsigned int count;
    15.     node_t *top;
    16. }stack_t;
    17.  
    18. int create_stack(stack_t **my_stack);
    19. int push_stack(stack_t *my_stack, int value);
    20. int pop_stack(stack_t *my_stack, int *num);
    21. int is_empty(stack_t *my_stack);
    22. int clean_stack(stack_t *my_stack);
    23. int destroy_stack(stack_t **my_stack);
    24. int print_stack(stack_t *my_stack);
    25.  
    26. #endif

    函数：

    1. #include "link_stack.h"
    2.  
    3. //创建栈
    4. int create_stack(stack_t **my_stack){
    5.     if(NULL == my_stack){
    6.         printf("入参为NULL 请检查\n");
    7.         return -1;
    8.     }
    9.     *my_stack = (stack_t *)malloc(sizeof(stack_t));
    10.     if(NULL == *my_stack){
    11.         printf("内存分配失败\n");
    12.         exit(-1);
    13.     }
    14.     (*my_stack)->count = 0;
    15.     (*my_stack)->top = NULL;
    16.     return 0;
    17. }
    18.  
    19. //入栈
    20. int push_stack(stack_t *my_stack, int value){
    21.     if(NULL == my_stack){
    22.         printf("入参为NULL 请检查\n");
    23.         return -1;
    24.     }
    25.     //先创建新的 数据节点
    26.     node_t *pnew = (node_t *)malloc(sizeof(node_t));
    27.     if(NULL == pnew){
    28.         printf("内存分配失败\n");
    29.         exit(-1);
    30.     }
    31.     pnew->data = value;
    32.     pnew->next = NULL;
    33.  
    34.     //将新节点头插到链表中
    35.     pnew->next = my_stack->top;
    36.     my_stack->top = pnew;
    37.  
    38.     my_stack->count++;
    39.     return 0;
    40. }
    41.  
    42. //出栈
    43. int pop_stack(stack_t *my_stack, int *num){
    44.     if(NULL == my_stack){
    45.         printf("入参为NULL 请检查\n");
    46.         return -1;
    47.     }
    48.     if(is_empty(my_stack)){
    49.         printf("栈为空 出栈失败\n");
    50.         return -1;
    51.     }
    52.     //数据出栈
    53.     *num = my_stack->top->data;
    54.     //删除已经出栈数据的节点--头删
    55.     node_t *pdel = my_stack->top;
    56.     my_stack->top = pdel->next;
    57.     free(pdel);
    58.     pdel = NULL;
    59.  
    60.     my_stack->count--;
    61.     return 0;
    62. }
    63.  
    64. //判断栈是否为空  返回 1 空  返回 0 非空
    65. int is_empty(stack_t *my_stack){
    66.     if(NULL == my_stack){
    67.         printf("入参为NULL 请检查\n");
    68.         return -1;
    69.     }
    70.     return my_stack->top == NULL ? 1 : 0;
    71. }
    72.  
    73. //清空栈
    74. int clean_stack(stack_t *my_stack){
    75.     if(NULL == my_stack){
    76.         printf("入参为NULL 请检查\n");
    77.         return -1;
    78.     }
    79.     node_t *pdel = NULL;
    80.     //循环头删 删除所有的 数据节点
    81.     while(NULL != my_stack->top){
    82.         pdel = my_stack->top;
    83.         my_stack->top = pdel->next;
    84.         free(pdel);
    85.     }
    86.     pdel = NULL;
    87.  
    88.     //个数清零
    89.     my_stack->count = 0;
    90.  
    91.     return 0;
    92. }
    93.  
    94. //销毁栈
    95. int destroy_stack(stack_t **my_stack){
    96.     if(NULL == *my_stack || NULL == my_stack){
    97.         printf("入参为NULL 请检查\n");
    98.         return -1;
    99.     }
    100.     //先调用清空
    101.     clean_stack(*my_stack);
    102.  
    103.     free(*my_stack);
    104.     *my_stack = NULL;
    105.     return 0;
    106. }
    107.  
    108. //遍历栈
    109. int print_stack(stack_t *my_stack){
    110.     if(NULL == my_stack){
    111.         printf("入参为NULL 请检查\n");
    112.         return -1;
    113.     }
    114.     node_t *ptemp = my_stack->top;
    115.     while(NULL != ptemp){
    116.         printf("%d  ", ptemp->data);
    117.         ptemp = ptemp->next;
    118.     }
    119.     printf("\n");
    120.     return 0;
    121. }

    main.c:

    1. #include "link_stack.h"
    2.  
    3. int main(){
    4.     stack_t *my_stack = NULL;
    5.     //创建栈
    6.     create_stack(&my_stack);
    7.  
    8.     //数据入栈
    9.     push_stack(my_stack, 10);
    10.     push_stack(my_stack, 20);
    11.     push_stack(my_stack, 30);
    12.  
    13.     //遍历栈
    14.     print_stack(my_stack);
    15.  
    16.     //数据出栈
    17.     int num = 0;
    18.     pop_stack(my_stack, &num);
    19.     printf("num = %d\n", num);
    20.  
    21.     pop_stack(my_stack, &num);
    22.     printf("num = %d\n", num);
    23.  
    24.     pop_stack(my_stack, &num);
    25.     printf("num = %d\n", num);
    26.  
    27.     pop_stack(my_stack, &num);
    28.     printf("num = %d\n", num);
    29.  
    30.     //再入栈两个元素
    31.     push_stack(my_stack, 520);
    32.     push_stack(my_stack, 1314);
    33.     //遍历栈
    34.     print_stack(my_stack);
    35.  
    36.     //清空栈
    37.     clean_stack(my_stack);
    38.     //遍历栈
    39.     print_stack(my_stack);
    40.  
    41.     //销毁栈
    42.     destroy_stack(&my_stack);
    43.     printf("my_stack = %p\n", my_stack);
    44.  
    45.     return 0;

    1.9队列

    1.9.1 概念

    队列是一种先进先出的结构。 FIFO（first in first out）

    1.9.1.1队列的逻辑结构

    线性结构

    1.9.1.2队列的存储结构

    顺序队列是基于顺序表配个两个下标，一个是队列头 front，一个是队列尾 rear。

    顺序队列相当于对顺序表操作的一种约束：一端插入，另一端删除。

    一般这种顺序队列我们不使用，因为 入队列时 rear++ 出队列时 front++

    相当于每块空间指使用了一次，即使出队列了，空间也不会复用了，相当于一次性的

    1.9.1.3 循环队列

    这种结构的队列可以让空间复用起来。

    每次插入完数据 不要执行 rear++ 而改成 rear = (reat+1)%N

    每次删除完数据 不要执行 front++ 而改成 front = (front+1)%N

    判断队列空 rear == front

    判断队列满 (rear+1)%N == front (浪费了一个存储空间用来和判断空作区分，方便写代

    1.9.1.4循序队列的操作：

    创建队列

    清空队列

    销毁队列

    入队列

    判断队列是否为满

    出队列

    判断队列是否为空

    1.9.1.5顺序队列的代码实现

    头文件

    1. #ifndef __SEQ_QUEUE_H__
    2. #define __SEQ_QUEUE_H__
    3.  
    4. #include 
    5. #include 
    6.  
    7. #define N 5
    8.  
    9. typedef struct _Queue{
    10.     int s[N];
    11.     int front; //头
    12.     int rear;  //尾
    13. }queue_t;
    14.  
    15. int create_queue(queue_t **p);
    16. int push_queue(queue_t *my_queue, int in_data);
    17. int is_full(queue_t *my_queue);
    18. int pop_queue(queue_t *my_queue, int *out_data);
    19. int is_empty(queue_t *my_queue);
    20. int clean_queue(queue_t *my_queue);
    21. int destroy_queue(queue_t **my_queue);
    22. int print_queue(queue_t *my_queue);
    23.  
    24. #endif

    函数

    1. #include "seq_queue.h"
    2.  
    3. //创建队列
    4. int create_queue(queue_t **p){
    5.     if(NULL == p){
    6.         printf("入参为 NULL,请检查\n");
    7.         return -1;
    8.     }
    9.     *p = (queue_t *)malloc(sizeof(queue_t));
    10.     if(NULL == *p){
    11.         printf("内存分配失败\n");
    12.         exit(-1);
    13.     }
    14.     (*p)->front = 0;
    15.     (*p)->rear = 0;
    16.     return 0;
    17. }
    18.  
    19. //入队列
    20. int push_queue(queue_t *my_queue, int in_data){
    21.     if(NULL == my_queue){
    22.         printf("入参为 NULL,请检查\n");
    23.         return -1;
    24.     }
    25.     if(is_full(my_queue)){
    26.         printf("队列满 入队列失败\n");
    27.         return -1;
    28.     }
    29.     //执行入队列操作
    30.     printf("入之前：front = %d  rear = %d\n", my_queue->front, my_queue->rear);
    31.     my_queue->s[my_queue->rear] = in_data;
    32.     my_queue->rear = (my_queue->rear+1)%N;
    33.     printf("入之后：front = %d  rear = %d\n", my_queue->front, my_queue->rear);
    34.     return 0;
    35. }
    36.  
    37. //判断队列满  返回1满  0 未满
    38. int is_full(queue_t *my_queue){
    39.     if(NULL == my_queue){
    40.         printf("入参为 NULL,请检查\n");
    41.         return -1;
    42.     }
    43.     return (my_queue->rear+1)%N == my_queue->front ? 1 : 0;
    44. }
    45.  
    46. //出队列
    47. int pop_queue(queue_t *my_queue, int *out_data){
    48.     if(NULL == my_queue || NULL == out_data){
    49.         printf("入参为 NULL,请检查\n");
    50.         return -1;
    51.     }
    52.     if(is_empty(my_queue)){
    53.         printf("队列空 出队列失败\n");
    54.         return -1;
    55.     }
    56.     //执行出队列操作
    57.     *out_data = my_queue->s[my_queue->front];
    58.     my_queue->front = (my_queue->front+1)%N;
    59.     return 0;
    60. }
    61.  
    62. //判断队列空  返回1空  0 非空
    63. int is_empty(queue_t *my_queue){
    64.     if(NULL == my_queue){
    65.         printf("入参为 NULL,请检查\n");
    66.         return -1;
    67.     }
    68.     return my_queue->front == my_queue->rear ? 1 : 0;
    69. }
    70.  
    71. //清空队列
    72. int clean_queue(queue_t *my_queue){
    73.     if(NULL == my_queue){
    74.         printf("入参为 NULL,请检查\n");
    75.         return -1;
    76.     }
    77.     my_queue->front = 0;
    78.     my_queue->rear = 0;
    79.     return 0;
    80. }
    81.  
    82. //销毁队列
    83. int destroy_queue(queue_t **my_queue){
    84.     if(NULL == my_queue || NULL == *my_queue){
    85.         printf("入参为 NULL,请检查\n");
    86.         return -1;
    87.     }
    88.     free(*my_queue);
    89.     *my_queue = NULL;
    90.     return 0;
    91. }
    92.  
    93. //遍历队列
    94. int print_queue(queue_t *my_queue){
    95.     if(NULL == my_queue){
    96.         printf("入参为 NULL,请检查\n");
    97.         return -1;
    98.     }
    99.     int i = 0;
    100.     for(i = my_queue->front; (i%N)!=my_queue->rear ;i++){
    101.         printf("%d ", my_queue->s[i%N]);
    102.     }
    103.     printf("\n");
    104.     return 0;
    105. }

    main.c

    1. #include "seq_queue.h"
    2.  
    3. int main(){
    4.     queue_t *my_queue = NULL;
    5.     //创建队列
    6.     create_queue(&my_queue);
    7.     //数据入队列
    8.     push_queue(my_queue, 10);
    9.     push_queue(my_queue, 20);
    10.     push_queue(my_queue, 30);
    11.     push_queue(my_queue, 40);
    12.     //push_queue(my_queue, 50);//队列满
    13.  
    14.     //遍历队列
    15.     print_queue(my_queue);
    16.  
    17.     //数据出队列
    18.     int num = 0;
    19.     pop_queue(my_queue, &num);
    20.     printf("num = %d\n", num);
    21.  
    22.     pop_queue(my_queue, &num);
    23.     printf("num = %d\n", num);
    24.     
    25.     pop_queue(my_queue, &num);
    26.     printf("num = %d\n", num);
    27.  
    28.     pop_queue(my_queue, &num);
    29.     printf("num = %d\n", num);
    30.     
    31.     //pop_queue(my_queue, &num);//失败  队列空
    32.     //printf("num = %d\n", num);
    33.  
    34.     //遍历队列
    35.     print_queue(my_queue);
    36.  
    37.     //再入队列几个数据
    38.     push_queue(my_queue, 50);
    39.     push_queue(my_queue, 60);
    40.     push_queue(my_queue, 70);
    41.     push_queue(my_queue, 80);
    42.     //遍历队列
    43.     print_queue(my_queue);
    44.     
    45.     //清空队列
    46.     clean_queue(my_queue);
    47.     //遍历队列
    48.     print_queue(my_queue);
    49.  
    50.     //销毁队列
    51.     destroy_queue(&my_queue);
    52.     printf("my_queue = %p\n", my_queue);
    53.  
    54.     return 0;
    55. }

    1.10链式队列

    1.10.1概念:

    链式队列是基于链表实现的。

    链式队列相当于对链表操作的一种约束：一端插入，另一端删除。

    一般使用 尾插头删法

    1.10.2链式队列的操作：

    创建队列

    清空队列

    销毁队列

    入队列

    出队列

    判断队列是否为空

    遍历队列--学习阶段看现象用的

    1.10.3代码实现

    头文件

    1. #ifndef __LINK_QUEUE_H__
    2. #define __LINK_QUEUE_H__
    3.  
    4. #include 
    5. #include 
    6.  
    7. typedef struct _Node{
    8.     int data;
    9.     struct  _Node *next;   
    10. }node_t;
    11.  
    12. typedef struct _Queue{
    13.     node_t *front;
    14.     node_t *rear;
    15. }queue_t;
    16.  
    17. int create_queue(queue_t **p);
    18. int push_queue(queue_t *my_queue, int in_data);
    19. int print_queue(queue_t *my_queue);
    20. int pop_queue(queue_t *my_queue, int *out_data);
    21. int is_empty(queue_t *my_queue);
    22. int clean_queue(queue_t *my_queue);
    23. int destroy_queue(queue_t **my_queue);
    24.  
    25. #endif

    函数

    1. #include "link_queue.h"
    2.  
    3. //创建队列
    4. int create_queue(queue_t **p){
    5.     if(NULL == p){
    6.         printf("入参为NULL, 请检查\n");
    7.         return -1;
    8.     }
    9.     *p = (queue_t *)malloc(sizeof(queue_t));
    10.     if(NULL == *p){
    11.         printf("内存分配失败\n");
    12.         exit(-1);
    13.     }
    14.     (*p)->front = NULL;
    15.     (*p)->rear = NULL;
    16.     return 0;
    17. }
    18.  
    19. //数据入队列
    20. int push_queue(queue_t *my_queue, int in_data){
    21.     if(NULL == my_queue){
    22.         printf("入参为NULL, 请检查\n");
    23.         return -1;
    24.     }
    25.     //先创建数据节点
    26.     node_t *pnew = (node_t *)malloc(sizeof(node_t));
    27.     if(NULL == pnew){
    28.         printf("内存分配失败\n");
    29.         exit(-1);
    30.     }
    31.     pnew->data = in_data;
    32.     pnew->next = NULL;
    33.     //执行插入操作
    34.     if(my_queue->front==NULL && my_queue->rear==NULL){
    35.         //说明是第一个数据节点
    36.         my_queue->front = pnew;
    37.         my_queue->rear = pnew;
    38.     }else{
    39.         //说明不是第一个数据节点
    40.         my_queue->rear->next = pnew;
    41.         my_queue->rear = pnew;
    42.     }
    43.     return 0;
    44. }
    45.  
    46. //遍历队列
    47. int print_queue(queue_t *my_queue){
    48.     if(NULL == my_queue){
    49.         printf("入参为NULL, 请检查\n");
    50.         return -1;
    51.     }
    52.     node_t *ptemp = my_queue->front;
    53.     while(NULL != ptemp){
    54.         printf("%d ", ptemp->data);
    55.         ptemp = ptemp->next;
    56.     }
    57.     printf("\n");
    58.     return 0;
    59. }
    60.  
    61. //数据出队列
    62. int pop_queue(queue_t *my_queue, int *out_data){
    63.     if(NULL == my_queue || NULL == out_data){
    64.         printf("入参为NULL, 请检查\n");
    65.         return -1;
    66.     }
    67.     if(is_empty(my_queue)){
    68.         printf("队列已经空了 出队列失败\n");
    69.         return -1;
    70.     }
    71.     //执行出队列的操作
    72.     *out_data = my_queue->front->data;
    73.     node_t *pdel = my_queue->front;
    74.     my_queue->front = pdel->next;
    75.     free(pdel);
    76.     pdel = NULL;
    77.     //如果出队列之后没有节点了  rear的指向也要更新
    78.     if(NULL == my_queue->front){
    79.         my_queue->rear = NULL;
    80.     }
    81.     return 0;
    82. }
    83.  
    84. //判断队列是否为空  返回1空  0非空
    85. int is_empty(queue_t *my_queue){
    86.     if(NULL == my_queue){
    87.         printf("入参为NULL, 请检查\n");
    88.         return -1;
    89.     }
    90.     return my_queue->front==NULL?1:0;
    91. }
    92.  
    93. //清空队列
    94. int clean_queue(queue_t *my_queue){
    95.     if(NULL == my_queue){
    96.         printf("入参为NULL, 请检查\n");
    97.         return -1;
    98.     }
    99.     //头删法删除所有节点
    100.     node_t *pdel = NULL;
    101.     while(NULL != my_queue->front){
    102.         pdel = my_queue->front;
    103.         my_queue->front = pdel->next;
    104.         free(pdel);
    105.     }
    106.     pdel = NULL;
    107.     my_queue->rear = NULL;
    108.     return 0;
    109. }
    110.  
    111. //销毁队列
    112. int destroy_queue(queue_t **my_queue){
    113.     if(NULL == my_queue || NULL == *my_queue){
    114.         printf("入参为NULL, 请检查\n");
    115.         return -1;
    116.     }
    117.     //先调用清空
    118.     clean_queue(*my_queue);
    119.     //再销毁
    120.     free(*my_queue);
    121.     *my_queue = NULL;
    122.     return 0;
    123. }

    main.c

    1. #include "link_queue.h"
    2.  
    3. int main(){
    4.     queue_t *my_queue = NULL;
    5.     //创建队列
    6.     create_queue(&my_queue);
    7.  
    8.     //数据入队列
    9.     push_queue(my_queue, 10);
    10.     push_queue(my_queue, 20);
    11.     //printf("front = %p  rear = %p\n", my_queue->front, my_queue->rear);
    12.  
    13.     //遍历队列
    14.     print_queue(my_queue);
    15.  
    16.     //数据出队列
    17.     int num = 0;
    18.     pop_queue(my_queue, &num);
    19.     printf("num = %d\n", num);
    20.     //printf("front = %p  rear = %p\n", my_queue->front, my_queue->rear);
    21.  
    22.     pop_queue(my_queue, &num);
    23.     printf("num = %d\n", num);
    24.  
    25.     //pop_queue(my_queue, &num);//失败  队列已经空了
    26.     //printf("num = %d\n", num);
    27.     //printf("front = %p  rear = %p\n", my_queue->front, my_queue->rear);
    28.  
    29.     //再入队列几个元素
    30.     push_queue(my_queue, 10);
    31.     push_queue(my_queue, 20);
    32.     push_queue(my_queue, 30);
    33.     push_queue(my_queue, 40);
    34.     //遍历队列
    35.     print_queue(my_queue);
    36.  
    37.     //清空队列
    38.     clean_queue(my_queue);
    39.     //遍历队列
    40.     print_queue(my_queue);
    41.  
    42.     //销毁队列
    43.     destroy_queue(&my_queue);
    44.     printf("my_queue = %p\n", my_queue);
    45.  
    46.     return 0;
    47. }

    1.11递归

    1.11.1概念

    递归就是在函数内部再次调用函数自身的逻辑。

    注意，每个递归都要有一个出口，否则函数无限次的调用下去，会把内存资源耗尽，

    会出现堆栈溢出，导致段错误。

    注意，递归本质就是函数调用，不是C语言程序结构的一种。

    C语言程序结构只有三种：顺序结构、分支结构(选择结构)、循环结构。

    1.11.2例子

    1~n求和

    1. #include 
    2.  
    3. //1~n求和
    4. int func(int n){
    5.     	if(n==1){
    6.     		return 1;//递归的出口
    7.     	}
    8.     	return n+func(n-1);
    9. }
    10.  
    11. int main(int argc, const char *argv[])
    12. {
    13. 	int ret = 0;
    14. 	ret = func(5);
    15. 	printf("sum = %d\n", ret);
    16. 	return 0;
    17. }

    青蛙跳台阶，共有10阶台阶，青蛙每次可以选择跳一阶或者两阶，

    问：青蛙跳上这10个台阶共有多少种跳法

    1. #include 
    2.  
    3. //计算跳上第n阶 有几种跳法
    4. //返回值：就是跳法的多少
    5. int func(int n){
    6. 	//递归的出口
    7. 	if(1 == n){
    8. 		return 1;
    9. 	}
    10. 	if(2 == n){
    11. 		return 2;
    12. 	}
    13. 	return func(n-1) + func(n-2);
    14. }
    15.  
    16. int main(int argc, const char *argv[])
    17. {
    18. 	int ret = 0;
    19. 	ret = func(10);
    20. 	printf("ret = %d\n", ret);//89
    21. 	return 0;
    22. }

    1.12.1快速排序

    1.12.1.1概念

    快速排序是冒泡排序的优化，也是一种基于交换的排序方式。

    时间复杂度 O(nlogn)。

    1.12.1.2基本思想

    分而治之

    通过一趟排序，先将数据分成两部分，其中一部分的数据，

    都比另一部分的数据大(小)，（每部分数据内部不要求有序）

    然后，对于两部分数据分别进行上述的排序操作，把没部分数据再分成两部分，

    依次类推，直到整个数据有序。

    1.12.1.3代码实现

    1. #include 
    2.  
    3. //一趟排序
    4. int sort(int *s, int low, int high){
    5.         //选取一个比较的基准，选待排序列中的那个都可以
    6.         //一般情况下，为了方便写代码，我们都选下标最小的那个
    7.         int flag = s[low];
    8.  
    9.         while(low
    10.                 while(s[high] > flag && low < high){//如果是降序，将此处的s[high] > flag 改成 s[high] < flag
    11.                         high--;
    12.                 }
    13.                 if(low
    14.                         s[low] = s[high];
    15.                         low++;
    16.                 }
    17.                 while(s[low] < flag  && low < high){//如果是降序，将此处的s[low] < flag 改成 s[low] > flag
    18.                         low++;
    19.                 }
    20.                 if(low
    21.                         s[high] = s[low];
    22.                         high--;
    23.                 }
    24.         }
    25.         //记得把 flag 塞回去
    26.         s[low] = flag;
    27.         return low;//return high也可以，因为此时 low和high是相等的
    28. }
    29.  
    30. //快速排序
    31. int quick_sort(int *s, int low, int high){
    32.         //递归的出口
    33.         if(low
    34.                 int ret = sort(s, low, high);
    35.                 quick_sort(s, 0, ret-1);
    36.                 quick_sort(s, ret+1, high);
    37.         }
    38. }
    39.  
    40. int print_arr(int *p){
    41.         int i = 0;
    42.         for(i = 0; i < 10; i++){
    43.                 printf("%d  ", p[i]);
    44.         }
    45.         printf("\n");
    46. }
    47.  
    48. int main(int argc, const char *argv[])
    49. {
    50.         int s[10] = {6, 4, 9, 3, 7, 5, 8, 2, 1, 10};
    51.         //排序前
    52.         print_arr(s);
    53.  
    54.         //执行快速排序
    55.         quick_sort(s, 0, 9);
    56.  
    57.         printf("---------------------------\n");
    58.         //排序后
    59.         print_arr(s);
    60.  
    61.         return 0;
    62. }

    1.14树的前中后续遍历

    1.14.1概念

    前序遍历：根左右，先遍历根节点，然后遍历左子树，最后遍历右子树。

    一般在构建树的过程中会用到前序遍历，因为现有根，才有左右子树。

    中序遍历：左根右，先遍历左子树，然后遍历根节点，最后遍历右子树。

    一般遍历时使用中序，对于有序的树，使用中序遍历能得到有序的序列。

    后序遍历：左右根，先遍历左子树，然后遍历右子树，最后遍历根节点。

    释放树中所有节点时，一般使用后续，因为如果把根节点释放了，就没法访问左右子树了。

    1.14.2图例

    前序：ABCDEFGHI

    中序：BDCAEHGIF

    后序：DCBHIGFEA

    1.14.3代码实现

    1. #include 
    2. #include 
    3.  
    4. //树的节点类型
    5. typedef struct _Node{
    6.     int data;//数据域
    7.     struct _Node *lchild;//指向左孩子的指针
    8.     struct _Node *rchild;//指向右孩子的指针
    9. }node_t;
    10.  
    11. //创建一棵树
    12. int create_tree(node_t **root){
    13.     if(NULL == root){
    14.         printf("入参为NULL, 请检查\n");
    15.         return -1;
    16.     }
    17.  
    18.     char value = 0;
    19.     scanf("%c", &value);
    20.     getchar();//清理垃圾字符
    21.     //递归的出口
    22.     if('#' == value){
    23.         return 0;
    24.     }
    25.     //分配空间
    26.     *root = (node_t *)malloc(sizeof(node_t));
    27.     if(NULL == *root){
    28.         printf("内存分配失败\n");
    29.         exit(-1);
    30.     }
    31.  
    32.     (*root)->data = value;
    33.     (*root)->lchild = NULL;
    34.     (*root)->rchild = NULL;
    35.  
    36.     //创建左子树
    37.     create_tree(&((*root)->lchild));
    38.     //创建右子树
    39.     create_tree(&((*root)->rchild));
    40.  
    41.     return 0;
    42. }
    43.  
    44. //前序遍历
    45. int qianxu(node_t *root){
    46.     if(NULL == root){//递归的出口
    47.         return -1;
    48.     }
    49.     printf("%c", root->data);
    50.     qianxu(root->lchild);
    51.     qianxu(root->rchild);
    52.     return 0;
    53. }
    54.  
    55. //中序遍历
    56. int zhongxu(node_t *root){
    57.     if(NULL == root){//递归的出口
    58.         return -1;
    59.     }
    60.     zhongxu(root->lchild);
    61.     printf("%c", root->data);
    62.     zhongxu(root->rchild);
    63.     return 0;
    64. }
    65.  
    66. //后序遍历
    67. int houxu(node_t *root){
    68.     if(NULL == root){//递归的出口
    69.         return -1;
    70.     }
    71.     houxu(root->lchild);
    72.     houxu(root->rchild);
    73.     printf("%c", root->data);
    74.     return 0;
    75. }
    76.  
    77. //销毁树
    78. int destroy_tree(node_t **root){
    79.     if(root == NULL || *root == NULL){
    80.         return -1;
    81.     }
    82.     destroy_tree(&((*root)->lchild));
    83.     destroy_tree(&((*root)->rchild));
    84.     free(*root);
    85.     *root = NULL;
    86.     return 0;
    87. }
    88.  
    89. int main(){
    90.     node_t *root = NULL;
    91.     create_tree(&root);
    92.  
    93.     //前序
    94.     printf("前序遍历\n");
    95.     qianxu(root);
    96.     printf("\n");
    97.  
    98.     //中序
    99.     printf("中序遍历\n");
    100.     zhongxu(root);
    101.     printf("\n");
    102.  
    103.     //后序
    104.     printf("后序遍历\n");
    105.     houxu(root);
    106.     printf("\n");
    107.     
    108.     //销毁树
    109.     destroy_tree(&root);
    110.  
    111.     return 0;
    112. }

    1.14.4树的练习

    练习1：

    已知一棵树前序和中序的遍历结果：

    前序： A B C E H F I J D G K

    中序： A H E C I F J B D K G

    请画出这个树的结构。

    解题思路：

    根据前序，能确定根，

    然后根据中序，确定哪些节点是根的左子树，哪些是根的右子树

    然后再根据前序确定子树的根

    在根据中序确定子树的子树。。。依次类推。。

     1.15哈希

    练习：

    从终端输入任意一个只包含小写字母的字符串

    输出每个字符出现的次数。

    如：输入：aabbccdfe

    1. #include 
    2.  
    3. int get_index(char value){
    4.     return value-'a';
    5. }
    6.  
    7. int main(){
    8.     char s[128] = {0};
    9.     printf("请输入字符串(小写):");
    10.     scanf("%s", s);
    11.  
    12.     //用来保存字母出现次数的数组
    13.     //count[0]  --> a出现的次数
    14.     //count[1]  --> b出现的次数
    15.     //...
    16.     //count[25] --> z出现的次数
    17.     unsigned int count[26] = {0};
    18.  
    19.     //遍历字符串，统计次数
    20.     int i = 0;
    21.     int index = 0;
    22.     while(s[i] != '\0'){
    23.         index = get_index(s[i]);
    24.         count[index]++;
    25.         i++;
    26.     }
    27.  
    28.     //输出次数
    29.     for(i = 0; i < 26; i++){
    30.         printf("%c : %d\n", i+'a', count[i]);
    31.     }
    32.  
    33.     return 0;
    34. }

  • 相关阅读:
    网络安全原理与实践学习笔记——设计DMZ
    Java进阶 - 易错知识点整理（待更新）
    从C语言基础到高级C语言 （结构体和位域）
    12. 一文快速学懂常用工具——docker 命令
    2023.10.18
    【高分快刊】Elsevier旗下，中科院2区SCI，2个月19天录用！
    STM32_DMA_多通道采集ADC出现错位现象
    epoll 和 reactor 的关系
    15.cuBLAS开发指南中文版--cuBLAS中的Level-1函数rotg()
    Affinity Propagation (AP)近邻传播聚类
  • 原文地址：https://blog.csdn.net/a2998658795/article/details/125907749