数据结构笔记

本篇内容是根据B站郝斌数据结构的学习笔记，本篇笔记是用markdown根据Typora编写，copy到博客有些格式微调，如发现错误望留言指正，不胜感激！

如想转载请注明出处谢谢！

 

数据结构

概述

  • 数据结构定义

    我们如何把现实中大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对元素进行排序等）而执行的相应操作，这个相应的操作也叫算法。

    数据结构 = 个体的存储 + 个体的关系存储

    算法 = 对存储数据的操作

  • 算法定义

    • 通俗的说算法是解题的方法和步骤

    • 衡量算法的标准

      1. 时间复杂度：程序大概要执行的次数，而非执行的时间。

      2. 空间复杂度：程序执行过程中大概所占用的最大内存空间。

      3. 难易程度：用易懂，避免过于复杂。

      4. 健壮性

  • 数据结构的地位

    数据结构是软件中最核心的课程

    程序=数据的存储+数据的操作+可以被计算机执行的语言

预备知识

  1. 指针

    • 指针的重要性：指针是C语言的灵魂

    • 定义：

      • 地址：内存单元的编号，从0开始的非负整数

      • 指针：指针就是地址，地址就是指针；指针变量是存放内存单元地址的变量；指针的本质是一个操作受限的非负整数。

    • 分类：基本类型的指针；指针和数组的关系

  2. 结构体

    • 为什么会出现结构体：为了表示一些复杂的数据，而普通的基本类型变量无法满足要求；

    • 定义：结构体是用户根据实际需要自己定义的复合数类型；

    • 如何使用结构体

      //定义结构体
struct Student
{
    int sid;
    char name[200];
    int age;
};

       

      • //整体赋值，类似于Java中new类的构造函数 
        struct Student st = {1001,"zhangsan",18}；
//单个赋值
st.id=1001；
strcpy(st.name,"zhangsan")；
st.age=18； 
      • //通常使用指针的方式赋值
        struct Student *pst；
//pst所指向的结构体变量中的sid这个成员
pst->sid=1001；
strcpy(pst->name,"lisi")；
pst->age=19；

         

         

    • 注意事项：结构体变量不能算术计算，但是可以赋值；普通结构体变量和结构体指针变量作为函数传参的问题，推荐使用传递结构体指针的方式，这样效率高节约内存。

  3. 动态内存的分配和释放　　　

　样例代码：　　　　

 1  1 一维数组:
 2  2 
 3  3 # include <stdio.h>
 4  4 # include <malloc.h>
 5  5 ​
 6  6 int main(void)
 7  7 {
 8  8  //静态分配数组
 9  9  int a[5] = {2,3,5,6,9};
10 10  //len为一维数组的长度，可以根据需求动态分配长度
11 11  int len;
12 12  printf("请输入你需要分配的数组长度：len=");
13 13  scanf("%d",&len);//len=5
14 14  //malloc为分配内存的函数，返回第一个字节的地址，但是默认返回是一个干地址，没有实际意义，必须加强制类型转换为指定的指针类型才有意义，（int *）表示强转为int类型的指针，那么返回的地址指向的就是第一个元素的地址，那么第二个元素的地址就是第一个地址向后挪一位
15 15  int * pArr = (int *)malloc(sizeof(int) * len);
16 16  *pArr = 2;//类似于 a[0]=4,因为数组名就是指向了第一个元素的地址，跟*pArr一样
17 17  pArr[1] = 3; //类似于 a[1]=3
18 18  
19 19  free(pArr);//把pArr所代表的动态分配的20个字节的内存释放
20 20  
21 21  return 0;
22 22 }

  1. 跨函数使用内存

     1 # include <stdio.h>
 2 # include <malloc.h>
 3 ​
 4 struct Student
 5 {
 6  int sid;
 7  int age;
 8 }；
 9 ​
10 struct Student * CreateStudent(void);
11 void ShowStudent(struct Student *);
12 ​
13 int main(void)
14 {
15     struct Student * ps;
16     ps = CreateStudent();
17  ShowStudent(ps);
18  return 0;
19 }
20 ​
21 void ShowStudent(struct Student * pst)
22 {
23  printf("%d %d",pst->sid,pst->age);
24 }
25 ​
26 struct Student * CreateStudent(void)
27 {
28     struct Student * p = (struct Student *)malloc(sizeof(struct Student))；
29  p->sid = 1001;
30  p->age = 18;
31  return p;
32 }

     

  2. typedef函数的使用

     1 typedef int INT; // 相当于给int起了一个别名 INT
 2 typedef struct Student
 3 {
 4  int sid;
 5  char name[100];
 6  char sex;
 7 } ST; //ST st 就相当于 struct Student st,给struct Student 起了别名ST，这样简洁了代码
 8 typedef struct Student
 9 {
10  int sid;
11  char name[100];
12  char sex;
13 } * ST; //ST就相当于struct Student *  

线性结构

把所有节点用一条直线串起来

  • 连续存储【数组】

    1. 什么叫数组：元素类型相同，大小相等

    2. 数组的优缺点

      • 优点：存取速度很快

      • 缺点：插入删除元素很慢

      数组例子

        1 # include <stdio.h>
  2 # include <malloc.h>
  3 # include <stdlib.h>
  4 # include <stdbool.sh>
  5 ​
  6 struct Arr
  7 {
  8     int * pBase;//数组首地址
  9     int cnt;//当前数组内已有元素长度
 10     int len;//数组长度
 11 };
 12 ​
 13 //初始化数组
 14 void init_arr(struct Arr * pArr,int length);
 15 //获取某个位置上的元素
 16 int get(int pos);
 17 //判断数组是否已经满了
 18 bool is_full(struct Arr * pArr);
 19 //判断数组是否为空
 20 bool is_empty(struct Arr * pArr);
 21 //打印数组内所有元素
 22 void show_arr(struct Arr * pArr);
 23 //向数组中追加元素
 24 void append_arr(struct Arr * pArr,int val);
 25 //向数组某个位置插入元素
 26 void insert_arr(struct Arr * pArr,int pos,int val);
 27 //排序
 28 void sort_arr (struct Arr * pArr);
 29 ​
 30 int main(void)
 31 {
 32     struct Arr arr;
 33     init_arr(&arr,6);
 34     
 35     
 36     return 0;
 37 }
 38 ​
 39 void init_arr(struct Arr * pArr,int length)
 40 {
 41     pArr->pBase = (int *)malloc(sizeof(struct Arr) * length);
 42     if ( NULL == pArr->pBase)
 43     {
 44         printf("动态内存分配失败\n");
 45         exit(-1);
 46     }
 47     else 
 48     {
 49         pArr->len = length;
 50         pArr->cnt = 0;
 51     }
 52     return;
 53 }
 54 ​
 55 bool is_empty(struct Arr *pArr)
 56 {
 57     return 0 == pArr->cnt ? true:false;
 58 }
 59 ​
 60 bool is_full(struct Arr * pArr)
 61 {
 62     return pArr->cnt == pArr->len ? true:false;
 63 }
 64 ​
 65 void show_arr(struct Arr * pArr)
 66 {
 67     int i;
 68     if ( is_empty(pArr) )
 69     {
 70         printf("数组为空");
 71     }
 72     else 
 73     {
 74         for (i = 0;i<pArr->cnt;i++)
 75         {
 76             printf("%d ",pArr->pBase[i]);
 77         }
 78         printf("\n");
 79     }
 80     return;
 81 }
 82 ​
 83 void append_arr(struct Arr * pArr,int val)
 84 {
 85     if( is_full(pArr) )
 86     {
 87         printf("数组已满，不能再追加！\n");
 88     }
 89     else 
 90     {
 91         pArr->pBase[pArr->cnt]=val;
 92         ++ pArr->cnt;
 93     }
 94     return;
 95 }
 96 ​
 97 void insert_arr(struct Arr * pArr,int pos,int val)
 98 {
 99     if ( is_full(pArr) )
100     {
101         printf("数组已满，无法插入！\n");
102         return;
103     }
104     if ( pos < 1 || pos > pArr->cnt)
105     {
106         printf("指定位置有误，无法插入！\n");
107         return;
108     }
109     
110     for (int i=pArr->cnt; i<pos-1; --i)
111     {
112         pArr->pBase[i+1]=pArr->pBase[i];
113     }
114     pArr->pBase[pos-1]=val;
115     pArr->cnt ++;
116     return;
117 }
118 ​
119 void inversion_arr (struct Arr * pArr)
120 {
121 int i;
122 int j = pArr-> cnt -1;
123 int t;
124 
125 while (i < j) 
126     {
127 t = pArr->pBase[i];
128 pArr->pBase[i] = pArr->pBase[j];
129 pArr->pBase[j] = t;
130 ++i;
131 --j;
132     }
133 return;
134 }
135 ​
136 void sort_arr (struct Arr * pArr)
137 {
138 int i,j,t;
139 ​
140 for (i=0; i<pArr->cnt-1; ++i)
141     {
142 for (j=i+1; j<pArr->cnt; ++j)
143     {
144 if (pArr->pBase[i]>pArr->pBase[j])
145     {
146 t = pArr->pBase[j];
147 pArr->pBase[j]=pArr->pBase[i];
148 pArr->pBase[i]=t;
149     }
150     }
151     }
152 return;
153 }

  • 离散结构【链表】

    • 定义：n个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点同时每个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。

      专业术语

      • 首节点：存放第一个有效数据的节点

      • 尾节点：存放最后一个有效数据的节点

      • 头结点：位于首节点之前的一个节点，头结点并不存放有效的数据，加头结点的目的主要是为了方便对链表的操作

      • 头指针：指向头结点的指针变量

      • 尾指针：指向尾节点的指针变量

    • 确定一个链表需要几个参数：只需要一个头指针参数，因为我们通过头指针可以推算出链表的其他所有信息

      例子

       1 # include <stdio.h>
 2 ​
 3 typedef struct Node
 4 {
 5  int data;//数据域
 6  struct Node * PNext;//指针域
 7 } NODE, *PNODE;//NODE等价于struct Node，PNODE等价于struct Node *
 8 ​
 9 int main(void)
10 {   
11  return 0;
12 }

    • 分类

      • 单链表：每一个节点只有一个指针域

      • 双链表：每一个节点有两个指针域

      • 循环链表：能通过任何一个节点找到其他所有的节点

      • 非循环链表：不能通过任何一个节点找到其他所有的节点

        循环链表属于双链表的一种特殊形式，即循环链表是双链表的一个子集。

    • 优缺点

      • 优点：空间没有限制，插入和删除元素很快

      • 缺点：存取速度很慢

    • 算法

      算法：

      • 侠义的算法是与数据的存储方式密切相关

      • 广义的算法是与数据的存储方式无关

      泛型：利用某种技术达到的效果就是：不同的存储方式，执行的操作是一样的

      • 遍历

      • 查找

      • 清空

      • 销毁

      • 求长度

      • 排序

      • 删除节点

      • 插入节点

      代码实现

        1 # include <stdio.h>
  2 # include <malloc.h>
  3 # include <stdbool.h>
  4 ​
  5 typedef struct Node
  6 {
  7 int data;//数据域
  8 struct Node * pNext;//指针域
  9 }NODE,*PNODE；//NODE相当于struct Node，*PNODE相当于struct Node *
 10 ​
 11 //创建链表
 12 PNODE create_list(void);
 13 //遍历链表
 14 void traverse_list(PNODE pHead);
 15 //判断是否为空
 16 bool is_empty(PNODE pHead);
 17 //返回链表长度
 18 int length_list(PNODE pHead);
 19 //在指定节点处插入某个元素
 20 bool insert_list(PNODE,int,int);
 21 //删除指定位置的元素
 22 bool delete_list(PNODE,int,int *);
 23 //对链表排序
 24 void sort_list(PNODE pHead);
 25 ​
 26 int main(void)
 27 {
 28 PNODE pHead = NULL;//定义头结点指针
 29 pHead = create_list();
 30 return 0;
 31 }
 32 ​
 33 PNODE create_list(void)
 34 {
 35 int len;//链表成员个数，由用户输入
 36 int i;
 37 int val;//链表成员值，由用户输入
 38 ​
 39 PNODE pHead = (PNODE)malloc(sizeof(NODE));//定义头结点指针
 40 if (NULL == pHead)
 41 {
 42   printf("分配内存失败，程序结束");
 43   exit(-1);
 44 }
 45 ​
 46 printf("请输入链表长度,len=");
 47 scanf("%d",&len);
 48 ​
 49 PNODE pTail = pHead;
 50 pTail->pNext = NULL;
 51 ​
 52 for(i=0; i < len; i++)
 53 {
 54   PNODE pNew = (PNODE)malloc(sizeof(NODE));
 55   if (NULL == pNew)
 56      {
 57     printf("分配内存失败，程序结束");
 58     exit(-1);
 59      }
 60   printf("请输入要插入链表的值,val=");
 61      scanf("%d",&val);
 62   
 63   pNew->data = val;
 64   pTail->pNext = pNew;
 65   pNew->pNext = NULL;
 66   pTail = pNew;
 67 }
 68 return pHead;
 69 }
 70 ​
 71 void traverse_list(PNODE pHead)
 72 {
 73  PNODE p = pHead->pNext;
 74  if (NULL != p)
 75  {
 76      printf("%d\t",p->data);
 77      p = p->pNext;
 78  }
 79  printf("\n");
 80  return;
 81 }
 82 ​
 83 bool is_empty(PNODE pHead)
 84 {
 85  if (NULL == pHead->pNext)
 86     return true;
 87  else
 88      return false;
 89 }
 90 ​
 91 int length_list(PNODE pHead)
 92 {
 93  int len = 0;
 94  PNODE p = pHead->pNext;
 95  while(NULL != p)
 96  {
 97      ++len;
 98      p = p->pNext;
 99  }
100  return len;
101 }
102 ​
103 bool insert_list(PNODE pHead,int pos,int val)
104 {
105  int i;
106  PNODE p = pHead;
107  //循环到p指向pos-1的位置
108  while( NULL != p && i<pos-1)
109  {
110      p = p->pNext;
111      ++i;
112  }
113  if (NULL == p || i > pos -1)
114  {
115      return false;
116  }
117  //插入的数申请内存
118  PNODE pNew = (PNODE)malloc(sizeof(NODE));
119  if (NULL == pNew)
120     {
121         printf("分配内存失败，程序终止！\n");
122         exit(-1);
123     }
124  pNew->data = val;
125  PNODE q = p->pNext;
126  p->pNext = pNew;
127  pNew->pNext = q;
128  return ture;
129 } 
130 ​
131 bool delete_list(PNODE pHead,int pos,int *pVal)
132 {
133  int i;
134  PNODE p = pHead;
135  //循环到p指向pos-1的位置
136  while( NULL != p->pNext && i<pos-1)
137  {
138      p = p->pNext;
139      ++i;
140  }
141 if (NULL == p->pNext || i > pos -1)
142  {
143      return false;
144  }
145 PNODE q = p->pNext;
146 *pVal = p->data;
147 p->pNext=q->pNext;
148 free(q);
149 q=NULL;
150 return true;
151 }
152 ​
153 void sort_list(PNODE pHead)
154 {
155 int i,j,t;
156 PNODE p,q;
157 int len = length_list(pHead);
158 for(i=0,p=pHead->pNext;i<len-1;i++,p=p->pNext)
159  {
160      for(j=i+1,q=p->pNext;j<len;j++,q=q->pNext)
161      {
162          if(p->data > q->data)
163          {
164              t = p->data;
165              p->data = q->data;
166              q->data = t; 
167          }
168      }
169  }
170 return;
171 } 

       

  • 线性结构的两种常见应用之一：栈

    • 定义：一种可以实现“先进后出”的存储结构

    • 分类：静态栈；动态栈。

    • 算法：压栈；出栈

    • 应用：函数调用；中断；表达式求值；内存分配；缓冲处理；迷宫

    示例代码

      1 # include <stdio.h>
  2 # include <malloc.h>
  3 # include <stdlib.h>
  4 ​
  5 typedef struct Node
  6 {
  7     int data;
  8     struct Node * pNext;
  9 }NODE,* PNODE;
 10 ​
 11 typedef struct Stack
 12 {
 13     PNODE pTop;
 14     PNODE pBottom;
 15 }STACK,* PSTACK;
 16 ​
 17 //初始化
 18 void init_stack(PSTACK);
 19 //压栈
 20 void push_stack(PSTACK,int);
 21 //出栈
 22 int pop_stack(PSTACK);
 23 //遍历栈
 24 void traverse_stack(PSTACK);
 25 //判断栈是否为空
 26 bool is_empty(PSTACK);
 27 //清空栈
 28 void clear(PSTACK);
 29 ​
 30 int main(void)
 31 {
 32     int val;//出栈的值
 33     STACK s;
 34     init_stack(&s);//目的是造出一个空栈
 35     push_stack(&s,1);//压栈
 36     push_stack(&s,2);
 37     push_stack(&s,3);
 38     push_stack(&s,4);
 39     push_stack(&s,5);
 40     traverse_stack(&s);
 41     pop_stack(&s,&val);
 42     return 0;
 43 }
 44 ​
 45 void init_stack(PSTACK pS)
 46 {
 47     pS->pTop=(PNODE)malloc(sizeof(NODE));
 48     if (NULL == pS->pTop)
 49     {
 50         printf("分配内存失败，程序终止！\n");
 51         exit(-1);
 52     }
 53     else 
 54     {
 55         pS->pBottom = pS->pTop;
 56         pS->pTop->pNext = NULL;
 57     }
 58     return;
 59 }
 60 ​
 61 void push_stack(PSTACK pS,int val)
 62 {
 63     PNODE pNew = (PNODE)malloc(sizeof(NODE));
 64     if (NULL == pNew)
 65     {
 66         printf("分配内存失败，程序终止！\n");
 67         exit(-1);
 68     }
 69     pNew->data = val;
 70     pNew->pNext = pS->pTop;
 71     pS->pTop = pNew;
 72     
 73     return;
 74 }
 75 ​
 76 void traverse_stack(PSTACK pS)
 77 {
 78     
 79     PNODE p = pS->pTop;
 80     while (p != ps->pBottom) 
 81     {
 82         printf("%d\t",p->data);
 83         p = p->pNext;
 84     }
 85     printf("\n");
 86     return;
 87 }
 88 ​
 89 bool is_empty(PSTACK pS)
 90 {
 91     if (pS->pTop == pS->pBottom)
 92         return true;
 93     else 
 94         return false;
 95 }
 96 ​
 97 bool pop_stack(PSTACK pS,*pVal)
 98 {
 99     if (is_empty(pS)){
100         return false;
101     }
102     else 
103     {
104         PNODE p = pS->pTop;
105         *pVal = p->data;
106         pS->pTop = p->pNext;
107         free(p);
108         p = NULL;
109         return true;
110     }
111 }
112 ​
113 void clear(PSTACK pS)
114 {
115     if(is_empty(pS))
116         return;
117     else 
118     {
119         PNODE p = pS->pTop;
120         PNODE q = NULL;
121         if(p != pS->pBottom)
122         {
123 q = p->pNext;
124 free(p);
125 p = q;
126     }
127 pS->pTop = pS->pBottom;
128     }
129 /*此种方法待验证
130 while (!is_empty(pS)) 
131 {
132 PNODE p = pS->pTop;
133 pS->pTop = p->pNext;
134 free(p);
135 p=NULL;
136 }
137 */
138 return;
139 }

     

  • 线性结构的两种常见应用之二：队列

    • 定义：一种可以实现“先进先出”的存储结构

    • 分类

      • 链式队列——用链表实现

      • 静态队列——用数组实现

        1. 静态队列通常都必须是循环队列

        2. 循环队列的讲解

          • 静态队列为什么必须是循环队列

          • 循环队列需要几个参数来确定

            需要两个参数来确定队列，front|rear；

          • 循环队列各个参数的含义

            1. 队列初始化：front和rear的值都是0

            2. 队列非空：front代表的是队列的第一个元素，rear代表的是队列的最后一个有效元素的下一个位置

            3. 队列空：front和rear的值相等，但不一定是0

          • 循环队列入队伪算法

            1. 将值存入rear所代表的位置

            2. rear = （rear + 1） % 数组的长度

          • 循环队列出队伪算法

            1. front = (front + 1) % 数组的长度

          • 如何判断循环队列是否为空

            if (front == rear)

          • 如何判断循环队列是否已满

            两种方式：

            1. if ((rear + 1 % 数组的长度) == front)

            2. 元素个数=数组长度-1

        3. 队列的具体应用：所有和时间有关的操作都与队列有关

          样例代码

            1 # include <stdio.h>
  2 # include <malloc.h>
  3 # include <stdboo.h>
  4 ​
  5 typedef struct Queue
  6 {
  7 int * pBase;//循环数组的首地址
  8 int front;//队头
  9 int rear;//队尾
 10 }QUEUE;
 11 ​
 12 //初始化队列
 13 void init(QUEUE *);
 14 //判断队列是否为空
 15 bool is_empty(QUEUE *);
 16 //队列是否已满
 17 bool is_full(QUEUE *);
 18 //插入队列 入队
 19 bool en_queue(QUEUE *,int val);
 20 //遍历队列
 21 void traverse_queue(QUEUE *);
 22 //出队
 23 bool out_queue(QUEUE *,int *);
 24 ​
 25 int main(void)
 26 {
 27  int val;//出队的元素
 28  QUEUE Q;
 29  init(&Q);
 30  en_queue(&Q,1);
 31  en_queue(&Q,2);
 32  en_queue(&Q,3);
 33  en_queue(&Q,4);
 34  en_queue(&Q,5);
 35  en_queue(&Q,6);
 36  traverse_queue(&Q);
 37  if(out_queue(&Q,&val))
 38  {
 39      printf("The elem out queue is %d .",val);
 40  }
 41  return 0;
 42 }
 43 ​
 44 void init(QUEUE * pQ)
 45 {
 46  pQ->pBase = (int *)malloc(sizeof(int) * 6);
 47  pQ->front = 0;
 48  pQ->rear = 0;
 49 }
 50 ​
 51 bool is_empty(QUEUE * pQ)
 52 {
 53  return pQ->front == pQ->rear? true:false;
 54 }
 55 ​
 56 bool is_full(QUEUE * pQ)
 57 {
 58  return pQ->front == (pQ->rear + 1) % 6 ? true:false;
 59 }
 60 ​
 61 //入队
 62 bool en_queue(QUEUE * pQ,int val)
 63 {
 64  if(is_full(pQ))
 65     return false;
 66  else
 67  {
 68      pQ->pBase[pQ->rear] = val;
 69      pQ->rear = (pQ->rear + 1) % 6;
 70      return true;
 71  }
 72  
 73 }
 74 ​
 75 //遍历队列
 76 void traverse_queue(QUEUE * pQ)
 77 {
 78     if(is_empty(pQ))
 79  {
 80      printf("The queue is empty!");
 81      return;
 82  }
 83  else
 84  {
 85      int val;
 86      while(pQ->front != pQ->rear)
 87      {
 88          printf("%d ",pQ->pBase[pQ->front]);
 89          pQ->front = (pQ->front + 1) % 6;
 90      }
 91      printf("\n");
 92      return;
 93  }
 94 }    
 95 ​
 96 //出队
 97 bool out_queue(QUEUE * pQ,int *pVal)
 98 {
 99  if(is_empty(pQ))
100  {
101      printf("The queue is empty.");
102      return false;
103  }
104  else
105  {
106      *pVal = pQ->pBase[pQ->front];
107      pQ->front = (pQ->front + 1) % 6;
108      return true;
109  }
110 } 

主题：递归

定义：一个函数自己直接或间接调用自己

递归满足三个条件

  1. 递归必须得有一个明确的中止条件

  2. 该函数所处理的数据规模必须在递减

  3. 这个转化必须是可解的

循环和递归

  • 递归

    • 易于理解

    • 速度慢

    • 存储空间大

  • 循环

    • 不易理解

    • 速度快

    • 存储空间小

函数的调用：

  • 当在一个函数的运行期间调用另一个函数时，在运行被调函数之前，系统需要完成三件事：

    1. 将所有的实际参数、返回地址等信息传递给被调函数保存。

    2. 为被调函数的局部变量（也包括行参）分配存储空间。

    3. 将控制转移到被调函数的入口。

  • 从被调函数返回函数之前，系统也要完成三件事：

    1. 保存被调函数的返回结果。

    2. 释放被调函数所占的存储空间。

    3. 依照被调函数保存的返回地址将控制转移到调用函数。

  • 当有多个函数相互调用时，按照”后调用先返回“的原则，上述函数之间信息传递和控制转移必须借助”栈“来实现，即系统将整个程序运行时所需的数据空间安排在一个栈中，每当调用一个函数时，就在栈顶分配一个存储区，进行压栈操作，每当一个函数退出时，就释放它的存储区，就做出栈操作，当前运行的函数永远都在栈顶位置。

  • A函数调用A函数和A函数调用B函数在计算机看来是没有任何区别的，只不过用我们日常的思维方式理解比较怪异而已！

  1. 1+2+3+...+100的和


    代码实现
     1 # include <stdio.h>
 2 ​
 3 int sum(int);
 4 ​
 5 int main(void)
 6 {
 7     int n = 100;
 8     printf("%d\n",sum(n));
 9  return 0;
10 }
11 ​
12 int sum(int n)
13 {
14  if(1 == n)
15      return 1;
16  else
17      return n + sum(n-1);
18 } 

  2. 求阶乘

    代码实现
     1 # include <stdio.h>
 2 ​
 3 long multi(int);
 4 ​
 5 int main(void)
 6 {
 7     printf("%ld\n",multi(6));
 8  return 0;
 9 } 
10 ​
11 long multi(int n)
12 {
13  if (1 == n)
14     return 1;
15  else
16     return n * multi(n - 1);
17 }

     

  3. 汉诺塔

    伪代码：

    如果只有一个盘子：

    直接将盘子从A柱子移到C柱子

    否则：

    先将A柱子上的n-1个盘子借助C柱子移到B柱子

    再直接将盘子从A柱子移到C柱子

    最后再将B柱子上的盘子借助A柱子移到C柱子上

    代码实现样例：

     1 # include <stdio.h>
 2 ​
 3 void hanoi(int,char,char,char);
 4 ​
 5 int main(void)
 6 {
 7     //柱子编号
 8     char ch1 = 'A';
 9     char ch2 = 'B';
10     char ch3 = 'C';
11     //盘子数量
12     int n;
13     printf("请输入盘子的数量");
14     scanf("%d",&n);
15     hanoi(n,'A','B','C');
16     
17     return 0;
18 }
19 ​
20 void hanoi(int n,char 'A',char 'B',char 'C')
21 {
22     if (1 == n)
23         printf("编号为%d的盘子：%c-->%c\n",n,'A',"C");
24     else
25     {
26         hanoi(n-1,A,C,B);
27         printf("编号为%d的盘子：%c-->%c\n",n,'A',"C");
28         hanoi(n-1,B,A,C);
29     }
30 } 

  4. 走迷宫

    A*(A-Star)算法实现

递归的应用

  • 树和森林就是以递归的方式定义的

  • 树和图的很多算法

  • 很多数学公式：例如斐波拉契数列

非线性结构

树

树的定义

  • 专业定义：

    1. 有且只有一个称为根的节点

    2. 有若干个互不相交的子树，这些子树本身也是一颗树

  • 通俗定义：

    1. 树是由节点和边组成

    2. 每个节点只有一个父节点但可以有多个子节点

    3. 但有一个节点例外，该节点没有父节点，此节点称为根节点

  • 专业术语：

    • 节点，父节点，子节点

    • 子孙，堂兄弟

    • 深度：从根节点到最底层节点的层数称之为深度，根节点是第一层

    • 叶子节点：没有子节点的节点

    • 非终端节点：实际就是非叶子节点

    • 度：子节点的个数

树的分类

  • 一般树：任意一个节点的子节点的个数都不受限制

  • 二叉树：任意一个节点的子节点个数最多两个，且子节点的位置不可更改

    • 分类

      • 一般二叉树

      • 满二叉树：在不增加树层数的前提下，无法再多添加一个节点的二叉树就是满二叉树

      • 完全二叉树：如果只是删除了满二叉树最底层最右边的连续若干个节点，这样形成的二叉树就是完全二叉树。（满二叉树是完全二叉树的一个特例）

  • 森林：n个互不相交的树的集合

树的存储

  • 二叉树的存储

    • 连续存储【完全二叉树】

      优点：查找某个节点的父节点和子节点（也包括判断有没有子节点）

      缺点：耗用内存空间过大

    • 链式存储

  • 一般树的存储

    • 双亲表示法：求父节点方便

    • 孩子表示法：求子节点方便

    • 双亲孩子表示法：求父节点和子节点都很方便

    • 二叉树表示法：把一个普通树转化成二叉树来存储

      具体转换方法：

      设法保证任意一个节点的左指针域指向它的第一个孩子，右指针域指向它的兄弟，只要满足此条件，就可以把一个普通树转化为二叉树。

      一个普通树转化成的二叉树一定没有右子树

  • 森林的存储

    先把森林转化为二叉树，再存储二叉树：

    将相邻的父节点依次作为节点的右子树再对各父节点进行转化

树的操作

  • 遍历

    • 先序遍历【先访问根节点】

      1. 先访问根节点

      2. 再先序访问左子树

      3. 最后先序访问右子树

        例子：

                A
               / \
              B   C
             / \   \
            D   E    F
           / \   \  / \
          G   H   I J  k

        先序遍历结果：ABDGHEICFJK

    • 中序遍历【中间访问根节点】

      1. 中序遍历左子树

      2. 再访问根节点

      3. 再中序遍历右子树

        例子：

                A
               / \
              B   C
             / \   \
            D   E    F
           / \   \  / \
          G   H   I J  k

        中序遍历结果：GDHBEIACJFK

    • 后续遍历【最后访问根节点】

      1. 先中序遍历左子树

      2. 再中序遍历右子树

      3. 最后遍历根节点

        例子：

                A
               / \
              B   C
             / \   \
            D   E    F
           / \   \  / \
          G   H   I J  k

        后序遍历结果：GHDIEBJKFCA

  • 已知两种遍历序列求原始二叉树

    通过先序和中序或者中序和后序我们可以还原出原始二叉树，但是通过先序和后序是无法还原出原始二叉树；

    换句话，只有通过先序和中序或者中序和后序，我们才可以唯一的确定一个二叉树。

    例子1：

    先序：ABCDEFGH
    中序：BDCEAFHG
    求后序？
    分析：按照先序的定义，A为最外层根节点，按照中序的定义和前面的结论可知BDCE为A节点的左子树节点，FHG为A节点的右子树，再依次按照两个遍历定义可以推出原始二叉树为：
            A
           / \
          B   F
            \  \
             C  G
            / \ /
           D  E H
    那么此二叉树的后序为：DECBHGFA

    例子2：

    先序：ABDGHCEFI
    中序：GDHBAECIF
    求后序？
    分析：按照先序的定义得到A为最外层根节点，再根据中序结果可知GDHB为A的左子树，ECIF为A的右子树；B先出现在先序结果中可知B为左子树的根节点，再根据中序结果知B节点没有右子树，GDH均为B节点的左子树，再根据先序结果D先出现，知D为B左子树的根节点，再根据先序发现G在D的后面且中序中G在D的前面得出G为D左子树的根节点，那么D的右子树的根节点就是H了，依次类推A的右子树，得出原始二叉树为：
          A
         / \
        B   C
       /   / \
      D   E   F
     / \     /
    G   H   I
    那么此二叉树的后序为：GHDBEIFCA

    例子3：

    中序：BDCEAFHG
    后序：DECBHGFA
    求先序？
    分析：由后序结果知A为最外层根节点，再根据中序结果知BDCE为A节点的左子树，FHG为A的右子树；A的左子树中B最靠近A那么根据后序规则得出B为左子树的根节点，再根据中序结果B在结果的第一位，由中序规则知B没有左子树，DCE均为B的右子树，在DCE中后序结果C最靠近B，得出C为B的右子树的根节点，再依据中序结果知C前面是D后面是E得出D为C的左子树，E为C的右子树，同理可以推出A的右子树，得出原始二叉树为：
            A
           / \
          B   F
           \   \
            C   G
           / \  /
          D   E H
    那么此二叉树的先序为：ABCDEFGH

  • 二叉树的代码实现举例

      1 # include <stdio.h>
  2 # include <malloc.h>
  3 ​
  4 typedef struct BinaryTree
  5 {
  6     char data;//节点值 数据域
  7     struct BinaryTree * pLchild;//左子树 左指针域
  8     struct BinaryTree * pRchild;//右子树 右指针域
  9 }BINARYTREE,* PBINARYTREE;
 10 ​
 11 //创建一个静态二叉树
 12 PBINARYTREE create_binary_tree(void);
 13 //先序遍历
 14 void pre_traversal(PBINARYTREE);
 15 //中序遍历
 16 void in_traversal(PBINARYTREE);
 17 //后序遍历
 18 void post_traversal(PBINARYTREE);
 19 ​
 20 int main(void)
 21 {
 22     PBINARYTREE pT = NULL;
 23     pT = create_binary_tree();
 24     printf("先序遍历结果为：");
 25     pre_traversal(pT);
 26     printf("\n中序遍历结果为：");
 27     in_traversal(pT);
 28     printf("\n后序遍历结果为：");
 29     post_traversal(pT);
 30     return 0;
 31 }
 32 ​
 33 /**创建以下结果的二叉树,此二叉树结构是上面二叉树遍历的例子，可对比结果是否正确
 34         A
 35        / \
 36       B   C
 37      / \   \
 38     D   E    F
 39    / \   \  / \
 40   G   H   I J  k
 41 */
 42 PBINARYTREE create_binary_tree(void)
 43 {
 44     //为每个二叉树节点申请内存空间
 45     PBINARYTREE pA = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 46     PBINARYTREE pB = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 47     PBINARYTREE pC = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 48     PBINARYTREE pD = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 49     PBINARYTREE pE = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 50     PBINARYTREE pF = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 51     PBINARYTREE pG = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 52     PBINARYTREE pH = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 53     PBINARYTREE pI = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 54     PBINARYTREE pJ = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 55     PBINARYTREE pK = (PBINARYTREE)malloc(sizeof(BINARYTREE));
 56     //给每个二叉树节点的数据域赋值
 57     pA->data = 'A';
 58     pB->data = 'B';
 59     pC->data = 'C';
 60     pD->data = 'D';
 61     pE->data = 'E';
 62     pF->data = 'F';
 63     pG->data = 'G';
 64     pH->data = 'H';
 65     pI->data = 'I';
 66     pJ->data = 'J';
 67     pK->data = 'K';
 68     //给每个二叉树节点的左右指针域赋值
 69     pA->pLchild = pB; 
 70     pA->pRchild = pC; 
 71     pB->pLchild = pD; 
 72     pB->pRchild = pE;
 73     pC->pLchild = NULL; 
 74     pC->pRchild = pF;
 75     pD->pLchild = pG; 
 76     pD->pRchild = pH;
 77     pE->pLchild = NULL; 
 78     pE->pRchild = pI;
 79     pF->pLchild = pJ; 
 80     pF->pRchild = pK;
 81     pG->pLchild = pG->pRchild = NULL;
 82     pH->pLchild = pH->pRchild = NULL;
 83     pI->pLchild = pI->pRchild = NULL;
 84     pJ->pLchild = pJ->pRchild = NULL;
 85     pK->pLchild = pK->pRchild = NULL;
 86     
 87     return pA;
 88 }
 89 ​
 90 void pre_traversal(PBINARYTREE pT)
 91 {
 92     if(NULL != pT)
 93     {
 94         printf("%c\t",pT->data);
 95         if(NULL != pT->pLchild)
 96             pre_traversal(pT->pLchild);
 97 if(NULL != pT->pRchild)
 98 pre_traversal(pT->pRchild);
 99     }
100 return;
101 }
102 ​
103 void in_traversal(PBINARYTREE pT)
104 {
105 if(NULL != pT)
106     {
107 if(NULL != pT->pLchild)
108 in_traversal(pT->pLchild);
109 printf("%c\t",pT->data);
110 if(NULL != pT->pRchild)
111 in_traversal(pT->pRchild);
112     }
113 return;
114 }
115 ​
116 void post_traversal(PBINARYTREE pT)
117 {
118 if(NULL != pT)
119     {
120 if(NULL != pT->pLchild)
121 post_traversal(pT->pLchild);
122 if(NULL != pT->pRchild)
123 post_traversal(pT->pRchild);
124 printf("%c\t",pT->data);
125     }
126 return;
127 }

     

     

树的应用

  • 树是数据库中数据组织的一种重要形式

  • 操作系统子父进程的关系本身就是一个树

  • 面向对象语言中类的继承关系

  • 赫夫曼树

图

视频中没有具体讲解

查找和排序

查找：折半查找
排序

关于排序算法，推荐去中文维基百科上面查看，有动态排序过程，有助于理解算法本质！

排序算法

  1. 冒泡排序

     1 //简单冒泡排序举例【升序】
 2 ​
 3 # include <stdio.h>
 4 ​
 5 void bubble_sort(int *,int);
 6 ​
 7 int main(void)
 8 {
 9     int i;
10     int len = 6;
11     int arr[len] = {2,10,8,5,3,1};
12     
13     bubble_sort(arr,len);
14     for(i = 0;i < 6;i++)
15         printf("%d ",arr[i]);
16     printf("\n");
17     return 0;
18 }
19 ​
20 void bubble_sort(int * arr,int len)
21 {
22     int i,j,t;
23     for(i = 0; i < len; i++)
24     {
25         for(j = i+1; j < len-1; j++)
26         {
27             if(arr[i] > arr[j])
28             {
29                 t = arr[i];
30                 arr[i] = arr[j];
31                 arr[j] = t;
32             }
33         }
34     }
35 }

     

  2. 插入排序

     1 //直接插入排序【升序】
 2 ​
 3 # include <stdio.h>
 4 ​
 5 void insertion_sort(int *,int);
 6 ​
 7 int main(void)
 8 {
 9     int i;
10     int len = 6;//数组长度
11     int arr[len] = {2,10,8,5,3,1};
12     insertion_sort(arr,len);
13     for(i = 0;i < 6;i++)
14         printf("%d ",arr[i]);
15     printf("\n");
16 }
17 ​
18 void insertion_sort(int * arr,int len)
19 {
20     int i,j,t;
21     for (i=1; i<len; i++)
22     {
23         if(arr[i]<arr[i-1])
24         {
25             t = arr[i];
26             j = i - 1;
27             for(j; j>=0 && arr[j]>t;j--)
28             {
29                 arr[j+1] = arr[j];
30             }
31             a[j+1] = t;
32         }
33     }
34 }

     

  3. 选择排序

     1 //直接选择排序【升序】
 2 ​
 3 # include <stdio.h>
 4 ​
 5 void selection_sort(int *,int);
 6 ​
 7 int main(void)
 8 {
 9     int i;
10     int len = 6;//数组长度
11     int arr[6] = {2,10,8,5,3,1};
12     selection_sort(arr,len);
13     for(i = 0;i < 6;i++)
14         printf("%d ",arr[i]);
15     printf("\n");
16     return 0;
17 }
18 ​
19 void selection_sort(int * arr,int len)
20 {
21     int i,j,t,min;
22     for(i=0; i<len-1; i++)
23     {
24         for(min=i,j=i+1; j<len; j++)
25         {
26             if(arr[min] < arr[j])
27                 min = j;         
28         }
29         if(min != j)
30         {
31             t = arr[i];
32             arr[i] = arr[min];
33             arr[min] = t;
34          }
35     }
36 }

     

     

  4. 快速排序

     1 # include <stdio.h>
 2 ​
 3 void quick_sort(int *,int,int);
 4 int find_pos(int *,int,int);
 5 ​
 6 int main(void)
 7 {
 8     int i,len,low,high;
 9     low = 0;
10     high = 6;
11     int arr[7] = {13,2,1,3,8,5,1};
12     quick_sort(arr,low,high);//low表示起始位置，high表示结束位置
13     for(i = 0;i < 7;i++)
14         printf("%d ",arr[i]);
15     printf("\n");
16     return 0;
17 }
18 ​
19 void quick_sort(int * arr,int low,int high)
20 {
21     int pos;
22     if (low < high)
23     {
24         pos = find_pos(arr,low,high);
25         quick_sort(arr,low,pos-1);
26         quick_sort(arr,pos+1,high);
27     }
28 }
29 ​
30 int find_pos(int * arr,int low,int high)
31 {
32     int val = arr[low];
33     while(low < high)
34     {
35         while(low < high && arr[high] >= val)
36             --high;
37         arr[low] = arr[high];
38         while(low < high && arr[low] <= val)
39             ++low;
40         arr[high] = arr[low];
41     }
42     arr[low] = val;
43     return high;
44 }

     

     

  5. 归并排序

    摘自中文维基百科-归并排序

     1 # include <stdio.h>
 2 ​
 3 void merge_sort(int arr[], const int len);
 4 void merge_sort_recursive(int arr[], int reg[], int start, int end);
 5 ​
 6 int main(void)
 7 {
 8     int i;
 9     int arr[7] = {13,2,1,3,8,5,1};
10     merge_sort(arr,7);
11     for(i = 0;i < 7;i++)
12         printf("%d ",arr[i]);
13     printf("\n");
14     return 0;
15 }
16 ​
17 void merge_sort_recursive(int arr[], int reg[], int start, int end) {
18     if (start >= end)
19         return;
20     int len = end - start, mid = (len >> 1) + start;
21     int start1 = start, end1 = mid;
22     int start2 = mid + 1, end2 = end;
23     merge_sort_recursive(arr, reg, start1, end1);
24     merge_sort_recursive(arr, reg, start2, end2);
25     int k = start;
26     while (start1 <= end1 && start2 <= end2)
27         reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
28     while (start1 <= end1)
29         reg[k++] = arr[start1++];
30     while (start2 <= end2)
31         reg[k++] = arr[start2++];
32     for (k = start; k <= end; k++)
33         arr[k] = reg[k];
34 }
35 ​
36 void merge_sort(int arr[], const int len) {
37     int reg[len];
38     merge_sort_recursive(arr, reg, 0, len - 1);
39 } 

 

posted on 2019-10-06 10:33  北田  阅读(317)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 北田
Powered by .NET 9.0 on Kubernetes