豫章故郡，洪都新府。星分翼轸，地接衡庐。襟三江而带五湖，控蛮荆而引瓯越。物华天宝，龙光射牛斗之墟；人杰地灵，徐孺下陈蕃之榻。雄州雾列，俊采星驰。台隍枕夷夏之交，宾主尽东南之美。都督阎公之雅望，棨戟遥临；宇文新州之懿范，襜帷暂驻。十旬休假，胜友如云；千里逢迎，高朋满座。腾蛟起凤，孟学士之词宗；紫电青霜，王将军之武库。家君作宰，路出名区；童子何知，躬逢胜饯。时维九月，序属三秋。潦水尽而寒潭清，烟光凝而暮山紫。俨骖騑于上路，访风景于崇阿；临帝子之长洲，得天人之旧馆。层峦耸翠，上出重霄；飞阁流丹，下临无地。鹤汀凫渚，穷岛屿之萦回；桂殿兰宫，列冈峦之体势。披绣闼，俯雕甍，山原旷其盈视，川泽纡其骇瞩。闾阎扑地，钟鸣鼎食之家；舸舰弥津，青雀黄龙之舳。云销雨霁，彩彻区明。落霞与孤鹜齐飞，秋水共长天一色。渔舟唱晚，响穷彭蠡之滨；雁阵惊寒，声断衡阳之浦。遥襟甫畅，逸兴遄飞。爽籁发而清风生，纤歌凝而白云遏。睢园绿竹，气凌彭泽之樽；邺水朱华，光照临川之笔。四美具，二难并。穷睇眄于中天，极娱游于暇日。天高地迥，觉宇宙之无穷；兴尽悲来，识盈虚之有数。望长安于日下，目吴会于云间。地势极而南溟深，天柱高而北辰远。关山难越，谁悲失路之人；萍水相逢，尽是他乡之客。怀帝阍而不见，奉宣室以何年？嗟乎！时运不齐，命途多舛。冯唐易老，李广难封。屈贾谊于长沙，非无圣主；窜梁鸿于海曲，岂乏明时？所赖君子见机，达人知命。老当益壮，宁移白首之心；穷且益坚，不坠青云之志。酌贪泉而觉爽，处涸辙以犹欢。北海虽赊，扶摇可接；东隅已逝，桑榆非晚。孟尝高洁，空余报国之情；阮籍猖狂，岂效穷途之哭！勃，三尺微命，一介书生。无路请缨，等终军之弱冠；有怀投笔，慕宗悫之长风。舍簪笏于百龄，奉晨昏于万里。非谢家之宝树，接孟氏之芳邻。他日趋庭，叨陪鲤对；今兹捧袂，喜托龙门。杨意不逢，抚凌云而自惜；钟期既遇，奏流水以何惭？呜呼！胜地不常，盛筵难再；兰亭已矣，梓泽丘墟。临别赠言，幸承恩于伟饯；登高作赋，是所望于群公。敢竭鄙怀，恭疏短引；一言均赋，四韵俱成。请洒潘江，各倾陆海云尔：

一、选择题

1.顺序表中第一个元素的存储地址是100, 每个元素的长度为2, 则第5个元素的地址是（ ）。

A. 110

B. 108

C. 100

D. 120

答:B

**2.在含n个结点的顺序表中，算法的时间复杂度是O(1)**的操作是( )。

A. 访问第i 个结点 (1<=i<=n) 和求第i 个结点的直接前驱 (2<=i<=n)

B. 在第i 个结点后插入一个新结点 (1<=i<=n)

C. 删除第1 个结点 (1<=i<=n)

D. 将n个结点从小到大排序

答：A

3.在一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动的元素个数为（ ）。

A. 8

B. 63.5

C. 63

D. 7

答：B。 顺序表插入算法分析：$\large E_{ins}=\dfrac{1}{n+1}\sum\limits_{i=1}^{n+1}(n-i+1)=\dfrac{n}{2}$

4.链接存储的存储结构所占存储空间( )。

A. 分为两部分，一部分存放结点值，另一部分存放表示结点间关系的指针**

B. 只有一部分， 存放结点值

C. 只有一部分， 存储表示结点间关系的指针

D. 分两部分， 一部分存放结点值，另一部分存放结点所占单元数

答：A

5.线性表若采用链式存储结构，要求内存中可用存储单元的地址（ ）。

A. 必须是连续的

B. 部分地址必须是连续的

C. 一定是不连续的

D. 连续或不连续都可以

答：D

6.线性表 L 在（ ）情况下适用千使用链式结构实现。

A. 需经常修改 L中的结点值

B. 需不断对 L 进行删除、 插入

C. L 中含有大量的结点

D. L 中结点结构复杂

答：B

7.单链表的存储密度（ ）。

A. 大于1

B. 等于1

C. 小于1

D. 不能确定

答：C

8. 将两个各有n个元素的有序表归并成一个有序表， 其最少的比较次数是（）。

A. n

B. 2n- 1

C. 2n

D. n-1

答：A

9.在一个长度为n的顺序表中，在第i个元素(1<=i<=n+1) 之前插入一个新元素时需向后移动（ ） 个元素。

A. n-i

B. n -i+1

C. n - i -1

D. i

答：B,i是第几个位置，x是移动次数，第1个移动n次，第2个移动n-1次最后一个移动0次，可发现$\large i+x=n+1$

10.线性表 L=(a1 , a2, …， an), 下列陈述正确的是（ ）.

A. 每个元素都有一个直接前驱和一个直接后继

B. 线性表中至少有一个元素

C. 表中诸元素的排列必须是由小到大或由大到小

D. 除第一个和最后一个元素外， 其余每个元素都有一个且仅有一个直接前驱和直接后继

答：D

一个包括n个结点的有序单链表的时间复杂度是( )。**

A. 0(1)

B. O(n)

C. $O(n^2) $

D. $O(nlog_2 n)$

答：C，单链表创建的时间复杂度是O(n)，而要建立一个有序的单链表，则每生成一个新结点时需要和已有的结点进行比较，确定合适的插入位置，所以时间复杂度是O(n2)。

12.以下陈述错误的是( )。

A. 求表长、 定位这两种运算在采用顺序存储结构时实现的效率不比采用链式存储结构时实现的效率低

B. 顺序存储的线性表可以随机存取

C. 由于顺序存储要求连续的存储区域， 所以在存储管理上不够灵活

D. 线性表的链式存储结构优于顺序存储结构

答：D

13.在单链表中， 要将s所指结点插入到p所指结点之后， 其语句应为( )。

A．s->next=p+1; p->next=s;

B．(*p).next=s; (*s).next=(*p).next;

C．s->next=p->next; p->next=s->next;

D．s->next=p->next; p->next=s;

答：D

14.在双向链表存储结构中， 删除p所指结点时修改指针的操作为（ ）。

A．p->next->prior=p->prior; p->prior->next=p->next;

B．p->next=p->next->next; p->next->prior=p;

C．p->prior->next=p; p->prior=p->prior->prior;

D．p->prior=p->next->next; p->next=p->prior->prior;

答：A

15.在双向循环链表中，在 p指针所指的结点后插入 q所指向的新结点，其修改指针的操作是（ ）。

A. p->next = q; q->prior = p; p->next->prior = q; q->next = q;**

B. p->next = q; p->next->prior = q; q->prior=p; q->next = p->next;

C. q->prior = p; q->next = p->next; p->next->prior = q; p->next = q;

D. q->prior = p; q->next = p->next; p->next = q; p->next->prior = q;

答：C

二、算法设计题

（1）将两个递增的有序链表合并为一个递增的有序链表。不占用其它的存储空间。表中不允许有重复的数据。

• 算法分析：

  • 创建一个新表Lc,将La和Lb从头开始进行比较，将其中较小的放在Lc表中，如果两个表中的元素相等，则将La的元素放入Lc，Lb的元素删除,重复这个步骤，直到La或Lb中一个表到达尾节点，将非空表的剩余元素直接连接在Lc表的最后

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

  void MergeList(LINKlIST &La,LinkList &Lb,LinkList &Lc) pa=La->next; pb=Lb->next; Lc=pc=La; //用La的头结点作为Lc的头结点 while(pa && pb){ if(pa->data < pb->data){pc->next=pa;pc=pa;pa=pa->next;} //pc指针赋值是为了后移 else if(pa->data > pb->data){pc->next=pb;pc=pb;pb=pb->next;} else {pc->next=pa;pc=pa;pa=pa->next; q=pb->next;delete pb;pb =q;} } //相同时取La的元素，删除Lb的元素 pc->next=pa?pa:pb; //插入剩余段 delete Lb; //释放Lb的头结点 }

  具体合并过程可看*《数据结构与算法基础 王卓老师的p44》*

（2）将两个非递减的有序链表合并为一个非递增的有序链表。不占用其它的存储空间。表中允许有重复的数据。

• 算法分析：

  • 创建一个新表Lc,将La和Lb从头开始进行比较，将其中较小的放在Lc表中，如果两个表中的元素相等，则将La的元素放入Lc，保留Lb中的元素,重复这个步骤，直到La或Lb中一个表到达尾节点，将非空表的剩余元素直接连接在Lc表的最后

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

  void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc, ) {//合并链表La和Lb，合并后的新表使用头指针Lc指向 pa=La->next; pb=Lb->next; //pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点 Lc=pc=La; //用La的头结点作为Lc的头结点 Lc->next=NULL; while(pa||pb ) {//只要存在一个非空表，用q指向待摘取的元素 if(!pa) {q=pb; pb=pb->next;} //La表为空，用q指向pb，pb指针后移 else if(!pb) {q=pa; pa=pa->next;} //Lb表为空，用q指向pa，pa指针后移 else if(pa->data<=pb->data) {q=pa; pa=pa->next;} //取较小者（包括相等）La中的元素，用q指向pa，pa指针后移 else {q=pb; pb=pb->next;} //取较小者Lb中的元素，用q指向pb，pb指针后移 q->next = Lc->next; Lc->next = q; //将q指向的结点插在Lc 表的表头结点之后 } delete Lb; //释放Lb的头结点 }

（3）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。

• 算法描述：

  • 创建一个新表Lc，pa和pb分别是La和Lb的工作指针，从第一个结点开始依此比较，因为是递增排列，如果两个表中元素相等，则摘取La表中的元素，删除Lb中的元素，如果两者比较时其中一个表的元素较小时，删除此表中较小的元素，指针后移，直到有一个表到达尾节点，依此删除另一个表的剩余元素。

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

  void Mix(LinkList& La, LinkList& Lb, LinkList& Lc){ pa=La->next; pb=Lb->next; //pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点 Lc=pc=La; //用La的头结点作为Lc的头结点 while(pa&&pb){ if(pa->data == pb->data){ pc->next=pa;pc=pa;pa=pa->next; u=pb;pb=pb->next; delete u; } //交集并入结果表中。 else if(pa->data < pb->data) {u=pa;pa=pa->next; delete u;} else {u=pb; pb = pb->next; delete u;} } while(pa) {u=pa; pa = pa->next; delete u;}//释放结点空间 while(pb) {u=pb; pb = pb->next; delete u;}//释放结点空间 pc->next=null; //置链表尾标记。 delete Lb; //释放Lb的头结点 }

（4）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出两个集合A和B 的差集（即仅由在A中出现而不在B中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合的元素个数。

• 算法描述：

  • 使用指针pre指向前驱结点。pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，直到两个链表La或Lb到达尾结点，如果La表中的元素小于Lb表中的元素，pre置为La表的工作指针pa删除Lb表中的元素；如果其中一个表中的元素较小时，删除此表中较小的元素，此表的工作指针后移。当链表La和Lb有一个为空时，依次删除另一个非空表中的所有元素。

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  void Difference(LinkList& La, LinkList& Lb,int *n) {//差集的结果存储于单链表La中，*n是结果集合中元素个数，调用时为0 pa=La->next; pb=Lb->next; //pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点 pre=La; //pre为La中pa所指结点的前驱结点的指针 while(pa&&pb) {if（pa->data < pb->data）{pre=pa;pa=pa->next;*n++;} //A链表中当前结点指针后移 else if（pa->data > pb->data）pb=pb->next; //B链表中当前结点指针后移 else {pre->next=pa->next; u=pa; pa=pa->next; delete u;} //处理A，B中元素值相同的结点，应删除 } }

（5）设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点（链表A中的元素为非零整数，要求B、C表利用A表的结点）。

• 算法描述:

  • B表的头结点使用原来A表的头结点，为C表新申请一个头结点。从A表的第一个结点开始，依次取其每个结点p，判断结点p的值是否小于0，利用前插法，将小于0的结点插入B表,大于等于0的结点插入C表。

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  void DisCompose(LinkedList A){ B=A; B->next=NULL; //B初始化为空表 C=new LNode;//为C申请空间 C->next=NULL; //C初始化为空表 p=A->next; //p为工作指针 while(p!= NULL){ r=p->next; //暂存p的后继 if(p->data < 0) {p->next=B->next; B->next=p;}//将小于0的结点链入B表,前插法 else {p->next=C->next; C->next=p;}//将大于等于0的结点链入C表,前插法 p=r;//p指向新的待处理结点。 } }

（6）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。

• 算法描述：

  • 假定第一个结点中数据具有最大值，依次与下一个元素比较，若其小于下一个元素，则设其下一个元素为最大值，反复进行比较，直到遍历完该链表。

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  ElemType Max (LinkList L ){ if(L->next==NULL) return NULL; max=L->next; //假定第一个结点中数据具有最大值 p=L->next->next; while(p != NULL ){//如果下一个结点存在 if(p->data > max->data) max=p;//如果p的值大于pmax的值，则重新赋值 p=p->next;//遍历链表 } return max->data;

（7）设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。

• 算法描述：

  • 从首元结点开始，逐个地把链表L的当前节点p插入新的链表头部

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  void inverse(LinkList &L){ // 逆置带头结点的单链表 L lNode *p,*r; p=L->next; L->next=NULL; while(p){ q=p->next; //q为p后一结点，和p同样会后移 p->next=L->next;//p结点后继改为头结点的后继，刚开始为NULL，之后都是有结点的 L->next=p; //头结点后继变为p结点，最先的是1结点，后面依次为 2 3 4 5 p = q;//p结点后移 } }

（8）设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。

• 算法分析：

  • 分别查找第一个值>mink的结点和第一个值 ≥maxk的结点，再修改指针，删除值大于mink且小于maxk的所有元素。

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  void delete(LinkList &L, int mink, int maxk) { p=L->next; //首元结点 while (p && p->data<=mink) { pre=p; p=p->next; } //查找第一个值>mink的结点 if (p) {while (p && p->data<maxk) p=p->next; // 查找第一个值 ≥maxk的结点 q=pre->next; pre->next=p; // 修改指针 while (q!=p) { s=q->next; delete q; q=s; } // 释放结点空间 }//if }

（9）已知p指向双向循环链表中的一个结点，其结点结构为data、prior、next三个域，写出算法change§,交换p所指向的结点和它的前缀结点的顺序。

• 算法分析：

  • 知道双向循环链表中的一个结点，与前驱交换涉及到四个结点（p结点，前驱结点，前驱的前驱结点，后继结点）六条链。

• 算法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  void Exchange（LinkedList p） //p是双向循环链表中的一个结点，本算法将p所指结点与其前驱结点交换。 {q=p->llink; q->llink->rlink=p; //p的前驱的前驱之后继为p p->llink=q->llink; //p的前驱指向其前驱的前驱。 q->rlink=p->rlink; //p的前驱的后继为p的后继。 q->llink=p; //p与其前驱交换 p->rlink->llink=q; //p的后继的前驱指向原p的前驱 p->rlink=q; //p的后继指向其原来的前驱 } //算法exchange结束。

（10）已知长度为n的线性表A采用顺序存储结构，请写一时间复杂度为O(n)、空间复杂度为O(1)的算法，该算法删除线性表中所有值为item的数据元素。

• 算法分析：

  • 在顺序存储的线性表上删除元素，通常要涉及到一系列元素的移动（删第i个元素，第i+1至第n个元素要依次前移）。本题要求删除线性表中所有值为item的数据元素，并未要求元素间的相对位置不变。因此可以考虑设头尾两个指针（i=1，j=n），从两端向中间移动，凡遇到值item的数据元素时，直接将右端元素左移至值为item的数据元素位置。

• 算法描述：

  1 2 3 4 5 6 7 8 9 10 11 12 13

  void Delete（ElemType A[ ]，int n） //A是有n个元素的一维数组，本算法删除A中所有值为item的元素。 {i=1；j=n；//设置数组低、高端指针（下标）。 while（i<j） {while（i<j && A[i]!=item）i++; //若值不为item，左移指针。 if（i<j）while（i<j && A[j]==item）j--;//若右端元素为item，指针左移 if（i<j）A[i++]=A[j--];}

1 C语言基础知识

1.1 进位计数制

1.1.1 下标：

​二进制()~2~ B 八进制()~8~ O/Q
​十进制()~10~ D 十六进制()~16~ H

1.1.2 进制转换

​方法：整数：转几除几，倒取余
​小数：转几乘几，正取余

1.2 字符在计算机内部的表示

• 字符在计算机内部以ASCII码存储，占1个字节，**整形数据在计算机内以补码**表示。

  大写字母：A-65，……Z-90

  小写字母：a-97，……z-122

  数字字符：0-48,1-49.……9-57

  空格：32 **\0’**的ASCII码是 0

• 大小写转换要±32

2 C语言的概述

2.1 C语言的基本概念

1. C语言编写的程序成为**源程序（.c），不可直接执行，先经过编译变成目标程序（.obj），在经过链接**处理后才可运行，处理后生成的文件扩展名是（.exe）

1
2

graph LR
C语言-->|编写|D[源程序.c]-->|编译|E[目标程序.obj]-->|链接|F[文件.exe]

2. 由高级语言编写的程序称为**源程序**

2.2 程序化设计

1. C语言是一种结构化的程序设计语言，它提供了三种**基本结构语句，结构化程序通常由三种基本结构组成，包括顺序，选择，循环**。

2. C程序由**函数组成，函数是组成C程序的基本**单位，语句是C程序的最小单位。

3. C程序总是从**主函数开始执行，由主函数结束，主函数**的位置是任意的

4. 语句最后以**分号**结束

5. 一行可以写**一条或多条语句，一条语句也可以写一行或多行**

6. 标识符

   1. 组成：数字，字母，下划线，开头只能是**字母或下划线**

   2. 标识符分为关键字，预定义标识符，用户标识符。

      关键字都是小写字母，不能用做用户标识符，预定义标识符包括（define，include，scanf，printf）可以作为用户标识符但不建议。

      标识符区分大小写

3 数据类型极其运算

3.1 数据类型

1. 常见的基本数据类型包括**整型，实型，字符型**。

   1. 整形包括**常量，变量**

      • 常量：在程序运行中，值不可改变的量
      • 变量：在程序运行中，值可以改变的量

3.1.1 整形常量

1. C语言中没有二进制

2. 八进制前导**$\large 0$**

3. 十六进制前导**$\large 0x$或者$\large 0X$**

4. %d 十进制
   %o 八进制
   %x：十六进制数（字母小写）^1
   %X：十六进制数（字母大写）^1

   • 输入有前导，==输出无前导==

3.1.2 整型变量

• 未赋值的变量输出时默认为随机值

• 当格式字符少于输出项时多余的输出项不输出

  printf（“%d”,a,c）不输出c

• 当格式字符多于输出项时输出随机值

  printf（“%d，%d”,a）输出一个a一个随机值

3.1.3 实型常量

1. 小数点式

   1. 小数点式：由**数字，正负号，小数点**组成
      • 小数点式：必须有小数点，至少一边有数字
        • $0.78\Rightarrow.78$ $3.0\Rightarrow 3.$

   指数形式

   1. 由E或者e组成

      • $12.34E+2\Rightarrow12.34\times10^{+2}$

      • $12.34e-2\Rightarrow12.34\times10^{-2}$

      • E或e的**两边必须有数字，右边（指数部分）必须是整数**

        $3.14E-7.0(X)$ 右边的7.0是实型中的小数点式

   实型变量

   • 单精度：float 占4字节
   • 双精度：double 占8字节
   • %f：十进制浮点数
     • %f输出默认保留**==6位小数，不足补0，超过6位四舍五入==**
     • 当多个类型的值进行混合运算时，运算结果为字节数**最大的类型*

3.1.4 字符常型

• 常规字符常量

  • 单引号只能放一个字符，一个字符一个字节

  • 转义字符

    ‘\n’:换行

    ‘\t’:横向跳格（跳过8列）

    ‘\b’:左移覆盖 printf（“abcd\b1234”）;=printf(“abcd\b”)

    ‘\’‘’:输出’

    ‘\"’:输出”

    ‘\\’:输出\

  • 八进制转义字符：‘\ddd’一到三位八进制表示一个字符

    • ‘\101’ ‘\006’ ==前导的0可加可不加==

  • 十六进制转义字符：‘\xhh’一到二位十六进制表示一个字符

    • ‘\xab’ ==前导x必须有==

• 字符串常量

  • 双引号括起多个字符 例如“ABCD”占**5**个字节
    • 字符串后面还有个**‘\0’，其为字符串的结束标志**

3.1.5 字符型变量

• char 占一个字节

  %c 只能输出一个字符

• printf（“%c\n”,‘A’） ； A
  printf（“%d\n”,‘A’） ； 65

  • ==如果以%d形式输出一个字符，则输出他的ASCII码值。==

3.2 常见运算符

3.2.1 算数运算符

• 算数运算符：+，-，*，/，%

  • $/$两边都是整形的话，结果就是一个整形，任意一个为实型，结果为实型。

    • 4+3.0=7.0

  • $%$两边要求是整数，余数正负号与被除数（左边的数）一致。

    • -7%3=-1

    • 并且**求余运算符的对象必须是整型**

    • 整型变量只接受整数部分

      1 2 3 4 5 6 7

      int a=1; float b=2.5; a=b; a=2;

3.2.2 强制类型转换符

• 形式：(类型名)表达式

  （int）x/2 解释运算过程：将X强制转换成整形，最后结果除以2

  （int）（x/2） 解释运算过程：将（x/2）的结果强制转换成整形

  • 强制转化只对结果有影响，表达式还是原来的类型并未改变

    • 按照指定宽度输出

  • 指定>宽度 ==左补==空格

  • 指定<实际 原样输出

    1 2 3

    int a=1234; printf("a=%5d\n",a);a=_1234 printf("a=%2d\n",a);a=1234

• %m,nf

• m-代表数据总长（包含小数点），n代表小数位数

  实际>n 四舍五入

  实际<n 补零

  1 2 3 4

  float f=3.1415； printf("f=%7.2f\n",f);f=_ _ _3.14 printf("f=%10.5f\n",f);f=_ _ _3.14150 printf("f=%4.3f\n",f);f=3.142//实际五位数，大于要求的四位数，原样输出

• int的数据范围是-32768~+32767

• int a=1；

  for（;a>0;a++）是死循环

• 无符号数据范围0~65535

  • 无符号65535与int型-1对应

• %u：无符号十进制整数

数据输入

1. 整型数据输入如果没有其他符号分隔，用空格或回车分隔

   scanf（“%d%d”，&a&b）; 1_2 或者 1回车2

2. 指定输入数据的宽度时输入宽度不得少于指定宽度

3. 实型数据输入时，不能指定小数位数

   scanf（“%3.2f”，&f）；（X）

4. %c前不能加空格，因为空格也是字符，也会被输入进去

5. 字符输入函数：getchar（）

   字符输出函数：putchar（）

   只针对一个字符的输入和输出

   1 2 3

   char ch; ch=getchar(); putchar(ch);

• ==将两个整数a和b的值互换后输出==
  • t=a,a=b,b=t;空瓶子原理（需要定义第三变量）
  • a=a+b；b+a-b；a=a_b; 和差差（不需要定义第三变量）

4 选择结构

4.1 关系运算与逻辑运算

• C语言中：C语言将非零值视作真。0值视作假

4.1.1 关系运算

• $>>,>=,<,<=,==,!=$
  • 成立 ：1 不成立：0

4.1.2 逻辑运算

• 逻辑运算符：！，&&，||

  • &&：有0为0，全1为1
    • 条件同时满足
  • ||：有1为1，全0为0
    • 只满足一个就可以
  • ！：取反
    • 1+2&&3+4结果为1
  • 符号优先级

  优先级	运算符
  1	！
  2	算数运算符 *,/,%大于+,-
  3	关系运算符 <,>,>=,<=大于==,!=
  4	&&
  5	||
  6	赋值运算符
  7	逗号运算符

  • 逻辑与运算与逻辑或运算同时出现时，&&运算优先级高，先结合

    从左向右计算

    • ++a||++b&&++c=++a||(++b&&++c)

4.2 条件运算符号（三目运算符）

• 形式：条件1？值1；值2

  • 条件为真，结果为值1；为假：则结果为值2

    1 2 3 4 5 6 7

    #include <stdio.h> int main() { int a=2,b=1,c=3,d=4; int result=(a<b?a;c<d?a;d); printf("结果是：%d\n",result);//结果是：2 return 0 }

4.3 if语句

• 单分支if(语句)

  • 条件为真，执行语句，为假，则不执行
  • if只能控制一条语句，==if语句后的分号比较重要==

• 双分支if(语句)

  • 真，执行if语句，假，执行else
  • 出现多个else时，要注意配对原则
    • 就近原则，else总是和**==上面的，最近的，未配对==**的配对

4.4 switch语句

• 看括号里的内容，执行与case对应的，顺序执行，直到break跳出循环
  • 先进入，后向下
  • case后面必须是**整形常量或常量表达式**（switch括号内一样）
  • default表示“其他”分支，可有可无，位置任意
  • break跳出循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>

int main() {
    int num;

    printf("请输入一个数字（1-3）：");
    scanf("%d", &num);

    switch (num) {
        case 1:
            printf("你输入了数字1\n");
            break;
        case 2:
            printf("你输入了数字2\n");
            break;
        case 3:
            printf("你输入了数字3\n");
            break;
        default:
            printf("你输入的数字不在范围内\n");
            break;
    }

    return 0;
}

5 循环结构

5.1 while循环

• 形式：while（条件）语句；

  • 先判断条件，为真时循环，直到条件为假跳出循环

  • 循环三要素：初值，条件，增量

  • ==循环次数看成立几次==

  • 与if语句相同，while循环只控制一条语句

  • 常见用法-倒序输出

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

    #include <stdio.h> int main() { int x = 1234; printf("倒过来输出的数字是："); while (x > 0) { int digit = x % 10; // 取最后一位数字 printf("%d", digit); // 输出最后一位数字 number /= 10; // 去掉最后一位数字 } printf("\n"); return 0; }

5.2 do-while循环

• 形式：

  do语句;

  while（条件）;

• 先执行语句再判断条件，为真时循环，直到条件为假跳出循环

  • while后面分号不可以省略，代表循环语句结束
  • 循环次数也是看条件成立几次
  • 循环体执行次数比条件成立次数多一
  • do-while语句至少执行一次

5.3 for循环

• 形式：

  for（初值；条件；增量）语句；条件为真，执行语句，然后返回增量

  • 省略式1，执行式2
  • 省略式2，默认条件为真
  • 省略式3，回式2
  • 式子都可以省，分号不能省

• 循环次数看条件成立几次

5.4 break和continue

• break语句

  • 跳出循环，在那个循环内部，就跳出那个循环

• continue

  • 结束本次循环，进入下一次循环

    • while循环，回条件
    • do-while循环，回条件
    • forxunhuan,回增量

  • continue只跟循环语句有关系，看见continue就找循环

5.5 循环的嵌套

• 嵌套循环的次数为 内循环次数X外循环次数

• 常用嵌套代码-更相减损法

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  #include <stdio.h> int main() { int a, b; printf("请输入两个整数："); scanf("%d %d", &a, &b); // 保证a和b是非负数 if (a < 0) a = -a; if (b < 0) b = -b; // 使用更相减损法求最大公约数 while (a != b) { if (a > b) { a = a - b; } else { b = b - a; } } printf("最大公约数是：%d\n", a); return 0; }

• 常用嵌套代码-辗转相除法

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  #include <stdio.h> int main() { int a, b; printf("请输入两个整数："); scanf("%d %d", &a, &b); // 保证a和b是非负数 if (a < 0) a = -a; if (b < 0) b = -b; while (b != 0) {//除数 int temp = a % b;//余数=大%小 a = b ;//大=小 b = temp;//小=余 } printf("最大公约数是：%d\n", a);//输出被除数 return 0; }

6 函数

6.1 函数的定义

1. 函数是组成c程序的基本单位，语句是最小单位
2. C程序总是从**主函数开始执行，由主函数结束，主函数**的位置是任意的
3. ==实参的类型可以与形参类型不一致，以形参的类型为准==
4. 实参和形参各占独立存储单元
5. 形参需单独定义，属于定时变量，调用函数时为其分配存储单元，调用结束后释放存储单元
6. ==函数应先定义后调用==
7. ==函数可以嵌套调用，但不可以嵌套定义==
   • $/large (int x,int y)（✓）(int x,y)（X）$
8. 函数默认为int型
9. ==函数返回值的类型是由定义函数时所指定的函数类型决定的==
10. main（）函数不能调用自己，其他函数都可以调用自己
11. return语句只能带回一个返回值，void表示函数无返回值
    • void可以定义函数，也可以定义变量
    • 函数不一定都有参数
12. ==函数的实参传递分为值传递和地址传递==

6.2 函数声明

• 形式：float fun（float x,float y）；
  1. 先定义，后调用
  2. ==先声明，再调用，最后定义==

（错题本上有道题可以放这里，这里先按下不表）

6.3 函数的调用

• 函数调用形式
  1. 语句调用 fun（a,b）;
  2. 表达式调用 y=fun（a,b）;
  3. 嵌套调用 将函数的返回值作为实参进行调用
     • fun(a,fun(a,b))
  4. 递归调用 函数直接或间接的调用自己
     1. 直接递归 A->A
     2. 间接递归 A->B->A

7 数组

7.1 定义

​类型说明符 数组名【常量表达式】；

• int a [ ]；

• 中括号是**整型常量或整型常量表达式**。

• 定义数组时，需要指定数组元素个数，方括号中的整形常量或整型表达式用来表示元素的个数，即数组长度。

• 中括号中的常量可以是符号常量（宏定义中的字符）。

  • #define N10

    int a [N]；

• 不可以给整型数组赋字符串 char s【】;s=“right!”; [x]

7.2 一维数组的应用

• 数组必须先定义，再使用
• 引用形式：数组名【下标】 、
  • 数组的下标都是**从0开始**的
• 数组初始化可以少赋值，不能多赋值
• 未赋值的部分默认为0
• 数组长度为初始化元素个数

7.3 二维数组的应用

• 引用形式：数组名【下标】【下标】
• ==行下标可以省略，列下标不能省略==
• 没赋值，则行列都不可省
• 初始化至少赋一个值

8 指针

• 指针的概念

  • ==指针就是地址==

    变量的指针就是变量的地址

• 指针的定义

  • 基类型*指针变量名 int * p；
  • $$ **==只有在定义语句中是指针定义符==***

8.1 指针的赋值

• 通过取地址运算符：&

  • int a , * p

    p = & a ;

• 通过另一个指针

  • int a，* p ， * q；

    p = & a ; q = p ;

• 空指针的定义

  • int * p = NULL ;
  • 其值为0

• 指针的操作

  • &：取地址运算符
    • p = & a
  • *：取内容运算符
    • * p = a

8.2 指针与一维数组

1. 一维数组的地址

   • a是数组名，即一维数组的首地址，第0个元素的地址，即&a[0]

2. 一维数组常用表达式

   • a ：& a [0]
   • a+i : & a [i]
   • * (a+i): a [i]

3. 指向一维数组的指针

   • 指针指向哪一位，哪一位就是该指针的首元素

   • *++p：指针后移，取值

   • ++*p：先取值，加一

   • *p++：先取值，指针后移

   • ==数组名是地址常量，不可赋值。指针是变量，可以赋值。==

   • 指针比较大小就是比所在位置的大小

   • 指针可以想减不能相加

4. 函数之间对一维数组的引用

   实参	形参	传递方式
   数组元素 a [1] a [2]	变量	值传递
   数组元素地址 & a [1]	指针	地址传递
   数组名 a	指针	地址传递

8.3 指针与二维数组

• 前面为行，后面为列
• ==二维数组引用时出现，[]任意两个代表内容，出现一个代表地址==*

8.4 数组指针与指针数组

8.4.1 数组指针

• int ( * p ) [4];
  • p为类型的int型数组的指针。数组长度为4
  • 一个指向M个整形元素的一维数组指针

8.4.2 指针数组

• Int * q [3]；

  • q是由三个指针变量构成的数组，简称指针数组。q[0]，q[1]，q[2]，均为int *

    每一个元素都是一个指针，每个元素都是地址

    数组	数组名	元素
    int q [3]	整形元素	数值
    Int * q [3]	整型指针元素	指针

8.5 函数指针和指针函数

8.5.1 函数指针

• int ( * p )();
  • 说明p是返回值为整形函数的指针

8.5.2 指针函数

• int *p()；

  • 说明函数值为整型指针的函数

• ==p先和*结合说明是指针，p先和【】结合，说明是数组，p先和（）结合，说明是函数。==

9 字符串

9.1 字符数组与字符串

1. 字符数组定义

   用来存放字符的数组就是字符数组。

2. 字符数组的初始化

   省略的元素默认为‘\0’

   长度默认为初始化元素个数

3. 字符数组与字符串

   字符数组中，存放‘\0’，就当做字符串

9.2 字符串指针

1. 定义

   char *p；

2. 字符串指针赋值

   char *p=“ABCD”;或者 char s[5]={“ABCD”}

   字符串给指针赋值，指针只接收字符串首地址

9.3 字符串的输入与输出

1. 利用scanf和printf

   字符串输出时遇到‘\0’结束

   %s:输出一个字符串

   %c:输出一个字符

2. 字符串输入输出函数

   输入：gets（）^2

   输出：puts（）^2

   专门用于字符串的输入输出

   ==带空格的字符串不能用scanf输入，必须用gets（）==

9.4 字符串函数

9.4.1 字符串长度函数 strlen

==strlen（）不包括‘\0’，sizeof（）包括\0’，当参数是数组名时，直接输出数组的长度。==

9.4.2 字符串复制函数 strcpy

strcpy（字符数组1，字符串2）

将字符串2复制到字符数组1中，类似替换

==字符数组1的长度不能小于字符串2的长度==

9.4.3 字符串连接函数 strcat

strcat（字符数组1，字符数组2）

把字符数组2接到字符数组1之后（只有字符串1变化）

字符数组1必须足够大，以便容纳链接后的新字符串，链接后字符串1后面的‘\0’取消，只保留新串最后的\0’

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>
#include <string.h>

int main() {
    // 声明并初始化两个字符串
    char str1[50] = "Hello, ";
    char str2[] = "World!";
    
    // 输出原始字符串
    printf("Before strcat:\n");
    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);
    
    // 使用strcat连接str2到str1
    strcat(str1+1, str2+1);
    
    // 输出连接后的字符串
    printf("\nAfter strcat:\n");
    printf("str1: %s\n", str1);
    
    return 0;
}

运行结果

1
2
3
4
5
6

Before strcat:
str1: Hello, 
str2: World!

After strcat:
str1: ello, orld!

9.4.4 字符串比较函数 strcmp

• 比较字符串1和字符串2（用ASCII比较）
  • 串1大 1
  • 一样大 0
  • 串2大 -1
• 只能通过字符串比较函数比较字符串大小，不能通过关系运算符比较

10 变量作用域与存储类

10.1 作用域

10.1.1 局部变量

• 再复合语句内部或函数内部定义的变量称为局部变量
  • 自定义位置起，到符合语句或函数的结束

10.1.2 全局变量

• 自函数外部定义的变量称为全局变量
  • 自定义位置起，到程序结束
  • 局部变量和全局变量同时存在，先用局部变量

10.2 变量的存储类

1. 自动型：auto

   函数中的局部变量，默认都是自动型,在调用该函数时系统会给这些变量分配存储空间，函数调用结束时就会自动释放存储空间

   这类局部变量称为自动变量，用关键字auto做存储类别声明

• 变量默认的存储类为auto类型

2. 静态型：static 内部变量,内部函数

   调用结束后不消失而累计，即其占用的存储单元不释放

3. 寄存器型：register

4. extern 外部变量，外部函数

10.3 动态存储方式与静态存储方式

• 静态区

  • 变量类型：静态局部变量，全局变量或外部变量
  • 生存期：整个程序
  • 初始化在编译阶段,初值为0

• 动态区

  • 变量类型：动态变量
  • 生存期：他所在的局部
  • 初值为随机值

• 变量

  • 局部变量
    • 动态
    • 静态
  • 全局变量
    • 静态

• int x; 其中的$X$是动态变量，初值为随机
• static int x；其中的$X$是静态变量，初值为0

11 编译预处理

C语言提供的预处理功能主要有三种：==宏定义，文件包含和条件编译==

11.1 宏定义

• 形式：
  • #define 宏名 替换文本
    • #defube B 5
  • #define 宏名（参数） 替换文本
    • #define f(x) x*x
• 预处理命令不是C语句，不用加分号
• 宏名习惯用大写字母，但是也可以用小写

11.2 文件包含

• 形式：

  • #include<文件名>系统目录

  • #include“文件名” 系统目录+用户目录

    • stdio.h 标准输入输出头文件

      • 标准库函数

    • string.h 字符串函数头文件

      • strcmp

        strlen

    • math.h 数学函数头文件

      • sqrt

        fabs

• 提问方式

  • 只问头文件
    • stdio.h
    • string.h
    • math.h
  • 文件包含的整体格式
    • #include<stdio.h>
    • #include<string.h>
    • #include<math.h>
  • 问是什么命令
    • 文件包含/#include

• 例题

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
#define MAX( a , b ) ( a ) > ( b ) ? ( a ) ; ( b )
main() {
    int x , y , z ;
    x = 10 ;
    y = 15 ;
    z = 10 * MAX( x , y );//先不要计算，先把宏定义替换带入进去
    //z=10*( x ) > ( y ) ? ( x ) ; ( y )
    printf("%d\n",z);//结果为10
}

11.3 条件编译

不在考纲内，不想学了

12 结构体

在C语言中，数组是表示类型相同的数据，而结构体则是若干类型不同数据项的集合；

12.1 自定义类型

• 形式：typedef 类型 别名；
  • typedef int SER;
    • int 是本名 SER是别名（都是大写）
    • SER a；就相当于 int a;了

12.2 结构体

12.2.1 结构体的定义

• 形式：struct student

  ​{成员列表}： 结构体中成员类型可以相同也可以不同

  • struct：结构体类型关键字
  • student：结构体名/类型名
  • struct student：结构体类型/结构体类型名

12.2.2 结构体变量的定义

• 先说明结构体类型，再定义结构体变量

  1 2 3 4 5

  struct student{ int num; char name[8] };//分号很重要 sruct student a,*b,c[3];

• 说明结构体类型的同时定义结构体变量

  1 2 3 4

  struct student{ int num; char name[8] }a,*b,c[3];

• 直接定义结构体变量

  1 2 3 4

  struct{ int num; char name[8] }a,*b,c[3];

• 使用用户自定义类型定义结构体变量

  1 2 3 4 5

  typedef struct student{//struct student是本名 int num; char name[8] }STD;//STD是别名 STD a,*b,c[3];//等价 于sruct student a,*b,c[3];

12.2.3 结构体变量的初始化

• 结构体变量的初始化

  1 2 3 4

  struct data{ int a; float b; }s={12,24.56};

• 结构体数组的初始化

  1 2 3 4

  struct data{ int a; float b; }c[2]={1,2,3,4};

• 结构体变量所占空间大小

  • 等于所有成员只和

  • ==结构体指针变量占空间大小分为两种情况==

    • TC系统（默认）下：2个字节

    • VC系统下：4个字节

      系统	指针	int	其他
      TC	2B	2B	不变
      VC	4B	4B	不变

12.2.4 结构体成员引用

1. 结构体变量名.成员名字
2. 结构体指针->成员名
3. *（结构体指针名）.成员名
   • “.”：成员运算符 “->”：指向运算符

12.3 链表

1. 处理动态链表所需的函数

   • 函数malloc（）和calloc（）为链表分配存储空间，free（）释放存储空间

     • malloc（）分配变量

       1 2	int *p; p=(int*)malloc(sizeof)(int);

     • calloc（）分配数组

2. 指向自身的结构体类型

   1 2 3 4

   struct node{ int data; struct node *next; };

3. 静态链表

   1. 定义指向自身的结构体类型（数据结构里的链表）

      1 2 3 4

      struct node{ int data; struct node *next; };

   2. struct node a,b,c,*p; 定义结构体变量

   3. a.data=1；b.data=2;c.data=3; 给数据域赋值

   4. a.next=&b;b.next=&c;c.next=NULL; 连接

4. 链表的插入与删除

   1. 将q节点插入到p节点后

      q->next=p->next; 先连后面

      p->next=q; 再连前面

   2. 将q节点从链表中删除（q节点前为p节点）

      p->next=q->next;

      free(q);

13 位运算

1. 位运算符和位运算
   1. 按位与&：有0为0，全1为1
   2. 按位或|：有1为1，全0为0
   3. 按位异或^：相同为0，不同为1
   4. 按位取反~：相当于-(x+1)
   5. 位左移<<：左移几位乘几个2
   6. 位右移>>：右移几位除几个2（舍弃余数）

• ==位运算针对的都是二进制数==
  • 例题

1
2
3
4
5
6
7

#include <stdio.h>
main (){
    char a,b;
    a=4|3;//4=>0100  3=>0011
    b=4&3;
    printf("%d %d\n",a,b);//a=7 b=0
}

• 优先级：~，<<,>>,&,^,|
  • 例题

1
2
3
4
5
6

#include <stdio.h>
main (){
    char a=3,b=6，c;//a=00000011
    c=a^b<<2;//先算b<<2=24b=00011000
    printf("%x",c);//00011011输出为1b，输出无前导
}

14 文件

• 根据数据的组织形式，C语言将文件分为**ASCII码/文本文件和二进制文件**两种类型

• 文件指针

  • FILE 文件指针名

    FILE *fp；

• 文件函数

  • 文件的打开

    FILE *fp；

    fp=fopen(“a.txt”,”r”);

    以只读的方式打开文件a.txt，返回一个文件型指针，若没有打开文件返回空指针NULL。

  • 文件的关闭

    fclose（fp）；

    关闭文件指针fp所指的文件

  • 读字符函数 fgetc()

    ch=fgetc(fp);

    从文件指针fp所指的文件中读取一个字符赋给字符变量ch。

  • 写字符函数 fputc（）

    fputc(‘a’,fp)；字符常量

    fputc(ch,fp)；字符变量

    讲一个字符写入到文件指针fp所指的文件中

  • 读字符串函数 fgets（）

    fgets（str,11,fp）;

    从fp所指的文件中读取**10个字符放入字符输入数组str中，在最后一个（第10个）字符后面加1个‘/0’**

  • 写字符串函数 fputs（）

    fputs(“abcd”,fp);字符串常量

    将字符串写入到fp所指的文件中

    fputs(str,fp);字符数组名

    将字符数组中的字符串写入到fp所指的文件中.

  • int a,b;

    fscanf(fp,“%d%d”,&a&b);

    从fp所指的文件中读取两个十进制整数分别赋给整形变量a和b。

  • int a,b;

    fprintf(fp,“%d%d”,&a&b);

    将整形变量a和b的值以十进制的形式写入到fp所指的文件夹中

  • 数据块读函数fread（）;

    fread（a,4,5,fp）；

    从fp所指的文件中，每次读4个字节的数据放入数组a中，连续读5次。

  • 数据块写函数fwrite（）；

    fwrite（a,4,5,fp）

    从a数组的首地址开始，每次将4个字节的数据写入到fp所指的文件中，连续写5次。

  • rewind（）；

    将fp所指文件的位置**指针（插入点）移动到文件首部****

  • feof（fp）；

    • 判断fp所指的文件是否处于结束位置，处于结束位置返回1，否则返回0
    • E0F含义是指文件结束标志

  • fseek（文件指针，位移量，起始点）；

    fseek(fp,0L,SEEK_SET);等价于rewind（fp）

    fseek(fp,0L,2);指针位于文件末尾

  起始点	表示符号	数字表示
  文件首	SEEK_SET	0
  当前位置	SEEK_CUR	1
  文件末尾	SEEK_END	2

• ==r 读 w 写 a 追加 b二进制文件 t 文本文件 +可读可写==

  • 新建的文件用w开头
  • 若要打开一个***==新的==***二进制文件，该文件要既能读也能写，则文件方式字符串应是“wb+”

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  #include<stdio.h> main() { FILE *fp; char str[10]; fp=fopen("myfile.dat","w"); //新建文件夹 fputs("abc",fp);//字符串abc写进去 fclose(fp);//关上 fp=fopen("myfile.dat","a+");//追加形式打开可读可写 fprintf(fp,"%d",28);//把28写入 rewind(fp);//回到开头u fscanf(fp,"%s",str);//读字符串 puts(str);//写字符串abc28 fclose(fp);//关闭文件 }

8.1 基本概念和排序方法概述

8.1.1 排序的基本概念

• 排序：将一组杂乱无章的数据按照一定规律顺次排列起来，即，将无需数列排成一个有序序列（由小到大或由大到小）的运算。

  • 如果参加排序的数据结点包含多个数据域，那么排序往往是针对其中某个域而言
  • 排序方法的分类：
    • 按数据存储介质：内部排序和外部排序
      • 内部排序：数据量不大，数据在外存，无需内外存交换数据
      • 外部排序：数据量较大，数据在外存（文件排序）
        • 外部排序时，要将数据分批调入内存来排序，中间结果还要及时放入外存，显然外部排序要复杂得多
    • 按比价器个数：串行排序和并行排序
      • 串行排序：单处理机（同一时刻比较一对元素）
      • 并行排序：多处理机（同一时刻比较多对元素）
    • 按主要操作：比较排序和基数排序
      • 比较排序：用比较的方法
        • 插入排序、交换排序、选择排序、归并排序
      • 基数排序：不比较元素的大小，仅仅根据元素本身的取值确定其有序位置
    • 按辅助空间：原地排序和非原地排序
      • 原地排序：辅助空间用量为O(1)的排序方法（所占用的辅助存储空间与参与排序的数据量大小无关）
      • 非原地排序：辅助空间用量超过O(1)的排序方法
    • 按稳定性：稳定排序和非稳定排序
      • 稳定排序：能够使任何数值相等的元素，排序以后相对次序不变。
      • 非稳定排序：不是稳定排序的方法
    • 按自然性：自然排序和非自然排序
      • 自然排序：输入数据越有序，排序的速度越快的排序方法
      • 非自然排序：不是自然排序的方法

• 接下来的学习内容：

• 按排序依据原则：

  • 插入排序：直接插入排序、折半插入排序、希尔排序
  • 交换排序：冒泡排序、快速排序
  • 选择排序：简单选择排序、堆排序
  • 归并排序:：2-路归并排序
  • 基数排序

• 按排序所需工作量

  • 简单的排序方法：$ T(n)=O(n^2)$
  • 基数排序：$ T(n)=O(d.n)$
  • 先进的排序方法：$ T(n)=O(nlogn)$

• 存储结构——记录序列以顺序表存储

  1 2	#define MAXSIZE 20//设记录不超过20个 typedef int KeyType;//设关键字为int型

  1 2 3 4

  Typedef struct{ KeyType key;//关键字 infoType otherinfo;//其他数据项 }RedType;

  1 2 3 4 5

  Typedef struct{//定义顺序表的结构 RedType r[MAXSIZE +1];//存储顺序表的向量 //r[0]一般作哨兵或缓冲区 int length; }SqList;

8.2 插入排序

• 基本思想：
  • 在有序序列中插入一个元素，保持序列有序，有序长度不断增加
• 插入排序的种类
  • 顺序法定位插入位置——直接插入排序
  • 二分法定位插入位置——二分插入排序
  • 缩小增量多遍插入排序——希尔排序

8.2.1 直接插入排序

• 直接插入排序——采用顺序查找法查找插入位置

  1. 复制插入元素

  2. 记录后移，查找插入位置

     1 2	for(j=i-1;j>=0&&x<a[j]；j--) a[j+1]=a[j];

  3. 插入到正确位置

• 直接插入排序，使用“哨兵”

  1. 复制为哨兵 L.r[0]=L.r[i];
  2. 记录后移，查找插入位置
  3. 插入到正确位置

1
2
3
4
5
6
7
8
9
10
11
12

void InserSort(SqList &L){
    int i,j;
    for(i=2;i<=L.length;++i){
        if(L.r[i].key<L.r[i-1].key){
            L.r[0]=L.r[i];
            for(j=i-1;L.r[0].key<L.r[j].key;--j){
                L.r[j+1]=L.r[j];
            }
        }
        L.r[j+1]=L.r[0];
    }
}

• 平均的情况：
  • 比较次数$\sum\limits^{n-1}_{i=1} \dfrac{i+1}{2}=\dfrac{1}{4}(n+2)(n-1) $
  • 移动次数$\sum\limits^{n-1}_{i=1} （\dfrac{i+1}{2}+1）=\dfrac{1}{4}(n+6)(n-1) $
• 时间复杂度结论
  • 原始数据越接近有序，排序速度越快
  • 最坏情况下（输入数据是逆有序的） $Tw(n)=O(n^2)$
  • 平均情况下，耗时差不多是最坏情况的一半 $Te(n)=O(n^2)$
  • 要提高查找速度
    • 减少元素的比较次数
    • 减少元素的移动次数

8.2.2 折半插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13

void BinsertSort(SqList &L)｛   //对顺序表L做折半插入排序
for (i=2;i<=L.length;++i){
    L.r[O]=L.r[i];
low=l;high=i-1;
while(low<=high){
        m=(low+high)/2;
if(L.r[O].key<L.r[mid].key) high=mid-1;//插入点在前一子表
else low=mid+1;//插入点在后一子表
    }
    for (j=i一l;j>=high+l; --j) L.r[j+l]=L.r(j]; //记录后移
L.r[high+l]=L.r[O]; //将r[O]即原r[i], 插入到正确位置
}
}

• 算法特点：
  • 稳定排序
  • 应为要进行折半查找，所以只能用于顺序结构，不能用于链式结构
  • 适合初始记录无序，n较大时的情况
• 算法分析：
  • 时间复杂度为$O(n^2)$
  • 空间复杂度为$O(1)$

8.2.3 希尔排序

• 基本思想：

  • 先将整个待排记录序列分割成若干子序列，分别进行直接插入排序待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。

• 算法特点：

  • 一次移动，移动位置较大，跳跃式地接近排序后的最终位置
  • 最后一次只需要少量移动
  • 增量序列必须是递减的，最后一个必须是1
  • 增量序列应该是互质的

• 算法举例：

  

• 算法代码：

  1 2 3 4

  void shellsort(Sqlist &L,int dlta[],int t){ for(k=0;k<t;++k) shellinsert(L,dlta[k]);//一趟增量为dlta[k]的插入排序 }

  1 2 3 4 5 6 7 8

  void shellinert（SqList &L，int dk) for(i=dk+1;i<=L.length;++i) if(r[i].key<r[i-dk].key){ r[0]=r[i]; for(j=i-dk;j>0 &&（r[0].key<r[j].key);j=j-dk) r[j+dk]=r[j]; r[j+dk]=r[0] }

• 算法分析：

  • 时间复杂度是n和d的函数：
    • $O(N^{1.25})到O(1.6n^{1.25})——经验公式 $
    • 时间复杂度为$O(1)$
    • 是一种不稳定的排序方法

8.3 交换排序

8.3.1 冒泡排序

• 基本思想：每趟不断将记录两两比较，并按“前小后大”规则交换

1
2
3
4
5
6
7
8
9
10
11

void bubble_sort(SqList &L){
    int m,j,i; RedType x;
    for(m=1;m<=n-1;m++){
        for(j=1j=n-m;j++)
            if(L.r[j].key>L.r[j+1].key){
                x=L.r[j];
                L.r[j]=L.r[j+1];
                r[j+1]=x
            }
    }
}

• 改进的冒泡排序算法

  1 2 3 4 5 6 7 8 9 10 11 12 13

  void bubble_sort(SqList &L){ int m,j,i,flag=1; RedType x; for(m=1;m<=n-1&&flag==1;m++){//用flag作为是否有交换的标记 flag=0； for(j=1j=n-m;j++) if(L.r[j].key>L.r[j+1].key){ flag=1 //若发生交换，flag置为1 x=L.r[j]; L.r[j]=L.r[j+1]; r[j+1]=x } } }

• 冒泡排序算法评价

  • 冒泡排序最好时间复杂度是$O(n)$
  • 冒泡排序最坏时间复杂度为$(n^2)$
  • 冒泡排序平均时间复杂度为$O(n^2)$
  • 冒泡排序算法中增加一个辅助空间temp，辅助空间为$S(n)=O(1)$
  • 冒泡排序是稳定的

8.3.2 快速排序

• 基本思想

  • 任取一个元素为中心
  • 所有比他小的元素一律前放，比他大的后放，形成左右两个子表
  • 对各子表重新选择中心元素并依此规则调整
  • 知道每个子表的元素只剩一个

• 快速排序演示

  

• 算法图解：

  

• 排序算法：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  int partition(SqList &L,int low,int high){ L.r[0]=L.r[low];//用子表的第一个记录做枢轴记录 pivotkey=L.r[low].key;//枢轴记录关键字保存在pivotkey中 while(low<high){//从表的两端交替地向中间扫描 while(low<high&&L.[high].key>=pivotkey)--high; L.r[low]=L.r[high];//将比枢轴记录小的移动到低端 while(low<high&&L.[low].key>=pivotkey)++low; L.r[high]=L.r[low];//将比枢轴记录大的移动到高端 } L.r[low]=L.r[0];//枢轴记录到位 return low;//返回枢轴记录 } void QSort(SqList &L,int low,int high){ if(low<high){ pivotloc=Partition(L,low,high);//将L.r[low,high]一分为二。pivotloc是枢轴记录 QSort(L,low,pivotloc-1);//对左子表递归排序 QSort(L,pivotloc+1,high);//对右子表递归排序 } } void QuickSort(SqList &L){ QSort(L,1,L.length);//对顺序表L做快速排序 }

• 快速排序算法分析：

  • 时间复杂度

    • 平均计算时间是$O(nlog_2n)$
    • 实验表明快速排序是我们所讨论的所有内排序方法中最好的一个。

  • 空间复杂度

    • 快速排序不是原地排序
    • 平均情况下：需要$O(logn)$的栈空间
    • 最坏情况下：栈空间可达$O(n)$

  • 快速排序不适于队原本有序或基本有序的记录序列进行排序

8.4 选择排序

8.4.1 简单选择排序

• 基本思想：

  • 在待排序的数据中选出最大(小)的元素放在其最终的位置。

  

• 算法代码

  1 2 3 4 5 6 7 8 9 10 11 12

  void SelectSort(SqList &K){ for(i=1;i<L.length;++i){ k=i; for(j=i+1;j<=L.length;j++) if(L.r[j].key<L.r[k].key)k=j;//记录最小值位置 if(k!=i){ x=L.r[i]; L.r[i]=L.r[k]; L.r[k]=x; } } }

• 算法分析

  • 时间复杂度：$O(n^2)$
  • 空间复杂度：$O(1)$

• 简单选择排序是不稳定排序

8.2.2 堆排序

• 若有n个元素${a_1,a_2,……,a_n}$满足
  $$
  \left{
  \begin{array}{l}
  a_i<=a_{2i}\
  a_i<=a_{2i+1}\
  \end{array}
  \right.
  \quad\text{或者}\quad
  \begin{cases}
  a_i>=a_{2i}\
  a_i>=a_{2i+1}\
  \end{cases}
  $$

  • 则分别称该序列为小根堆和大根堆。

  • 从堆 定义可以看出，堆实质是满足如下性质的完全二叉树：二叉树中任一非叶子结点均小于(大于)它的孩子结点

• 若在输出堆顶的最小值 (最大值) 后，使得剩余n-1个元素的序列重又建成一个堆，则得到n个元素的次小值 (次大值) …如此反复，便能得到一个有序序列，这个过程称之为堆排序。

• 堆的调整

  • 小根堆
    1. 输出堆顶元素之后，以堆中最后一个元素替代之
    2. .然后将根结点值与左、右子树的根结点值进行比较，并与其中小者进行交换，
    3. 重复上述操作，直至叶子结点，将得到新的堆，称这个从堆顶至叶子的调整过程为“筛选“

• 算法描述

  1 2 3 4 5 6 7 8 9 10

  void HeapAdjust(elem R[],int s, int m){ rc=R[s]; for(j=2*S;J<=M;J*=2){//沿key较大的孩子结点向下筛选 if(j<m&&R[j]<R[j+1])++j;//j为key较大的记录的下标 if(rc>=R[j])break; R[s]=R[j]; s=j;//rc应插入在位置s上 } R[s]=rc;//插入 }

• 堆的建立

  • 单结点的二又树是堆;

  • 在完全二叉树中所有以叶子结点 (序号i > n/2) 为根的子树是堆这样，我们只需依次将以序号为$n/2，n/2-1，…,1$的结点为根的子树均调整为堆即可。

    从最后一个非叶子结点开始，以此向前调整

    1. 调整从第$n/2$个元素开始，将以该元素为根的二叉树调整为堆
    2. 将以序号为$n/2 - 1$的结点为根的二叉树调整为堆
    3. 再将以序号为$n/2 - 2$的结点为根的二又树调整为堆
    4. 再将以序号为$n/2 - 3$的结点为根的二又树调整为堆

  • 通过以上分析可知：

    • 若对一个无序序列建堆，然后输出根；重复该过程就可以由一个无序序列输出有序序列。
    • 实质上，堆排序就是利用完全二叉树中父结点与孩子结点之间的内在关系来排序的

• 堆排序算法

  1 2 3 4 5 6 7 8 9

  void HeapSort（elem R[]){//对R[1]到R[n]进行堆排序 int i; for(i=n/2;i>=1;i--) HeapAdjust(R,i,n);//建立初始堆 for(i=n;i>1;i--){//进行n-1趟排序 Swap(R[1],R[i]);//根与最后一个元素交换 HeapAdjust(R,1,i-1);//对R[1]到R[i-1]重新建堆 } }

• 算法分析

  • 初始化堆所需时间不超过O(n)
  • 堆排序在最坏情况下，其时间复杂度也为$O(nlog_2 n)$，这是堆排序的最大优点。无论待排序列中的记录是正序还是逆序排列，都不会使堆排序处于"最好”或"最坏“的状态。

8.5 归并排序

• 基本思想：

  • 将两个或两个以上的有序子序列“归并”为一个有序序列
  • 在内部排序中，通常采用的是2-路归并排序。

• 排序示例：

  

  • 整个归并排序仅需[$log_2 n $]趟

• 算法分析：

  • 时间效率：$O(nlog_2n)$
  • 空间效率：$O(n)$、
    • 因为需要一个与原始序列同样大小的辅助序列。这正是此算法的缺点
  • 具有稳定性

8.6 基数排序

• 基本思想：

  • 分配+收集
  • 也叫桶排序或箱排序: 设置若干个箱子，将关键字为k的记录放入第k个箱子，然后在按序号将非空的连接。

• 算法示例：

  

  • 将这组数据第一趟按照个位排，然后收集回来
  • 接下来按照十位来排，接下来收集回来
  • 最后按照百位来排，收集回来时，我们可以发现已经有序了

• 算法分析

  • 时间效率：O(k*(n+m))
    • k：关键字个数
    • m：关键字取值范围位m个值

  总结：

  

• 平衡二叉树的定义

  • 又称AVL树
  • 一棵平衡二叉树或者是空树，或者是具有以下性质的二叉排序树：
    • 左子树与右子树的高度之差的绝对值小于等于1；
    • 左子树和右子树也是平衡二叉排序树。

• 为了方便起见，给每个结点附加一个数字，给出该结点左子树与右子树的高度差。这个数字称为结点的平衡因子

  • 根据平衡二叉树的定义，平衡二叉树上所有结点的平衡因子只能是-1，0，或1

  • 对于一棵有n个结点的AVL树，其高度保持在$O(log_2n)$数量级，ASL也是保持在$O(log_2n)$量级

  • 当我们在一个平衡二叉树上插入结点时，可能导致失衡

    • 平衡调整的四种类型：

      

      LR型和RL型左右要看B和A哪个大

      • 调整原则：1. 降低高度 2. 保持二叉排序树性质

7.4 哈希表的查找

7.4.1 散列表的基本概念

• 基本思想：记录的存储位置与关键字之间存在对应关系

​对应关系——hash函数（hash:散列）

​Loc(i)=H(keyi)

• 散列表的查找
  • 根据散列函数H(key)=k
    • 查找key=9，直接访问H(9)=9号地址，若内容为9则成功
      若查不到，则返回一个特殊值，如空指针或空记录。
  • 优点：查找效率高
    缺点：空间效率低
• 散列函数和散列地址：在记录的存储位置p和其关键字key 之间建立一个确定的对应关系H, 使 p=H(key ), 称这个对应关系H为散列函数，p为散列地址。
• 散列表：一个有线连续的地址空间，用以存储按散列函数计算得到相应散列地址的数据记录。通常散列表的存储空间是一个一维数组，散列地址是数组的下标
• 冲突：不同的关键码映射到同一个散列地址
  • key1≠key2，但是H(key1)=H(key2)
  • 冲突是不可避免的，但可以减少
• 同义词：具有相同函数值的多个关键字

7.4.2 散列函数的构造方法

• 构造散列函数的考虑因素：

  • 散列表的长度
  • 关键字的长度
  • 关键字的分布情况
  • 计算散列函数所需的时间
  • 记录的查找频率

• 构造号的散列函数要遵循以下两条原则

  • 函数计算要简单，每一个关键字只能有一个散列地址与之对应
  • 函数的值域需在表长的范围内， 计算出的散列地址的分布应均匀，尽可能减少冲突。

• 根据数据元素的集合特性构造

  • 要求一: n个数据原仅占用n个地址虽然散列查找是以空间换时间，但仍希望散列的地址空间尽量小
  • 要求二:无论用什么方法存储，目的都是尽量均匀地存放元素，以避免冲突。

7.4.2.1 直接定址法

• Hash(key)=a.key+b
• 优点：以关键码key的某个线性函数值为散列地址，不会产生冲突
  缺点：要占用连续的地址空间，空间效率低

7.4.2.2 除留余数法

• Hash(key)=key mod p

  • 技巧：设：表长为m，取p<=m且为质数

    • 例：{15,23,27,38,53,61,70}

      散列函数：Hash(key)=key mod 7

      0	1	2	3	4	5	6
      70	15	23	38	53	61	27

7.4.3 处理冲突的方法

7.4.3.1 开放地址法（开地址法）

• 基本思想：有冲突时就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将数据元素存入

  • 列入：除留余数法：$H_i=(Hash(key)+d)mod \ m$
  • 常用方法：
    • 线性探测法 $d_i为1,2,……，m-1线性序列$
    • 二次探测法 $d_i为1^2,-1^2,2^2,-2^2……，q^2二次序列$
    • 伪随机探测法 $d_i为伪随机数序列$

• 例：关键码集为：{47，7，29，11，16，92，22，8，3}，散列表长m=11，散列函数为$Hash(key)=key \ mod \ 11$,拟用线性探测法处理冲突

  0	1	2	3	4	5	6	7	8	9	10
  11	22		47	92	16	3	7	29	8

  • 使用线性探测法解释：
  1. 47、7均是由散列函数得到的没有冲突的散列地址;
  2. Hash(29)=7，散列地址有冲突，需寻找下一个空的散列地址由$H=(Hash(29)+1) mod \ 11=8$，散列地址8为空，因此将29存入。
  3. 11、16、92均是由散列函数得到的没有冲突的散列地址:
  4. 另外，22、8、3同样在散列地址上有冲突，也是由H,找到空的散列地址的。
     • 平均查找长度ASL=(1+2 +1 +1 +1 +4 +1 +2 +2)/9=1.67

  0	1	2	3	4	5	6	7	8	9	10
  11	22	3	47	92	16		7	29	8

  • 使用二次探测法解释：
    • Hash(3)=3散列地址有冲突，由于$H_1=(Hash(3)+1^2)mod \ 11=4$，仍然冲突；
    • $H_2=(Hash(3)-1^2)mod \ 11=2$找到空的散列地址，存入

7.4.3.2 链地址法（拉链法）

• 基本思想：相同散列地址的记录链成一单链表

• m个散列地址就设m个单链表，然后用一个数组将m个单链表的表头指针存储起来，形成一个动态结构。

• 链地址法建立散列表的步骤

  • step1：取数据元素的关键字key，计算其散列函数值 (地址)。若该地址对应的链表为空，则将该元素插入此链表；否则执行Step2解决冲突。
  • step2：根据选择的冲突处理方法，计算关键字key的下一个存储地址若该地址对应的链表为不为空，则利用链表的前插法或后插法将该元素插入此链表

• 链地址法的优点：

  • 非同义词不会冲突，无“聚集”现象
    • 链表上的结点空间动态申请，更适合于表长不确定的情况

7.4.4 散列表的查找

• 给定值查找值k，查找过程：

1
2
3
4
5
6
7
8
9

graph TD
A[给定k值]==>B(计算H)
B==>C{此地址为空}
C-->|N|D{关键字==k}
C-->|Y|G[查找失败]
D-->|N|E[案处理冲突方法计算Hi]
D-->|Y|H[查找成功]
E-->C
F[竖向流程图]

• $ASL=(16+2+33+4+9)/12=2.5$

• 用连地址法处理冲突：

  

• $ASL=(16+24+3+4)/12=1.75$

• 使用平均查找长度ASL来衡量查找算法，ASL取决于

  • 散列函数
  • 处理冲突的方法
  • 散列表的装填因子α
    • $\Large α=\dfrac {表中填入的记录数}{哈希表的长度}$
    • α越大，表中的记录数越多，表越满，发生冲突的可能性就越大，查找时比较次数就越多
  • 无冲突时才能达到O(1)
  • $\large ASL≈1+\dfrac {α}{2}$
  • $\large ASL≈\dfrac {1}{2}(1+\dfrac{1}{1-α})$
  • $\large ASL≈-\dfrac{1}{α}ln(1-α)$

• 结论

  • 链地址法优于开地址法
  • 散列表技术具有很好的平均性能，优于一些传统的技术
  • 除留余数法作散列函数优于其它类型函数

7.1 查找的基本概念

• 查找表：是由同一类型的数据元素（或记录）构成的集合。由于“集合”中的数据元素之间存在着某种松散的关系，因此查找表是一种应用灵便的结构

  • 查找表分两类
    • 静态查找表：仅做“查询“{检索)操作的查找表
    • 动态查找表：做“插入”和“删除”操作的查找表

• 关键字：关键字是数据元素（或记录） 中某个数据项的值，用它可以标识一个数据元素（或记录）。

  • 主关键字：此关键字可以唯一地标识一个记录，则称此关键字为主关键字
  • 次关键字：用以识别若千记录的关键字为次关键字。

• 查找：根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素或（记录）

  • 若查找表中存在这样一个记录，则称 查找成功
    • 查找结果给出整个记录的信息，或指示该记录在查找表中的位置；
  • 否则称 查找不成功
    • 查找结果给出“空记录”或“空指针”
  • 查找经常进行的操作
    • 查询某个**“特定的”**数据元素是否在查找表中；
    • 检索某个**“特定的”**数据元素的各种属性；
    • 在查找表中插入一个数据元素；
    • 删除查找表中的某个数据元素；

• 查找算法的评价指标：

  • 关键字的平均比较次数，也称平均查找长度。

    $\LARGE ASL=\sum\limits_{i=1}^np_ic_i$ (关键字比较次数的期望值)

    • n：记录的个数
    • pi：查找第i个记录的概率（通常认为pi=1/n）
    • ci：找到第i个记录所需的比较次数

7.2 线性表的查找

7.2.1 顺序查找

• 应用范围：

  • 顺序表或线性链表表示的静态查找表
  • 表内元素之间无序

• 数据元素类型定义

  1 2 3 4

  typedef struct{ KeyType key; …… }ElemType;

• 顺序表的定义

  1 2 3 4 5

  typedef struct{//顺序结构表结构类型定义 ElemType *R;//表基址 int length;//表长 }SSTable; SSTable ST;//定义顺序表ST

• 顺序查找

  1 2 3 4 5

  int Search_seq(SSTable st,keytype key){ for(i=ST.length;i>=1;--i) if (ST.R[i].key==key)return i; return 0; }

  • 改进：把待查关键字key存入表头（”哨兵“）从后往前挨个比较，可免去查找过程中每一步都要检查是否查找完毕，加快速度

    1 2 3 4 5

    int search_seq(SSTable ST,KeyType key){ ST.R[0].key=key; for(i=ST.length;ST.R[i].key!=key;--i); return i; }

    • 比较次数与key位置有关：

      • 查找第i个元素，需要比较n-i+1次
      • 查找失败，需要比较n+1次

    • 时间复杂度O(n)

      • 查找成功时的平均查找长度，设表中各记录查找概率相等

        $ASL=（1+2+……+n）/n=\dfrac {n+1}{2}$

    • 空间复杂度：一个辅助空间——O(1)

• 顺序查找的特点

  • 优点：算法简单，逻辑次序无要求，且不同存储结构均适用
  • 缺点：ASL太长，时间效率太低

7.2.2 折半查找

• 算法步骤

  1. 设表长为n，low、high和mid分别指向待查元素所在区闻的上界，下界和中点，key为给定的要查找的值；
  2. 初始时，令low=1，high=n，
  3. 让k与mid指向的记录比较
     1. 若key==R[mid].KEY,查找成功
     2. 若key<R[mid].key,则high=mid-1
     3. 若key>R[mid].key,则low=mid-1

• 折半查找

  1 2 3 4 5 6 7 8 9 10 11 12

  int search_bIN(SSTable ST,KeyType key){ low=1;high=ST,length; while(low<=high){ mid=(low+high)/2; if(ST.R[mid].key==KEY)return mid; else if(key<ST.R[mid].key) high=mid-1; else low=mid+1; } return 0; }

  • 

  • $\large ASL=1/11*(11+22+43+44)=33/11=3$

  • 平均查找长度ASL（成功时）

    • $设表长为n=2^h-1,则h=log_2(n+1)，且表中每个记录的查找概率相等：p_i=1/n$

      $则\begin{align}
      ASL_{bs}&=\dfrac {1}{n} \sum\limits ^{n}_{j=1}j*2^{j-1}\
      &=\dfrac{n+1}{n}log_2(n+1)-1\
      &≈log_2(n+1)-1(n>50)\end{align}$

    • 折半查找的性能分析

      • 优点：效率比顺序查找高
      • 缺点：只适用于有序表，且限于顺序存储结构(对线性链表无效)

7.2.3 分块查找

• 分块查找 (Blocking Search) 又称索引顺序查找，这是一种性能介于顺序查找和折半查找之间的一种查找方法。

  1. 将表分成几块,且表或者有序，或者分块有序
  2. 建立“索引表”（每个结点含有最大关键字域和指向本块第一个结点的指针，且按关键字有序）。

• 查找过程：先确定待查记录所在块，再在块内查找

• 查找效率：$ASL=L_b+L_w$

• $\large ALS_{bs}≈log_2(\dfrac{n}{s}+1)+\dfrac {s}{2}$ s为每块内部的记录个数，n/s即块内数目

• 分块查找的特点

  • 优点：插入和删除比较容易
  • 缺点：要增加一个索引表的存储空间并对初始索引表进行排序运算
  • 适用情况：线性表既要快速查找又要经常动态变化

7.3 树表的查找

• 当表插入、删除操作频繁时，为了维护表的有序性，需要移动表中很多记录
  • 改用动态查找表——几种特殊的树
  • 表结构在查找过程中动态生成
  • 对于给定值key，若表中存在，则成功返回；否则，插入关键字等于key的记录
    • 二叉排序树
      平衡二叉树
      红黑树
      B-树
      B+树
      键树

7.3.1 二叉排序树

• 二叉排序树又称为二叉搜索树、二叉查找树

  • 二叉排序树或是空树，或是满足如下性质的二叉树；
    1. 若其左子树非空，则左子树上所有结点的值均小于根结点的值；
    2. 若其右子树非空，则右子树上所有结点的值均大于根结点的值；
    3. 其左右子树本身又各是一棵二叉排序树
  • 二叉排序树的性质
    • 中序遍历非空的二又排序树所得到的数据元素序列是一个按关键字排列的递增有序序列。

• 二叉排列树的操作——查找

  • 若查找的关键字等于根结点，成功

  • 否则

    • 小于根结点，查左子树
    • 大于根结点，查右子树

  • 在左右子树上的操作类似

• 算法描述

  1 2 3 4 5 6

  BSTree SearchBST (BSTree_T,KeyType key){ if ((!T)||key==T->data.key) return T; else if (key<T->data.key) return SearchBST(T->lchild,key); else return SearchBST (T->rchild,key); }

• 二叉排序树的查找分析

  • 含有n个结点的二叉排列树的平均查找长度和树的形态有关

    • 最好的情况：

      二叉排列树的形态和折半查找的判定树相似:

      $ASL=log_2(n+1)-1$
      $O(log_2n)$

    • 最坏情况

      二叉排序树的形态为单支树，树的深度为n，

      $ASL=\dfrac {n+1}{2}$

      $O(n)$

• 二叉排序树的操作——插入

  • 若二叉排序树为空，则插入结点作为根结点插入到空树中
  • 否则，继续在左右子树上查找
    • 树中已有，不再插入
    • 树中没有
      • 查找直至某个叶子结点的左子树或右子树为空为止，则插入结点应为该叶子结点的左孩子或右孩子
  • 插入的元素一定在叶子结点上

• 二叉排序树的操作——生成

  • 一个无序序列可通过构造二叉排序树而变成一个有序序列。构造树的过程就是对无序序列进行排序的过程。
  • 插入的结点均为叶子结点，故无序移动其他结点。相当于在有序序列上插入记录儿无需移动其他记录
  • 不同的插入次序的序列生成不同形态的二叉排序树

• 二叉排序树的操作——删除

  • 被删除的结点是叶子结点：直接删去该结点
  • 被删除的结点只有左子树或右子树，用其左子树或右子树替换它
  • 被删除的既有左子树，也有右子树，以其中序前驱值替换之（前驱是左子树中最大的结点），然后再删除该前驱结点
    • 也可以用其后继替换之（后继是右子树中最小结点），然后再删除该后继结点

7.3.2 平衡二叉树

• 平衡二叉树的定义

  • 又称AVL树
  • 一棵平衡二叉树或者是空树，或者是具有以下性质的二叉排序树：
    • 左子树与右子树的高度之差的绝对值小于等于1；
    • 左子树和右子树也是平衡二叉排序树。

• 为了方便起见，给每个结点附加一个数字，给出该结点左子树与右子树的高度差。这个数字称为结点的平衡因子

  • 根据平衡二叉树的定义，平衡二叉树上所有结点的平衡因子只能是-1，0，或1

  • 对于一棵有n个结点的AVL树，其高度保持在$O(log_2n)$数量级，ASL也是保持在$O(log_2n)$量级

  • 当我们在一个平衡二叉树上插入结点时，可能导致失衡

    • 平衡调整的四种类型：

      

      LR型和RL型左右要看B和A哪个大

      • 调整原则：1. 降低高度 2. 保持二叉排序树性质

7.4 哈希表的查找

7.4.1 散列表的基本概念

• 基本思想：记录的存储位置与关键字之间存在对应关系

​对应关系——hash函数（hash:散列）

​Loc(i)=H(keyi)

• 散列表的查找
  • 根据散列函数H(key)=k
    • 查找key=9，直接访问H(9)=9号地址，若内容为9则成功
      若查不到，则返回一个特殊值，如空指针或空记录。
  • 优点：查找效率高
    缺点：空间效率低
• 散列函数和散列地址：在记录的存储位置p和其关键字key 之间建立一个确定的对应关系H, 使 p=H(key ), 称这个对应关系H为散列函数，p为散列地址。
• 散列表：一个有线连续的地址空间，用以存储按散列函数计算得到相应散列地址的数据记录。通常散列表的存储空间是一个一维数组，散列地址是数组的下标
• 冲突：不同的关键码映射到同一个散列地址
  • key1≠key2，但是H(key1)=H(key2)
  • 冲突是不可避免的，但可以减少
• 同义词：具有相同函数值的多个关键字

7.4.2 散列函数的构造方法

• 构造散列函数的考虑因素：

  • 散列表的长度
  • 关键字的长度
  • 关键字的分布情况
  • 计算散列函数所需的时间
  • 记录的查找频率

• 构造号的散列函数要遵循以下两条原则

  • 函数计算要简单，每一个关键字只能有一个散列地址与之对应
  • 函数的值域需在表长的范围内， 计算出的散列地址的分布应均匀，尽可能减少冲突。

• 根据数据元素的集合特性构造

  • 要求一: n个数据原仅占用n个地址虽然散列查找是以空间换时间，但仍希望散列的地址空间尽量小
  • 要求二:无论用什么方法存储，目的都是尽量均匀地存放元素，以避免冲突。

7.4.2.1 直接定址法

• Hash(key)=a.key+b
• 优点：以关键码key的某个线性函数值为散列地址，不会产生冲突
  缺点：要占用连续的地址空间，空间效率低

7.4.2.2 除留余数法

• Hash(key)=key mod p

  • 技巧：设：表长为m，取p<=m且为质数

    • 例：{15,23,27,38,53,61,70}

      散列函数：Hash(key)=key mod 7

      0	1	2	3	4	5	6
      70	15	23	38	53	61	27

7.4.3 处理冲突的方法

7.4.3.1 开放地址法（开地址法）

• 基本思想：有冲突时就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将数据元素存入

  • 列入：除留余数法：$H_i=(Hash(key)+d)mod \ m$
  • 常用方法：
    • 线性探测法 $d_i为1,2,……，m-1线性序列$
    • 二次探测法 $d_i为1^2,-1^2,2^2,-2^2……，q^2二次序列$
    • 伪随机探测法 $d_i为伪随机数序列$

• 例：关键码集为：{47，7，29，11，16，92，22，8，3}，散列表长m=11，散列函数为$Hash(key)=key \ mod \ 11$,拟用线性探测法处理冲突

  0	1	2	3	4	5	6	7	8	9	10
  11	22		47	92	16	3	7	29	8

  • 使用线性探测法解释：
  1. 47、7均是由散列函数得到的没有冲突的散列地址;
  2. Hash(29)=7，散列地址有冲突，需寻找下一个空的散列地址由$H=(Hash(29)+1) mod \ 11=8$，散列地址8为空，因此将29存入。
  3. 11、16、92均是由散列函数得到的没有冲突的散列地址:
  4. 另外，22、8、3同样在散列地址上有冲突，也是由H,找到空的散列地址的。
     • 平均查找长度ASL=(1+2 +1 +1 +1 +4 +1 +2 +2)/9=1.67

  0	1	2	3	4	5	6	7	8	9	10
  11	22	3	47	92	16		7	29	8

  • 使用二次探测法解释：
    • Hash(3)=3散列地址有冲突，由于$H_1=(Hash(3)+1^2)mod \ 11=4$，仍然冲突；
    • $H_2=(Hash(3)-1^2)mod \ 11=2$找到空的散列地址，存入

7.4.3.2 链地址法（拉链法）

• 基本思想：相同散列地址的记录链成一单链表

• m个散列地址就设m个单链表，然后用一个数组将m个单链表的表头指针存储起来，形成一个动态结构。

• 链地址法建立散列表的步骤

  • step1：取数据元素的关键字key，计算其散列函数值 (地址)。若该地址对应的链表为空，则将该元素插入此链表；否则执行Step2解决冲突。
  • step2：根据选择的冲突处理方法，计算关键字key的下一个存储地址若该地址对应的链表为不为空，则利用链表的前插法或后插法将该元素插入此链表

• 链地址法的优点：

  • 非同义词不会冲突，无“聚集”现象
    • 链表上的结点空间动态申请，更适合于表长不确定的情况

7.4.4 散列表的查找

• 给定值查找值k，查找过程：

1
2
3
4
5
6
7
8
9

graph TD
A[给定k值]==>B(计算H)
B==>C{此地址为空}
C-->|N|D{关键字==k}
C-->|Y|G[查找失败]
D-->|N|E[案处理冲突方法计算Hi]
D-->|Y|H[查找成功]
E-->C
F[竖向流程图]

• $ASL=(16+2+33+4+9)/12=2.5$

• 用连地址法处理冲突：

  

• $ASL=(16+24+3+4)/12=1.75$

• 使用平均查找长度ASL来衡量查找算法，ASL取决于

  • 散列函数
  • 处理冲突的方法
  • 散列表的装填因子α
    • $\Large α=\dfrac {表中填入的记录数}{哈希表的长度}$
    • α越大，表中的记录数越多，表越满，发生冲突的可能性就越大，查找时比较次数就越多
  • 无冲突时才能达到O(1)
  • $\large ASL≈1+\dfrac {α}{2}$
  • $\large ASL≈\dfrac {1}{2}(1+\dfrac{1}{1-α})$
  • $\large ASL≈-\dfrac{1}{α}ln(1-α)$

• 结论

  • 链地址法优于开地址法
  • 散列表技术具有很好的平均性能，优于一些传统的技术
  • 除留余数法作散列函数优于其它类型函数

“程序=数据结构+算法”

​ ——图灵奖获得者、Pascal语言之父Nicklaus Wirth

课程内容：

[TOC]

1 绪论

1.1 数据结构研究内容

“计算机主要用于数值计算时， 一般要经过如下几个步骤：首先从具体问题抽象出数学模型，然后设计一个解此数学模型的算法，最后编写程序，进行测试、调试，直到解决问题。”

• 实例1.线性表

  

  • 操作==对象==：每位学生的信息（姓名，性别……）。

    操作==算法==：查询，插入，修改，删除等。

• 实例2.树结构

  

  • 操作==对象==：各种棋局状态，即描述棋盘的格局信息。

    操作==算法==：走棋，使棋局状态发生变化。

• 实例3.图结构

  

  • 操作==对象==：各地点及路的信息。

    操作==算法==：设置信号灯，求出各个可同时通行的路的集合。

“ 从上面三个实例可以看出，非数值计算问题的数学模型不再是数学方程，而是诸如==线性表、树和图的数据结构==。因此，简单地说，数据结构是一门研究==非数值计算==程序设计中的操作对象，以及这些对象之间的==关系==和==操作==的学科。“

1.2 基本概念和术语

1.2.1 数据、 数据元素、 数据项和数据对象

• 数据：各种符号的集合

  • 数值型的数据：整数、实数等
  • 非数值型的数据：文字、图像、图形、声音等

• 数据元素^a ：是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理

  学号	姓名	性别	出生日期	政治面貌
  0001	陆宇	男	1986/09/02	团员
  0002	李明	男	1985/12/25	党员
  0003	汤晓影	女	1986/03/26	团员

  其中第二行整体为一个数据元素^a ,其中包含了五个数据项

• 数据项：构成数据元素的不可分割的最小单位

  • 数据>数据元素>数据项
    • 例：学生表>个人记录>学号

• 数据对象：是性质相同的数据元素的集合，是数据的一个子集^b

  • 例：字母字符数据对象是集合C= {‘A’,‘B’, …，‘Z’,‘a’,‘b’, …，‘z’}

• 数据元素和数据对象

  • 数据元素与数据的关系：集合的个体

  • 数据对象和数据的关系：集合的子集

1.2.2 数据结构

• 数据结构

  1. 数据元素之间的逻辑关系，也称为逻辑结构
  2. 数据元素及其关系在计算机存储器中的表示（又称为映像），称为数据的物理结构或数据的存储结构
  3. 数据的运算和实现，即对数据元素可以施加的操作以及这些操作在相应的存储结构上的实现

  • 逻辑结构

    • 描述数据元素之间的逻辑关系
    • 与数据的存储无关，独立于计算机
    • 是从具体问题抽象出来的数学模型

  • 物理结构（存储结构）

    • 数据元素及其关系在计算机存储器中的结构（存储方式）
    • 是数据结构在计算机中的表示

  • 逻辑结构与存储结构的关系

    • 存储结构是逻辑关系的映象与元素本身的映象
    • 逻辑结构是数据结构的抽象，存储结构是数据结构的实现
    • 两者综合起来建立了数据元素之间的结构关系

  • 逻辑结构的种类

    • 划分方法一——两类结构

      • （1）==线性结构== ：有且仅有一个开始和一个终端节点，并且所有结点都最多只有一个直接前趋和一个直接后继

        例如：线性表、栈、队列、串

      • （2）==非线性结构==：一个节点可能有多个直接前驱和直接后继

        例如：树、图

    • 划分方法二——四类基本逻辑结构

      • （1）==集合结构==：数据元素之间除了 属于同一集合的关系外，别无任何其他关系。

        例如：确定一名学生是否为班级成员， 只需将班级看做一个集合结构。

      • （2）==线性结构===结构中的数据元素之间存在着一对一的线性关系。

        例如：将学生信息数据按照其入学报到的时间先后顺序进行排列，将组成一个线性结构

      • （3）==树形结构==：结构中的数据元素之间存在着一对多的层次**关系。

        例如：在班级的管理体系中，班长管理多个组长，每位组

        长管理多名组员，从而构成树形结构。

      • （4）==图状结构或网状结构==：结构中的数据元素之间存在着多对多的任意关系。

        例如：多位同学之间的朋友关系， 任何两位同学都可以是朋友，从而构成图状结构或网状结构。

  • 存储结构的种类

    • 四种基本的存储结构：

      • 顺序存储结构：用一组连续的存储单元依次存储数据元素，数据元素之间的逻辑关系由元素的存储位置来表示。

        在C语言中用数组来实现。

      • 链式存储结构：用一组任意的存储单元存储数据元素，数据元素之间的逻辑关系用指针来表示。

        在C语言中用指针来实现。关于“指针”的痛苦回忆浮现出来力。:cry:

      • 索引存储结构：存储结点信息的同时，还建立附加的索引表

        例如：通讯录

      • 散列存储结构：根据结点的关键字直接计算出该结点的存储地址

1.2.3 数据类型和抽象数据类型

• 数据类型：在使用高级程序设计语言编写程序时，必须对程序中出现的每个变量.常量或表达式，明确说明它们所属的数据类型^c。

  • 例如C语言中：
    • 提供int，char, float, double等基本数据类型
    • 数组、结构、共用体、枚举 等构造数据类型
    • 还有指针、空(void)类型
    • 用户也可用typedef 自己定义数据类型
  • 一些最基本数据结构可以用数据类型来实现，如数组、字符串等;
  • 而另一些常用的数据结构，如栈、队列、树、图等，不能直接用数据类型来表示。
  • 数值类型的作用
    • 约束变量或常量的取值范围
    • 约束变量或常量的操作

• 抽象数据类型:是指一个数学模型以及定义在此数学模型上的一组操作。

  • 由用户定义，从问题抽象出数据模型（逻辑结构）

  • 还包括定义在数据模型上的一组抽象运算（相关操作）

  • 不考虑计算机内的具体存储结构与运算的具体实现算法

  • 抽象数据类型的形式定义：

    • ADT抽象数据类型名{

      数据对象：<数据对象的定义>

      数据关系：<数据关系的定义>

      基本操作：<基本操作的定义>

      }ADT抽象数据类型名

      • 其中：

      1. 数据对象、数据关系的定义用伪代码描述

      2. 基本操作的定义格式为：

         基本操作名（参数表）

         初始条件：<初始条件描述>

         操作结果：<操作结果描述>

         基本操作定义格式说明：

         参数表：

         1. 赋值参数 只为操作提供输入值
         2. 引用参数 以&打头，除可提供输入值外，还将返回操作结果

         初始条件：描述操作执行之前数据结构和参数应满足的条件，若不满足则操作失败，并返回相应出错信息。若初始条件为空，则省略之

         操作结果：说明操作正常完成后，数据结构的变化情况和应返回的结果。

         ADT大致结构：

      1 2 3 4 5 6 7 8 9 10 11 12

      ADT 抽象数据名{ Data 数据对象的定义 数据元素之间的逻辑关系的定义 Operation 操作1 初始条件 操作结果描述 操作2 …… 操作n }ADT 抽象数据类型名

      • Circle的定义

      1 2 3 4 5 6 7 8 9 10 11 12 13 14

      ADT Circle{ 数据对象：D={r,x,y|rxy均为实数} 数据关系：R={<r,x,y>|r是半径，<x,y>是圆心坐标} 基本操作： Circle(&C,r,x,y) 操作结果：构造一个圆 double Area(C) 初始条件：圆已存在 操作结果：计算面积 double Circumference(C) 初始条件：圆已存在 操作结果：计算周长 …… }ADT Cicle

      • 复数的定义

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

      ADT Complex{ 数据对象：D = {r1,r2|r1,r2都是实数} 数据关系：S = { <r1,r2>|r1是实部，r2是虚部} 基本操作： assign (&C,v1,v2) 操作结果：构造复数Z，其实部和虚部，分别赋以参数V1,V2值 destroy(&C) 操作结果：复数Z被销毁 getreal(C,&realPart) 初始条件：复数已存在 操作结果：用realpart返回复数Z的实部值。 getlmag(C,&lmagPart) 初始条件：复数已存在 操作结果：用magPart返回复数Z的虚部值。 add(C1,C2,&sum) 初始条件：Z1,Z2是复数 操作结果：sum返回两个复数Z1，Z2的和 }ADT Circle

    • 以上代码均为类C语言作为描述工具

1.3 抽象数据类型的表示与实现

​以下给出一个具体的实现过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include<stdio.h>
typedef struct complex{//typedef起别名的，定义一个结构体变量struct[结构体名]结构体变量名：用[struct[结构体名]等价于int
    float realpart;//实部
    float imagepart;//虚部
}complex;//typedef关键字把struct complex 起了个名字叫complex]
complex assign(float real,float image){//构造复数
    complex c;
    c.realpart=real;
    c.imagepart=image;
    return c;
}
float getreal(complex c){//取复数实部
    return c.realpart;
}
float getimage(complex c){//取复数虚部
    return c.imagepart;
}
complex Add(complex c1,complex c2){//求两复数c1与c2的和sum
    complex sum;
    sum.realpart=c1.realpart+c2.realpart;
    sum.imagepart=c1.imagepart+c2.imagepart;
    return sum;
}
int main(){//主函数
    complex c1,c2,c3;
    c1=assign(1.0,2.0);
    c2=assign(3.0,4.0);
    c3=Add(c1,c2);
    printf("c1:%.2f+%.2fi\n",c1.realpart,c1.imagepart);
    printf("c1:%.2f+%.2fi\n",c2.realpart,c2.imagepart);
    printf("c1与c2的和为:%.2f+%.2fi\n",Add(c1,c2).realpart,Add(c1,c2).imagepart);
}

1.4 算法和算法分析

• 算法；对特定问题求解方法和步骤的一种描述，它是指令的有限序列。其中每个指令表示一个或多个操作。

• 算法的描述：

  1. 自然语言：英语、中文
  2. 流程图：传统流程图、NS流程图 // 软件工程没白学
  3. 伪代码：类语言：类C语言
  4. 程序代码：C语言程序，JAVA语言程序

• 算法与程序：

  • 算法是解决问题的一种方法或一个过程，考虑如何将输入转换成输出，一个问题可以有多个算法。

  • 程序是用某种程序设计语言对算法的具体实现。

    程序=数据结构+算法

1.4.1 算法特性

1. 有穷性：算法总在有穷步之后结束，且每一步在有穷时间内完成。
2. 确定性：每个指令有确切的含义，没有二义性，在任何条件下，只有唯一的一条执行路径，即对于相同的输入只能得到相同的输出。
3. 可行性：算法是可执行的，算法描述的操作可以通过已经实现的基本操作执行有限次来实现。
4. 输入：一个算法有零个或多个输入。
5. 输出：一个算法有一个或多个输出。

1.4.2 算法设计的要求

1. 正确性：
   1. 程序中不含语法错误。
   2. 程序对于几组输入数据能够得出满足要求的结果。
   3. 程序对于精心选择的、典型、苛刻且带有刁难性的几组输入数据能够得出满足要求的结果。
   4. 程序对于一切合法的输入数据都能得出满足要求的结。
2. 可读性：主要为了人的阅读和交流，其次才是为计算机的执行，因此算法要易于人理解。
3. 健壮性：指当输入非法数据时，算法算法恰当的做出反应或进行相应处理，而不是产生莫名其妙的输出结果。
4. 高效性：花费尽量少的时间和尽量地的存储需求。

1.4.3 算法的时间复杂度

• 算法效率以下两个方面来考虑：

  1. 时间效率：指的是算法所耗费的时间。
  2. 空间效率，值算法执行过程中所耗费的存储空间。
     • 时间效率和空间效率有时是矛盾的。

• 时间效率的度量：

  • 事后统计：将算法实现，测算其时间和空间开销。

    • 缺点：编写程序实现算法将花费较多时间与精力，所得实验结果依赖于计算机的软硬件等环境因素，掩盖算法本身的优劣。

  • 事前分析：对算法所消耗资源的一种估算方法。算法运行时间=一个简单操作*简单操作次数

    • 为了方便比较不同算法的时间效率，我们仅比较他们的数量级

1
2
3
4
5
6
7

for(i=1;i<=n;i++)//n+1次
    for(j+1;j<=n;j++){//n(n+1)次
        c[1][j]=0;//n*n次
        for(k=0:k<n:k++)//n*n*(n+1)次
            c[i][j]=c[i][j]+a[i][k]*b[k][j];//n*n*n次
    }

• 对于求解矩阵相乘问题，算法耗费时间：

  $\large T(n)={2n^3}+{3n^2}+2n+1$

  ​$n→∞$时，$T(n)/n3→2$,这表示n充分大时，$T(n)与n^3$是同阶或同数量级，引入大“O”记号，则T(n)可记作：

  • ​$\large T(n)=O(n^3)$

  • 原公式： $\large T(n)=O(f(n))$

• 分析算法时间复杂度的基本方法
  1. 找出语句频度最大的那条语句作为基本语句
  2. 计算基本语句的拼读得到问题规模$n$的某个函数$f(n)$
  3. 取其数量级用符号“$O$”表示

1
2
3
4
5
6

x=0;y=0;
for(int k=0;k<n;k++)//n+1次（这里是判断次数，所以要加一）
    x++;//n次(这里是执行次数，所以不用加一)
for(int i=0;i<n:i++)//n+1次
    for(int j=0;j<n;j++)//n*(n+1)次
        y++;//n*n次

• $\large f(n)=n(n+1)$ $\large T(n)=O(n^2)$
  • 可以直接看执行次数最多的语句，比如嵌套最深的语句

1
2
3
4

for(i=1:i<=n:i++)
    for(j+!;j<+i:j++)
        for(k=1;k<=j:k++)
            x=x+1

• 语句频度=$\large\sum\limits_{i=1}^n\sum\limits_{j=1}^n\sum\limits_{k=1}^n=\sum\limits_{i=1}^n\sum\limits_{j=1}^nj=\sum\limits_{i=1}^n\dfrac{i(i+1)}{2}=\dfrac{1}{2}(\sum\limits_{i=1}^ni^2+\sum\limits_{i=1}^ni)=v$

  • 公式第一步是第三层嵌套，执行$\large j$次（$\large j$个1的和）
    • 公式第二步是求和公式$\large j$看做一个变量，从$\large j=1$到$\large i$一个等差数列求和直接套公式
      • 公式第三步一个平方和累加公式^d一个累加公式[^e]，轻易可得出结果
        • 直接抓大放小，可得$T(N)=O(n^3)$

• 分析以下程序段的时间复杂度

  1 2 3

  i=1; while(i<=n) i=i*2;

  关键是找出来执行次数x与n的关系，并表示成n的函数

  假设语句2执行x次，由循环条件$i<=n,所以2^x=n 所以x<=log_2n$

  即$f(n)<=loglog_2n$,取最大值$f(n)=log_2n$

1.4.4 算法的空间复杂度

• 空间复杂度：算法所需存储空间的度量
  • 记作:$\large S(n)=O(f(n))$

算法一：

1
2
3
4
5

for(i=0;i<=n/2;i++){
    t=a[i];
    a[i]=a[n-i-1];
    a[n-i-1]=t;
}

算法二：

1
2
3
4

for(i=0;i<=n;i++)
    b[i]=a[n-i-1];
for(i=0;i<=n;i++)
    a[i]=b[i];

算法一：$\large S(n)=O(1)$ 原地工作

算法二：$\large S(n)=O(n)$

[^e]: $\large \sum\limits_{k=1}^nK=\dfrac{n(n+1)}{2}$​​

1.5 小结

1. 数据结构是一门研究非数值计算程序设计中操作对象， 以及这些对象之间的关系和操作。

2. 数据结构包括两个方面的内容：数据的逻辑结构和存储结构。同一逻辑结构采用不同的存储方法可以得到不同的存储结构。

   1. 逻辑结构是从具体问题抽象出来的数学模型，从逻辑关系上描述数据，它与数据的存储无关。根据数据元素之间关系的不同特性， 通常有四类基本逻辑结构：集合结构、线性结构、树形结构和图状结构。
   2. 存储结构是逻辑结构在计算机中的存储表示，有两类存储结构：顺序存储结构和链式存储结构。

3. 抽象数据类型是指由用户定义的、表示应用问题的数学模型 ， 以及定义在这个模型上的一组操作的总称， 具体包括三部分：数据对象、数据对象上关系的集合， 以及对数据对象的基本操作的集合。

4. 算法是为了解决某类问题而规定的一个有限长的操作序列。算法具有五个特性：有穷性、确定性、可行性、输入和输出。一个算法的优劣应该从以下四方面来评价：正确性、可读性、健壮性和高效性。

5. 算法分析的两个主要方面是分析算法的时间复杂度和空间复杂度， 以考察算法的时间和空间效率。一般情况下， 鉴于运算空间较为充足， 故将算法的时间复杂度作为分析的重点。算法执行时间的数量级称为算法的渐近时间复杂度，$T(n) = 0(f(n) )$, 它表示随着问题规模n的增大，算法执行时间的增长率和.f(n)的增长率相同， 简称时间复杂度。

2 线性表

“以下四章为线性结构相关的知识，同时本章是整个课程的重点与核心内容，也是其他后续章节的重要基础。”

2.1 线性表的定义和特点

线性表是具有相同特性的数据元素的一个有限序列
$\large (a1,a2,a3,……a_i,a_{i+1},……,a_n)$ 也就是说数组就是线性表咯

其中数据元素的个数n定义为表的长度。

• 当n=0时称为空表。

• 将非空的线性表记作(a1,a2……，an)

  

可以看出线性表的逻辑特征是：

1. 有且仅有一个开始结点$a1$，他没有直接前驱，而仅有一个直接后继$a2$。
2. 有且仅有一个终端结点$a_n$，他没有直接前驱，而仅有一个直接前驱$a{n-1}$。
3. 其余内部结点都有且仅有一个直接前驱和一个直接后继。

2.2 案例引入

2.2.1 一元多项式的运算

$\large P_n(x)=p_0+p_1x+p_2x^{2}+……+p_nx^n$ $\large Q_n(x)=q_0+q_1x+q_2x^{2}+……+q_nx^n$

• 其中$\large p_x和\large q_x$是系数
  • 那么两个多项式相加的结果$R_n(x)=P_n(x)+Q_m(x)$可用线性表R表示：
    • $\large R=(p_0+q_0,p1+q1,p2+q2+……+p_n+q_n)$

2.2.2 稀疏多项式的运算

$\large S(x)=1+3x^{10000}+2x^{20000}$

• 仅记录系数不为零的系数即可，这样可以大大节省空间。

​线性表A：(7,0)、(3,1)、(9,8)、(5,7)

​线性表B：(8,1)、(22,7)、(-9,8)

• 创建一个新数组C
• 分别从头比较A、B的每一项 PS：就是相当于走一遍一元多项式运算的步骤
  • 指数相同：对应系数相加，若其和不为零，则在C中增加一个新项
  • 指数不相同：则将指数较小的项复制到C中
  • 一个线性表添加完后，将另一个线性表剩余项依次复制到C中即可

• 顺序结构存在的问题
  1. 存储空间分配不灵活
  2. 运算的空间复杂度高
• 由此引出了链式存储结构
• 
  • 不需要额外的操作空间

2.2.3 图书信息管理系统

• 将图书表抽象为线性表
• 表中每本图书抽象线性表中数据元素
• 具体实现，学完这一章就会了，暂时按下不表

总结：

1. 线性表中数据元素的类型可以为简单类型，也可以为复杂类型。
2. 许多实际应用问题所涉及的基本操作有很大相似性，不应为每个具体应用单独编写一个程序。
3. 从具体应用中抽象出共性的逻辑结构和基本操作（抽象数据类型），然后实现其存储结构和基本操作。

2.3 线性表的类型定义

• 抽象数据类型线性表定义如下：

PS: List是线性表的英文名

• 基本操作：
  • InitList(&L) (Initialization List)
    操作结果：构造一个空的线性表L。
  • DestroyList(&L)
    初始条件:线性表L已存在。
    操作结果：将L重置为空表。
  • ListEmpty(L)
    初始条件：线性表L已存在。
    操作结果：若L为空表， 则返回true, 否则返回false。
  • ListLength(L)
    初始条件：线性表L已存在。
    操作结果：返回L中数据元素个数。
  • GetElem(L,i,&e)
    初始条件：线性表L巳存在，且1:,s;i:os;ListLength(L)。
    操作结果：用e返回L中第1个数据元素的值。
  • LocateElem(L,e)
    初始条件：线性表L已存在
    操作结果：返回L中第1个 值与e相同的元素在 L中的位置 。若这样的数据元素不存在 ， 则返回值为0。
  • PriorElem(r,cur_e,&pre_e)
    初始条件：线性表L已存在。
    操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回其前驱，否则操作失败，pre_e无定义。
  • NextElem(L,cur_e,&next_e)
    初始条件：线性表L已存在。
    操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回其后继，否则操作失败，next_e无定义。
  • Listinsert(&L,i,e)
    初始条件：线性表L已存在，且1:,s;i:os;ListLength (L) +l。
    操作结果：在 L中第1个位置之前插入新的数据元素 e, L的长度加1。
  • ListDelete(&L,i)
    初始条件：线性表L已存在且非空 ，且l:os;i:os;ListLength(L)。
    操作结果：删除L的第1个数据元素，L的长度减1。
  • TraverseList(L)
    初始条件：线性表L已存在
    操作结果：对线性表L进行遍历，在遍历过程中对 L的每个结点访问一次。

2.4 线性表的顺序表示和实现

2.4.1 线性表的顺序存储表示

• 线性表的顺序表示又称为顺序存储结构或顺序映像
  • 顺序存储定义：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构

线性表的第一个数据元素$a_1$的存储位置，称作线性表的起始位置或基地址

• 顺序表的特点：以物理位置相邻表示逻辑关系，任一元素均可随机存取。（优点）

  • PS：必须是占用一片连续的存储空间，中间不存在空的存储单元
  

• 线性表类型定义的模版：

1
2
3
4
5

#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量
typedef struct{
    ElemType elem[LIST_INIT_SIZE];//ElemType改成需要的元素类型，把他当做未知数x,根据题目需求而改变
    int length;//当前长度
}SqList;

• 例一：多项式的顺序存储结构类型定义

1
2
3
4
5
6
7
8
9
10

#define MAXSIZE 1000//多项式可能达到的最大长度
 typedef struct{//多项式非零项的定义
     float p;//系数
     int e;//指数
 }Ploynomial;

typedef struct{
    polynomial *elem;//存储空间的基地址
    int length;//多项式中当前项的个数
}SqList;//多项式的顺序存储结构类型为SqList

• 例二：图书表的顺序存储结构类型定义

1
2
3
4
5
6
7
8
9
10
11