数据结构简略笔记

最新推荐文章于 2023-04-29 13:32:28 发布
最新推荐文章于 2023-04-29 13:32:28 发布
阅读量215 收藏 1
点赞数 2
分类专栏： DataStructure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42403069/article/details/102864976
版权

数据结构
概述
数据结构定义

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

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

算法 = 对存储数据的操作

算法定义

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

衡量算法的标准

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

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

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

健壮性

数据结构的地位

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

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

预备知识
指针
指针的重要性：指针是C语言的灵魂

定义：

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

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

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

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

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

如何使用结构体

//定义结构体
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；

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

动态内存的分配和释放　　　
　样例代码：

复制代码
1 1 一维数组:

# 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 # 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 }

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 *

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

连续存储【数组】
什么叫数组：元素类型相同，大小相等

数组的优缺点

优点：存取速度很快

缺点：插入删除元素很慢

数组例子

  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 }

线性结构的两种常见应用之二：队列
定义：一种可以实现“先进先出”的存储结构

分类

链式队列——用链表实现

静态队列——用数组实现

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

循环队列的讲解

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

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

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

循环队列各个参数的含义

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

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

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

循环队列入队伪算法

将值存入rear所代表的位置

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

循环队列出队伪算法

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

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

if (front == rear)

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

两种方式：

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

元素个数=数组长度-1

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

样例代码

复制代码

  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 }

主题：递归
定义：一个函数自己直接或间接调用自己

递归满足三个条件

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

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

这个转化必须是可解的

循环和递归

递归

易于理解

速度慢

存储空间大

循环

不易理解

速度快

存储空间小

函数的调用：

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

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

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

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

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

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

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

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

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

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

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 }

求阶乘

代码实现

 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 }

汉诺塔

伪代码：

如果只有一个盘子：

直接将盘子从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 }

走迷宫

A*(A-Star)算法实现

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

树和图的很多算法

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

非线性结构
树
树的定义
专业定义：

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

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

通俗定义：

树是由节点和边组成

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

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

专业术语：

节点，父节点，子节点

子孙，堂兄弟

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

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

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

度：子节点的个数

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

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

分类

一般二叉树

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

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

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

树的存储
二叉树的存储

连续存储【完全二叉树】

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

缺点：耗用内存空间过大

链式存储

一般树的存储

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

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

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

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

具体转换方法：

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

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

森林的存储

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

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

树的操作
遍历

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

先访问根节点

再先序访问左子树

最后先序访问右子树

例子：

    A
   / \
  B   C
 / \   \
D   E    F

/ \ \ /
G H I J k
先序遍历结果：ABDGHEICFJK

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

中序遍历左子树

再访问根节点

再中序遍历右子树

例子：

    A
   / \
  B   C
 / \   \
D   E    F

/ \ \ /
G H I J k
中序遍历结果：GDHBEIACJFK

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

先中序遍历左子树

再中序遍历右子树

最后遍历根节点

例子：

    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 //简单冒泡排序举例【升序】

 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 }

插入排序
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 }

选择排序

复制代码
1 //直接选择排序【升序】

 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 }

快速排序

 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 }

归并排序

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

 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 }

总结
坚持就是胜利！

数学作曲家
关注
专栏目录
数据结构笔记
lobster
09-30 668
1.线性表 线性表主要有两种表示方法一种是顺序表示，一种是链式表示。   顺序表示 链式表示 定义 一组地址连续的存储单元依次存储线性表的数据元素特征（逻辑相邻，地址相邻） 一组任意的存储单元存储线性表的数据元素（地址可以连续，也可以不连续（逻辑相邻，地址不一定相邻） 实现 通过地址来实现逻辑相邻 通过在对象中保存后继数据的存储位置实...
数据结构 顺序表笔记（Markdown格式编写发布博客）
qq_42884288的博客
09-05 214
顺序表 向线性表指定位置插入一个新元素 //向线性表指定位置插入一个新元素 bool ListInsert(SqList &L, int pos, ElemType item) { //pos为插入的（逻辑）位置,item为待插入的数据元素 int i; if (L.length == MaxSize) { //判表满 cout << "顺序表满，无法插入！" << endl; return false; } if (pos < 1 ||
数据结构序(Markdown版)
你的指尖有改变世界的力量
03-02 812
数据结构序言，为专栏内的文章提供了目录与链接，方便大家快速找到自己想看的文章。
Markdown学习笔记
最新发布
峰-ZHANG的博客
04-29 797
能够快速入门Markdown，也能够当成字典便捷的查找Markdown的语法。
python算法与数据结构简略笔记
weixin_70459895的博客
07-24 772
程序=算法+数据结构 数据结构简介 通常而言，数据结构由以下三部分组成，数据结构=逻辑结构+存储结构+增删改查， 数据结构分为线性结构和非线性结构，常见的线性结构有：数组、队列、链表、栈。非线性结构有：二维数组、多维数组、广义表、树结构、图结构。 ●线性结构和非线性结构 数据结构包括：线性结构和非线性结构。 线性结构 1）线性结构作为取常用的数据结构，特点是数据元素之间存在对一的线性关系2）线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序...
郝斌数据结构学习笔记(8)快速排序练习代码
limx的博客
01-12 127
郝斌数据结构p76简述了五种常用排序流程，以及详细讲解了快排算法原理及代码实现 重点内容： 冒泡 插入 选择排序 快速排序 归并排序 除了快排已经测试过，其他的自己再去找代码看并测试 笔记：本次笔记很简略 模块三 查找和排序 折半查找 排序 冒泡（自己找代码看懂测试） 插入 选择 快速排序（已测试） 归并排序 排序和查找的关系 排序是查找的前提 排序是重点 练习代码如下 #include<stdio.h> void Qu...
（基于Java）算法笔记——复杂数据结构(并查集)
Terio的博客
08-02 367
复杂数据结构(并查集)算法简略记录 1、并查集 并查集（union-find或disjoint set）可以动态联通两个点，并且可以快速判断两个点是否联通，求最小生成树；由一个数组、两个函数（查找一个数的根、合并路线）组成，常用来解决一些不相交集合的合并与查找问题 合并（Union）：把两个不相交的集合合并为一个集合。 查询（Find）：查询两个元素是否在同一个集合中。 ① LeetCode 684 冗余连接（并查集） 解题思路 如果两个顶点属于不同的连通分量，则说明在遍历到当前的边之前，这两个顶点之
（基于Java）算法笔记——数据结构(图)
Terio的博客
07-30 278
数据结构(图)算法简略记录 1、引言 图是树的升级版（树是相连无相无环图） 有向图 无向图 有循环 无循环 所有节点相连 所有节点不相连 图通常有两种表示方法，假设图中有n个节点，m条边 邻接矩阵： 建立一个 n x n矩阵G，如果第i个节点连向第j个节点，则G[i][j]=1，反之为0 如果图是无向的，则该邻接矩阵一定是对称矩阵，即G[i][j]=G[j][i] 邻接链表： 建立一个大小为n的数组，每个位置i储存一个数组或链表，表示第i个节点连向其他节点 邻接矩阵 比 邻接链表 空间开销
《数据结构与算法 python语言描述》学习笔记（二）————抽象数据类型和Python类
qq_42056492的博客
10-05 1496
第一部分：学习内容概要 抽象数据类型 Python的类 第二部分：学习笔记 抽象数据类型   1.抽象数据类型（Abstract Data Type，ADT），通过一套接口阐述说明这一程序部分的可用功能，但不不限制功能的实现方法。   2.抽象数据类型（ADT）的基本想法是把数据定义为抽象地集合，只为他们定义可用的合法操作，并不暴露其内部实现的具体细节，不论是其数据的表示细节还是操作的实现细...
数据结构笔记整理1
weixin_44312349的博客
03-20 367
图的操作第一次写博客，还不会使用md图的操作 第一次写博客，还不会使用md 先把所有的笔记贴上了，顺便熟悉一下md的使用。慢慢整理，笔记太多太杂了。 图的操作 大学学习严蔚敏的数据结构，一下是图的一些常见操作 /*创建无向网UDN*/ int CreateUDN(MGraph * G){ int w = 0; char v1,v2; int IncInfo = 0; scanf("%d%d...
这是一篇Markdown的学习笔记整理
qq_30836399的博客
08-11 267
这是一篇Markdown的学习笔记整理 参考博客： https://blog.csdn.net/u014061630/article/details/81359144 写得比我详细好多_(:з」∠)_ 没事我留着自己慢慢康 文章目录这是一篇Markdown的学习笔记整理换行和空格字体更改标题部分常用转义符代码超链接(\[]\()\)列表引用注脚表格分隔线数学公式 换行和空格 换行 可...
尝试使用markdown编写数据结构树的知识脑图笔记
技术宅拯救世界
10-15 1069
#mermaid-svg-JpmMczGpsGYt3CZg .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-JpmMczGpsGYt3CZg .label text{fill:#333}#mermaid-svg-JpmMczGpsGYt3CZg .node rect,#mermaid-svg-JpmMczGpsG
https://www.cnblogs.com/linjiqin/p/7965783.html 收藏博客
zhengjie_yjx的博客
10-25 1万+
https://www.cnblogs.com/linjiqin/p/7965783.html    
数据结构笔记(郝斌主讲)（2015-11-26 22:16:36更新完毕）
阿滔-juliantem
08-21 1100
教材-课外书籍推荐 高一凡(伪算法→真代码) 数据结构概述 定义 我们如何把现实生活中大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器(内存)中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对所有元素进行排序）而执行的相应操作，这个相应的操作也叫算法 数据结构 = 个体 + 个体的关系 算法 = 对存储数据的操作 算法
新手向：Markdown 学习笔记
张猿的日常
01-05 1187
markdown 学习笔记 不得不说，认识了 markdown 之后感觉进入了全新的写作世界，再也不用等写完之后在进行文章的逐步排版了，也不用进行复杂的排版设计了，用 markdown 写作不需要首行缩进，不需要单独调整代码颜色，不需要调节图片布局，一切的一切都是为了更专注创作，让你不用分心它物，嗯，真好 markdown 编辑器和富文本编辑器的区别 富文本编辑器：如 word，所见即所得编...
Markdown语法笔记（二） 绘图(流程图 甘特图 图表)
热门推荐
会飞的鱼的博客
02-28 2万+
  在写文档过程中经常会遇到画流程图，程序框图等情况。一般在word中用自带的画图功能或者用Visio画好后，进行粘贴复制。在markdown中，使用mermaid插件，也可以愉快的画流程图，不过没word/Visio里面那么无脑，直接拖控件，调整控件的大小，但是画出来的流程图也不错。   首先设置typora的偏好设置，使其支持mermaid插件。设置方法：文件—偏好设置，找到Markdown扩...
951数据结构复习指南：荣正课本重点解析
"这是一份针对数据结构初试复习的资料，主要依据荣正的《数据结构与算法分析》教材，旨在帮助考生了解并掌握教材中的重点和难点。资料并非课本的简略版，而是强调关键知识点和易错点，同时提醒考生需要完成课本习题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值