C和数据结构北京大学(精)
数据结构与算法
数据结构与算法数据结构与算法是北京大学于2018年02月26日首次在中国大学MOOC开设的慕课课程，是国家精品在线开放课程。
该课程授课教师为张铭、陈斌、卢宗青、刘云淮、赵海燕、宋国杰、黄骏、邹磊、王腾蛟。
据2021年2月中国大学MOOC官网显示，该课程已开课4次。
数据结构与算法课程内容包括数据结构与抽象数据类型、算法特性及分类、算法效率与度量、线性结构、顺序表、链表、栈与队列、栈与递归、递归转非递归、字符串的存储结构、字符串运算的算法实现、字符串的快速模式匹配、二叉树的抽象数据类型、二叉树的搜索、二叉树的存储结构、树与二叉树的等价转换、树的抽象数据类型及树的遍历、树的链式存储结构、树的父指针表示法、树的顺序存储和K叉树、图的概念和抽象数据类型、图的存储结构、图的遍历、内排序、检索等内容。
课程性质:课程背景计算机是现代社会中用于解决问题的重要工具，支撑这个工具高效运转的就是其后的各种系统程序、应用程序。
数据结构，是抽象的表示数据的方式；算法，则是计算的一系列有效、通用的步骤。
算法与数据结构是程序设计中相辅相成的两个方面，是计算机学科的重要基石。
课程定位数据结构与算法是介绍基本数据结构以及相关的经典算法，强调问题-数据-算法的抽象过程，关注数据结构与算法的时间空间效率，培养学生编写出高效程序从而解决实际问题的综合能力的一门课程。
适应对象数据结构与算法适合计算机以及相关理工专业的本科生学习。
对于具有C语言结构化程序设计基础的学生，该课程第0章补充了一些面向对象的基本内容。
课程简介:数据结构与算法围绕着“算法+数据结构=程序”的思路，以问题求解为导向进行学习，运用问题抽象、数据抽象、算法抽象来分析问题，应用适当的数据结构和算法来设计和实现相应的程序。
在求解实际问题方面，该课程会学习到通过权衡时空和其他资源开销，利用数据结构来组织数据、设计高效的算法、完成高质量的程序以满足错综复杂的实际应用需要。
课程所学到的内容会被利用到计算机科学后续的各个课程中，如操作系统、软件工程、数据库概论、编译技术、计算机图形学、人机交互等。
北大数据结构课件,内部资料,精品
栈的应用递归到非递归的转换张 铭 北京大学信息学院1内容提要递归函数调用原理 机械的递归转换 优化后的非递归函数 非递归的二叉树周游2张铭 北京大学信息学院递归函数示例void exmp(int n, int& f) { int u1, u2; if (n<2) f = n+1; else { exmp((int)(n/2), u1); exmp((int)(n/4), u2); f = u1*u2; } } 张铭3北京大学信息学院数学公式fu (n) ={n +1当n < 2时fu ( ⎣n / 2 ⎦)* fu ( ⎣n / 4 ⎦)n ≥ 2时}4张铭 北京大学信息学院函数调用及返回的步骤调用– 保存调用信息（参数，返回地址） – 分配数据区（局部变量） – 控制转移给被调函数的入口返回– 保存返回信息 – 释放数据区 – 控制转移到上级函数（主调用函数）5张铭 北京大学信息学院函数执行过程图解二叉树图解 Exmp(7,&f) f=u1*u2=4u1=f=2 u2=f=2 Exmp(3,&f) Exmp(1,&f) f=u1*u2=2u1=f=2 Exmp(1,&f)张铭u2=f=1 Exmp(0,&f)6北京大学信息学院用栈模拟递归调用过程后调用，先返回(LIFO），所以用栈rd=1: n=1 f=1 u1=? u2=? f=2 rd=2: n=0 f=? u1=? u2=? f=? rd=2: n=1 f=? u1=2 u2=1 rd=1: n=3 f=? u1=? u2=? f=2 u1=? u2=? rd=3: n=7 f=? u1=? u2=? u1=2 u2=2张铭7北京大学信息学院递归过程的模拟假设 void recfunc(p1, p2, p3，…，pk, pk+1, …, pm) 是一个递归函数void是无返回值型的函数，如果有返回值， 我们可以把返回值转换为一个引用型参数 其中参数p1, p2, p3，…，pk是值传递，参 数pk+1, …, pm是引用传递。
2019年北京大学软件与微电子学院软件工程考研招生目录、参考书笔记资料
2019年招生信息：育明教育徐老师备注解析：1.2019年软件工程计划招收人数全日制60人，接收推免人数12人。
2.2019年软件工程只有1个方向，考的内容政治、英语一、数学一、867计算机基础综合。
3.软件工程从名称来看就知道是偏向于技术的专业，毕业后很多学生都能去微软，亚马逊，腾讯，百度，阿里巴巴这种国外和国内一流的软件公司。
北大软微这个平台是很好的，技术类的校友资源也很丰富，北大的学位基本保证找工作时候不会因为学校不好被刷掉简历，有些地方可是只要北清复交的哦，剩下的就看个人素质了，有了平台，个人专业知识、表达能力过硬，再找些相关实习，考些证书，找个好工作是不成问题的。
总的来说呢，技术类的就业不输给任何大学的计算机学硕。
读博方面，因为软微大部分是专硕，不能直博，读博只能申请或者考博，但软微作为北大的学院给教授的印象好，申博士的时候会优先考虑。
学院也有一些出国交流的机会，对于出国读博的同学有利。
推荐使用参考书：软件工程官方指定参考书：《数据结构》（C语言版）严蔚敏清华大学出版社《计算机操作系统》汤子瀛西安电子科技大学出版社《计算机网络》谢希仁电子工业出版社历年招生复试分数线：2016年：50，45，80，80，2902017年：50，45，80，80，3002018年：50，45，80，80，300北京大学软件与微电子学院2018年硕士研究生招生复试通知根据北京大学研究生院的工作安排，并结合我院的具体情况，现将2018年硕士研究生复试阶段的工作安排说明如下：一、复试时间、地点：复试时间：3月12日-16日；（具体时间请查收邮件）复试地点：软件与微电子学院（大兴校区）（地址：北京市大兴工业开发区金苑路24号）。
（具体地点见复试通知书）乘车路线：1、北京站：地铁二号线宣武门站换乘地铁四号线高米店南站下车，C 口出站，在金星西路打车或者乘兴11路到福苑东区站下车，北行300米路东。
2、北京西站：地铁九号线国家图书馆站换乘地铁四号线高米店南站下车，C口出站，在金星西路打车或者乘兴11路到福苑东区站下车，北行300米路东。
华文慕课数据结构与算法(上)(北京大学)章节测验答案
解忧书店 JieYouBookshop第二章单元测试1、(1分)以下哪种结构是逻辑结构，而与存储和运算无关：Which of the following structure is a logical structure regardless of the storage or algorithm:（There is only one correct answer）A、队列(queue)B、双链表(doubly linked list)C、数组(array)D、顺序表(Sequential list)答案： A2、(1分)计算运行下列程序段后m的值：Calculate the value of m after running the following program segmentn = 9; m = 0;for (i=1;i<=n;i++)for (j = 2*i; j<=n; j++)m=m+1;求m的值答案： 203、(1分)下列说法正确的是：Which options may be correct?（there are more than one correct answers）A、如果函数f(n)是O(g(n))，g(n)是O(h(n))，那么f(n)是O(h(n))【 if f(n) is O(g(n))，g(n) is O(h(n))，then f(n) is O(h(n))】B、如果函数f(n)是O(g(n))，g(n)是O(h(n))，那么f(n)+g(n)是O(h(n))【if f(n) is O(g(n))，g(n) is O(h(n))，so f(n)+g(n) is O(h(n))】C、如果a>b>1,logan是O(logbn)，但logbn不一定是O(logan)【if a>b>1,logan is O(logbn)，logbn may not be O(logan)】D、函数f(n)是O(g(n))，当常数a足够大时，一定有函数g(n)是O(af(n))【if f(n)是O(g(n))，When constant a is big enough ，there must be g(n) is O(af(n))】答案： A,B4、(1分)由大到小写出以下时间复杂度的序列：答案直接写标号，如：(1)(2)(3)(4)(5) （提示：系统基于字符匹配来判定答案，所以您的答案中不要出现空格）Write the following time complexity in descending sequence:Write down the answer labels such as (1)(2)(3)(4)(5). （Hint：This problem is judged by string matching, Please make sure your answer don't contain any blanks. ）RUX4%GXZNDD{IAQWTCSEEJG.png答案： (5)(1)(2)(4)(3)5、(1分)已知一个数组a的长度为n，求问下面这段代码的时间复杂度:An array of a, its length is known as n. Please answer the time complexity of the following code.（There are more than one answers.）for (i=0,length=1;i<n-1;i++){for (j = i+1;j<n && a[j-1]<=a[j];j++)if(length<j-i+1)length=j-i+1;}Screen Shot 2017-09-05 at 23.31.19.pngA、如图，A选项B、如图，B选项C、如图，C选项D、如图，D选项答案： A,B第三章单元测试1、(1分)下面关于线性表的叙述中，正确的是哪些？Which of the followings about linear list are correct?（There are more than one answers.）Select the answer that matchesA、线性表采用顺序存储，必须占用一片连续的存储单元。
2016北京大学计算机科学与技术(智能科学与技术)(信息科学技术学院)考研专业目录招生人数参考书目
更多资料请到易研官网 下载
棵哈夫曼树的是
A．24，10，5 和 24，10，7 B．24，10，5 和 24，12，7
C．24，10，10 和 24，14，11 D．24，10，5 和 24，14，6
4．现在有一颗无重复关键字的平衡二叉树（AVL 树）,对其进行中序遍历可得到
书名 《计算机组成原理》
作者
出版社
唐朔飞 编 著
高等教育出版社年
《计算机组成原理学习指导与习题解 答》
唐朔飞 编 著
高等教育出版社
《数据结构（c 语言版）》
严蔚敏、吴 清华大学出版社
伟民编著
《计算机组成原理》
白中英 主 科学出版社
更多资料请到易研官网 下载
学科专业基
2,0,2,9,3,4,2,8,2,3,8,4,5，若进程要访问的下一页的页号为 7，依据 LRU 算
法，应淘汰页的页号是（）
A．2 B．3 C．4 D．8
28．在系统内存中设置磁盘缓冲区的主要目的是（）
A．减少磁盘 I/O 次数
B．减少平均寻道时间
C．提高磁盘数据可靠性
更多资料请到易研官网 下载
（）
Ⅰ．S1 会限制用户申请资源的顺序
Ⅱ．S1 需要进行所需资源总量信息，而 S2 不需要
Ⅲ．S1 不会给可能导致死锁的进程分配资源，S2 会
A．仅Ⅰ Ⅱ B．仅Ⅱ Ⅲ C．仅Ⅰ Ⅲ D．Ⅰ Ⅱ Ⅲ
27 ． 系 统 为 某 进 程 分 配 4 个 页 框 ， 该 进 程 已 访 问 的 页 号 序 列 为
Ⅲ. 左规时可能引起阶码下溢
Ⅳ. 尾数溢出时结果不一定溢出
A．仅Ⅱ Ⅲ B．仅ⅠⅡⅣ C．仅ⅠⅢ Ⅳ D．ⅠⅡ Ⅲ Ⅳ
北大数据结构课讲义10
5
9.2.1 顺序查找
顺序表查找（Sequential Search）又称线性查找。
是一种最简单和最基本的查找方法。它从顺序表的一端 开始，依次将每个元素的关键字同给定值K进行比较，若某 个元素的关键字等于给定值K，则表明查找成功，返回该元 素所在的下标，若直到所有元素都比较完毕，仍找不到关 键字为K的元素，则表明查找失败，返回特定的值。
找成功时的平均查找长度（Average Search Length）。
n
ASL pici i 1
若查找每个数据元素的概率相等，则
1n
ASL ci
n i1
4
9.2 顺序表查找
顺序表 (Sequential List) 是指线性表的顺序存储结构。 ElemType A[MaxSize]; KeyType key;
28
9.4.4 散列表的运算
散列表的类型定义与所使用的冲突处理方法有关。 开放定址法
typedef ElemType hashlist1[HashMaxSize]; 链接法
typedef LNode* hashlist2[HashMaxSize];
（1）初始化散列表 （2）清空散列表 （3）向散列表中插入一元素 （4）从散列表中查找一元素 （5）从散列表中删除一元素
9
int Binsch (ElemType A[], int low, int high, KeyType K) {
int low=0, high=n-1; while (low<=high) {
int mid = (low+high)/2; if (K= =A[mid].key) return mid;
插入 K=31
北大数据结构课件,内部资料,精品
数据结构任课教员：张铭、赵海燕、冯梅萍、王腾蛟/mzhang/DS/北京大学信息科学与技术学院网络与信息系统研究所©版权所有，转载或翻印必究教学目的掌握常用的基本数据结构的ADT 及其应用学会合理地组织数据, 有效地表示数据, 有效地处理数据基本掌握算法的设计分析技术 提高程序设计的质量教学要求平时(考勤+作业)20％ 上机(+报告)30％期中20％期末30％诚信端正学习态度、调动学习兴趣提倡讨论，但严禁抄袭可以讨论思路，请同学看算法的逻辑问题和效率问题。
但要亲自动手实现。
发现抄袭，则抄袭者和被抄袭者本次作业或上机题计双倍倒扣分，即得-20分。
以后的作业题会得到重点检查。
严重的期评将给予不及格处理数据结构教学计划和要求按时提交作业，严禁抄袭所有书面作业和上机作业都必须在指定的期限内完成并提交一般周三交书面作业。
除非不可抗拒的客观原因，请严格按提交时间完成书面作业和上机作业。
例如，一个满分为10分的作业题，记分标准为：（1）准时提交，满分可达10分（个别加分）；（2）延迟3天之内提交，满分可达7分；（3）延迟7天之内提交，满分可达3分；（4）7天之后提交或不交，得分-5分。
（5）抄袭得–20分。
书面作业提交要求1) 写学号、名字2) 每次作业，都在作业本或电子稿的word文档中写上“我保证没有抄袭他人作业”的诚实保证。
否则，计零分或根据抄袭情况倒扣分。
3) 写算法分析、注释4) 算法中直接使用的函数、过程先写ADT，并说明函数功能、入口参数、出口参数5) 注意算法格式(层次嵌套、不同功能块之间留空)上机题提交要求上机作业提交时打一个zip包，学号+姓名+作业次数，如”00308096张宁1.zip”包中含有：1. readme.txt文件，把你的程序运行环境、编译运行步骤、程序功能等等简单说明一下。
2. 附加了诚实代码保证和足够注释的源程序以及相关的项目和资源文件。
例如，VC++中的.dsw, .dsp文件，rc目录中的图像资源文件；Jbuilder中的.jpr或.jpx文件，特殊的Java包等等。
第10章 搜索 数据结构(北师大)C++版
令
Δpi= ∑wj-∑wj
j=i+1
h
i-1
j=l
取最小值： Δpi=min{Δpj: l≤j≤h}
以ai为根， al+1,··,ai-1为左子树 ·· ··
右转：
65
p lc
13
38
将p作lc的右子结点
49
lc
13
65
10 10
p
38
左重加左——右转
结点p左重，还要加一个左结点 不平衡
右转：将p作lc的右子结点, 将lc的右子树接成p的左子树 p 38 lc lc
13 40 13
p
10
38
10
20 4 20 40
4
右重加右——左转
结点p右重，还要加一个右结点 不平衡
45 45
12 57
不 平 衡 8
平 衡
12
20
8
20
50
60
3
11
3
11
59
同一个数组的二叉排序树和二叉平衡树
20 30 80 40 10 60 50 70
49 20 49 30 13 65 10 49 30
80 27
40 13 10 97
20
40 13
49 60 13 65
80 27
60
50 50 97 70 49 70 49
以下序列中查找元素10的过程（比较4次） 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
北京大学数学科学学院考研参考书目汇总
北京大学数学科学学院考研参考书目汇总考试科目编号：01 数学分析 02 高等代数03 解析几何 04 实变函数05 复变函数 06 泛函分析07 常微分方程 08 偏微分方程09 微分几何 10 抽象代数11 拓扑学 12 概率论13 数理统计 14 数值分析15 数值代数 16 信号处理17 离散数学 18 数据结构与算法01 数学分析（ 150 分）考试参考书：1. 方企勤等，数学分析（一、二、三册）高教出版社。
2. 陈纪修、於崇华、金路，数学分析(上、下册)，高教出版社。
02 高等代数（ 100 分）考试参考书：1. 丘维声,高等代数(第二版) 上册、下册，高等教育出版社，2002年, 2003年。
高等代数学习指导书（上册），清华大学出版社，2005年。
高等代数学习指导书（下册），清华大学出版社，2009年。
2. 蓝以中，高等代数简明教程（上、下册），北京大学出版社，2003年（第一版第二次印刷）。
03 解析几何（ 50 分）考试参考书：1. 丘维声，解析几何（第二版），北京大学出版社，（其中第七章不考）。
2. 吴光磊，田畴，解析几何简明教程，高等教育出版社， 2003年。
04 实变函数（ 50 分）考试参考书：1. 周民强，实变函数论，北京大学出版社， 2001年。
05 复变函数（ 50 分）考试参考书：1. 方企勤，复变函数教程，北京大学出版社。
06 泛函分析（ 50 分）考试参考书：1. 张恭庆、林源渠，泛函分析讲义（上册），北京大学出版社。
07 常微分方程（ 50 分）考试参考书：1. 丁同仁、李承治，常微分方程教程，高等教育出版社。
2. 王高雄、周之铭、朱思铭、王寿松，常微分方程（第二版），高等教育出版社。
3. 叶彦谦，常微分方程讲义（第二版）人民教育出版社。
08 偏微分方程（ 50 分）考试参考书：1. 姜礼尚、陈亚浙，数学物理方程讲义（第二版），高等教育出版。
2. 周蜀林，偏微分方程，北京大学出版社。
北大数据结构课件,内部资料,精品
第三章字符串任课教员：张铭、赵海燕、冯梅萍、王腾蛟/mzhang/DS/北京大学信息科学与技术学院©版权所有，转载或翻印必究主要内容3.1 字符串抽象数据类型3.2 字符串的存储结构和类定义 3.3 字符串运算的算法实现3.4 字符串的模式匹配3.1字符串抽象数据类型3.1.1 基本概念3.1.2 String抽象数据类型3.1.1 基本概念字符串，由0个或多个字符的顺序排列所组成的复合数据结构，简称“串”。
串的长度：一个字符串所包含的字符个数。
空串：长度为零的串，它不包含任何字符内容。
3.1.1.1字符串常数和变量字符串常数例如："\n"字符串变量3.1.1.2 字符字符(char) ：组成字符串的基本单位。
在C和C＋＋中单字节（8 bits）采用ASCII码对128个符号（字符集charset）进行编码3.1.1.3 字符的编码顺序为了字符串间比较和运算的便利，字符编码表一般遵循约定俗成的“偏序编码规则”。
字符偏序：根据字符的自然含义，某些字符间两两可以比较次序。
其实大多数情况下就是字典序中文字符串有些特例，例如“笔划”序3.1.1.4 C++标准string标准字符串：将C++的<string.h>函数库作为字符串数据类型的方案。
例如：char S[M];串的结束标记：'\0''\0'是ASCII码中8位BIT全0码，又称为NULL符。
3.1.1.4 C++标准string(续)1. 串长函数int strlen(char*s);2. 串复制char *strcpy(char*s1, char*s2);3．串拼接char *strcat(char*s1, char *s2);4．串比较int strcmp(char*s1, char *s2);3.1.1.4 C++标准string(续)5．输入和输出函数6．定位函数char *strchr(char*s, char c); 7．右定位函数char *strrchr(char*s, char c);3.1.1.4 C++标准string(续)3.1.2 String抽象数据类型字符串类（class String）： 不采用char S[M]的形式而采用一种动态变长的存储结构。
数据结构(c语言版)第三版清华大学出版社习题参考答案
不管怎样，生活还是要继续向前走去。
有的时候伤害和失败不见得是一件坏事，它会让你变得更好，孤单和失落亦是如此。
每件事到最后一定会变成一件好事，只要你能够走到最后。
附录习题参考答案习题1参考答案1.1.选择题(1). A. (2). A. (3). A. (4). B.C. (5). A. (6). A. (7). C. (8). A. (9). B. (10.) A.1.2.填空题(1). 数据关系(2). 逻辑结构物理结构(3). 线性数据结构树型结构图结构(4). 顺序存储链式存储索引存储散列表（Hash）存储(5). 变量的取值范围操作的类别(6). 数据元素间的逻辑关系数据元素存储方式或者数据元素的物理关系(7). 关系网状结构树结构(8). 空间复杂度和时间复杂度(9). 空间时间(10). Ο(n)1.3 名词解释如下：数据：数据是信息的载体是计算机程序加工和处理的对象包括数值数据和非数值数据数据项：数据项指不可分割的、具有独立意义的最小数据单位数据项有时也称为字段或域数据元素：数据元素是数据的基本单位在计算机程序中通常作为一个整体进行考虑和处理一个数据元素可由若干个数据项组成数据逻辑结构：数据的逻辑结构就是指数据元素间的关系数据存储结构：数据的物理结构表示数据元素的存储方式或者数据元素的物理关系数据类型：是指变量的取值范围和所能够进行的操作的总和算法：是对特定问题求解步骤的一种描述是指令的有限序列1.4 语句的时间复杂度为：(1) Ο(n2)(2) Ο(n2)(3) Ο(n2)(4) Ο(n-1)(5) Ο(n3) 1.5 参考程序：main(){int XYZ；scanf("%d %d%d"&X&YZ)；if (X>=Y)if(X>=Z)if (Y>=Z) { printf("%d %d%d"XYZ);}else{ printf("%d %d%d"XZY);}else{ printf("%d %d%d"ZXY);}else if(Z>=X)if (Y>=Z) { printf("%d %d%d"YZX);}else{ printf("%d%d%d"ZYX);}else{ printf("%d%d%d"YXZ);}}1.6 参考程序：main(){int in;float xa[]p;printf("\nn=");scanf("%f"&n);printf("\nx=");scanf("%f"&x);for(i=0;i<=n;i++)scanf("%f "&a[i]);p=a[0];for(i=1;i<=n;i++){ p=p+a[i]*x;x=x*x;}printf("%f"p)'}习题2参考答案2.1选择题(1). C. (2). B. (3). B. (4). B. 5. D. 6. B. 7. B. 8. A. 9. A. 10. D.2.2.填空题(1). 有限序列(2). 顺序存储和链式存储(3). Ｏ(n) O(n)(4). n-i+1 n-i(5). 链式(6). 数据指针(7). 前驱后继(8). Ο(1) Ο(n)(9). s->next=p->next; p->next=s ;(10). s->next2.3. 解题思路：将顺序表A中的元素输入数组a若数组a中元素个数为n将下标为012...（n-1）/2的元素依次与下标为nn-1...（n-1）/2的元素交换输出数组a的元素参考程序如下：main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<=n-1;i++)scanf("%f "&a[i]);for(i=0;i<=(n-1)/2;i++){ t=a[i]; a[i] =a[n-1-i]; a[n-1-i]=t;} for(i=0;i<=n-1;i++)printf("%f"a[i]);}2.4 算法与程序：main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]);for(i=1;i<n;i++)if(a[i]>a[0]{ t=a[i]; a[i] =a[0]; a[0]=t;} printf("%f"a[0]);for(i=2;i<n;i++)if(a[i]>a[1]{ t=a[i]; a[i] =a[1]; a[1]=t;} printf("%f"a[0]);}2.5 算法与程序：main(){int ijkn;float xta[];printf("\nx=");scanf("%f"&x);printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]); // 输入线性表中的元素for (i=0; i<n; i++) { // 对线性表中的元素递增排序 k=i;for (j=i+1; j<n; j++) if (a[j]<a[k]) k=j;if (k<>j) {t=a[i];a[i]=a[k];a[k]=t;}}for(i=0;i<n;i++) // 在线性表中找到合适的位置if(a[i]>x) break;for(k=n-1;k>=i;i--) // 移动线性表中元素然后插入元素xa[k+1]=a[k];a[i]=x;for(i=0;i<=n;i++) // 依次输出线性表中的元素printf("%f"a[i]);}2.6 算法思路：依次扫描A和B的元素比较A、B当前的元素的值将较小值的元素赋给C如此直到一个线性表扫描完毕最后将未扫描完顺序表中的余下部分赋给C即可C的容量要能够容纳A、B两个线性表相加的长度有序表的合并算法：void merge (SeqList ASeqList BSeqList *C){ int ijk；i=0；j=0；k=0；while ( i<=st && j<=st )if (A.data[i]<=B.data[j])C->data[k++]=A.data[i++]；elseC->data[k++]=B.data[j++]；while (i<=st )C->data[k++]= A.data[i++]；while (j<=st )C->data[k++]=B.data[j++]；C->last=k-1；}2.7 算法思路：依次将A中的元素和B的元素比较将值相等的元素赋给C如此直到线性表扫描完毕线性表C就是所求递增有序线性表算法：void merge (SeqList ASeqList BSeqList *C){ int ijk；i=0；j=0；k=0；while ( i<=st)while（j<=st )if (A.data[i]=B.data[j])C->data[k++]=A.data[i++]；C->last=k-1；}习题3参考答案3.1.选择题(1). D (2). C (3). D (4). C (5). B (6). C (7). C (8). C (9). B (10).AB (11). D (12). B (13). D (14). C (15). C (16). D(17). D (18). C (19). C (20). C 3.2.填空题（1） FILOFIFO（2） -13 4 X * + 2 Y * 3 / -（3） stack.topstack.s[stack.top]=x（4） p>llink->rlink=p->rlinkp->rlink->llink=p->rlink（5） (R-F+M)%M（6） top1+1=top2（7） F==R（8） front==rear（9） front==(rear+1)%n（10） N-13.3 答：一般线性表使用数组来表示的线性表一般有插入、删除、读取等对于任意元素的操作而栈只是一种特殊的线性表栈只能在线性表的一端插入（称为入栈push）或者读取栈顶元素或者称为"弹出、出栈"(pop)3.4 答：相同点：栈和队列都是特殊的线性表只在端点处进行插入删除操作不同点：栈只在一端（栈顶）进行插入删除操作；队列在一端（top）删除一端(rear)插入3.5 答：可能序列有14种：ABCD; ACBD; ACDB; ABDC; ADCB; BACD; BADC; BCAD; BCDA; BDCA; CBAD; CBDA; CDBA; DCBA3.6 答：不能得到435612最先出栈的是4则按321的方式出不可能得到1在2前的序列可以得到135426按如下方式进行push(1)pop()push(2)push(3)pop()push(4)push(5)pop()pop()pop()push(6)pop()3.7 答：stack3.8 非递归:int vonvert (int noint a[]) //将十进制数转换为2进制存放在a[] 并返回位数{int r;SeStack s*p;P=&s;Init_stack(p);while(no){push(pno%2);no/=10;}r=0;while(!empty_stack(p)){pop(pa+r);r++;}return r;}递归算法:void convert(int no){if(no/2>0){Convert(no/2);Printf("%d"no%2);}elseprintf("%d"no);}3.9 参考程序：void view(SeStack s){SeStack *p; //假设栈元素为字符型char c;p=&s;while(!empty_stack(p)){c=pop(p);printf("%c"c);}printf("\n");}3.10 答：char3.11 参考程序：void out(linkqueue q){int e;while(q.rear !=q.front ){dequeue(qe);print(e); //打印}}习题4参考答案4.1 选择题：(1). A (2). D (3). C (4). C (5). B (6). B (7). D (8). A (9). B (10). D 4.2 填空题：（1）串长相等且对应位置字符相等（2）不含任何元素的串（3）所含字符均是空格所含空格数（4） 10（5） "hello boy"（6） 13（7） 1066（8）模式匹配（9）串中所含不同字符的个数（10） 364.3 StrLength (s)=14StrLength (t)=4SubStr( s87)=" STUDENT"SubStr(t21)="O"StrIndex(s"A")=3StrIndex (st)=0StrRep(s"STUDENT"q)=" I AM A WORKER"4.4 StrRep(s"Y""+");StrRep(s"+*""*Y");4.5 空串：不含任何字符；空格串：所含字符都是空格串变量和串常量:串常量在程序的执行过程中只能引用不能改变；串变量的值在程序执行过程中是可以改变和重新赋值的主串与子串：子串是主串的一个子集串变量的名字与串变量的值:串变量的名字表示串值的标识符4.6int EQUAl(ST){char *p*q;p=&S;q=&T;while(*p&&*q){if(*p!=*q)return *p-*q;p++;q++;}return *p-*q;}4.7(1)6*8*6=288(2)1000+47*6=1282(3)1000+(8+4)*8=1096(4)1000+(6*7+4)*8=13684.8习题5参考答案5.1 选择（1）C（2）B（3）C（4）B（5）C（6）D（7）C（8）C（9）B（10）C （11）B（12）C（13）C（14）C（15）C（16）B5.2 填空（1）1（2）1036；1040（3）2i（4） 1 ； n ; n-1 ; 2（5）2k-1；2k-1（6）ACDBGJKIHFE（7）p!=NULL（8）Huffman树（9）其第一个孩子; 下一个兄弟（10）先序遍历；中序遍历5.3叶子结点:C、F、G、L、I、M、K；非终端结点：A、B、D、E、J；各结点的度：结点： A B C D E F G L I J K M度： 4 3 0 1 2 0 0 0 0 1 0 0树深：45.4无序树形态如下：二叉树形态如下：5.5二叉链表如下:三叉链表如下:5.6先序遍历序列:ABDEHICFJG中序遍历序列:DBHEIAFJCG后序遍历序列:DHIEBJFGCA5.7(1) 先序序列和中序序列相同：空树或缺左子树的单支树；(2) 后序序列和中序序列相同：空树或缺右子树的单支树；(3) 先序序列和后序序列相同：空树或只有根结点的二叉树5.8这棵二叉树为:5.9先根遍历序列:ABFGLCDIEJMK后根遍历序列:FGLBCIDMJKEA层次遍历序列:ABCDEFGLIJKM5.10证明：设树中结点总数为n叶子结点数为n0则n=n0 + n1 + ...... + nm （1）再设树中分支数目为B则B=n1 + 2n2 + 3n3 + ...... + m nm （2）因为除根结点外每个结点均对应一个进入它的分支所以有n= B + 1 （3）将（1）和（2）代入（3）得n0 + n1 + ...... + nm = n1 + 2n2 + 3n3 + ...... + m nm + 1 从而可得叶子结点数为：n0 = n2 + 2n3 + ...... + (m-1)nm + 15.11由5.10结论得n0 = (k-1)nk + 1又由 n=n0 + nk得nk= n-n0代入上式得n0 = (k-1)（n-n0）+ 1叶子结点数为：n0 = n (k-1) / k5.12int NodeCount(BiTree T){ //计算结点总数if(T)if (T-> lchild==NULL )&&( T --> rchild==NULL )return 1;elsereturn NodeCount(T-> lchild ) +Node ( T --> rchild )+1; elsereturn 0;5.13void ExchangeLR(Bitree bt){/* 将bt所指二叉树中所有结点的左、右子树相互交换 */ if (bt && (bt->lchild || bt->rchild)) {bt->lchild<->bt->rchild;Exchange-lr(bt->lchild);Exchange-lr(bt->rchild);}}/* ExchangeLR */5.14int IsFullBitree(Bitree T){/* 是则返回1否则返回0*/Init_Queue(Q); /* 初始化队列*/flag=0;In_Queue(QT); /* 根指针入队列按层次遍历*/while(!Empty_Queue (Q)){Out_Queue(Qp);if(!p) flag=1; /* 若本次出队列的是空指针时则修改flag值为1若以后出队列的指针存在非空则可断定不是完全二叉树 */else if (flag) return 0; /*断定不是完全二叉树 */ else{In_Queue(Qp->lchild);In_Queue(Qp->rchild); /* 不管孩子是否为空都入队列*/}}/* while */return 1; /* 只有从某个孩子指针开始之后所有孩子指针都为空才可断定为完全二叉树*/}/* IsFullBitree */5.15转换的二叉树为：5.16对应的森林分别为：5.17typedef char elemtype;typedef struct{ elemtype data;int parent;} NodeType;(1) 求树中结点双亲的算法:int Parent(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标(根的双亲为-1 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) return t[i].parent; return -2;}/*Parent*/(2) 求树中结点孩子的算法:void Children(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++){if(x==t[i].data)break;/*找到x退出循环*/}/*for*/if(i>=MAXNODE) printf("x不存在\n"); else {flag=0;for(j=0;j<MAXNODE;j++)if(i==t[j].parent){ printf("x的孩子:%c\n"t[j].data);flag=1;}if(flag==0) printf("x无孩子\n");}}/*Children*/5.18typedef char elemtype;typedef struct ChildNode{ int childcode;struct ChildNode *nextchild;}typedef struct{ elemtype data;struct ChildNode *firstchild;} NodeType;(1) 求树中结点双亲的算法:int ParentCL(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) {loc=i;/*记下x的下标*/break;}if(i>=MAXNODE) return -2; /* x不存在 *//*搜索x的双亲*/for(i=0;i<MAXNODE;i++)for(p=t[i].firstchild;p!=NULL;p=p->nextchild) if(loc==p->childcode)return i; /*返回x结点的双亲下标*/}/* ParentL */(2) 求树中结点孩子的算法:void ChildrenCL(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++)if(x==t[i].data) /*依次打印x的孩子*/{flag=0; /* x存在 */for(p=t[i].firstchild;p;p=p->nextchild){ printf("x的孩子:%c\n"t[p-> childcode].data);flag=1;}if(flag==0) printf("x无孩子\n");return;}/*if*/printf("x不存在\n");return;}/* ChildrenL */5.19typedef char elemtype;typedef struct TreeNode{ elemtype data;struct TreeNode *firstchild; struct TreeNode *nextsibling; } NodeType;void ChildrenCSL(NodeType *telemtype x){ /* 层次遍历方法 */Init_Queue(Q); /* 初始化队列 */In_Queue(Qt);count=0;while(!Empty_Queue (Q)){Out_Queue(Qp);if(p->data==x){ /*输出x的孩子*/p=p->firstchild;if(!p) printf("无孩子\n");else{ printf("x的第%i个孩子:%c\n"++countp->data);/*输出第一个孩子*/p=p->nextsibling; /*沿右分支*/while(p){printf("x的第%i个孩子:%c\n"++countp->data);p=p-> nextsibling;}}return;}if(p-> firstchild) In_Queue(Qp-> firstchild);if(p-> nextsibling) In_Queue(Qp-> nextsibling);}}/* ChildrenCSL */5.20(1) 哈夫曼树为:(2) 在上述哈夫曼树的每个左分支上标以1右分支上标以0并设这7个字母分别为A、B、C、D、E、F和H如下图所示：则它们的哈夫曼树为分别为:A：1100B：1101C：10D：011E：00F：010H：111习题6参考答案6.1 选择题（1）C （2）A （3）B（4）C（5）B______条边（6）B（7）A（8）A（9）B（10）A（11）A（12）A（13）B（14）A（15）B（16）A（17）C 6.2 填空（1） 4（2） 1对多 ; 多对多（3） n-1 ; n（4） 0_（5）有向图（6） 1（7）一半（8）一半（9）___第i个链表中边表结点数___（10）___第i个链表中边表结点数___（11）深度优先遍历；广度优先遍历（12）O（n2）（13）___无回路6.3（1）邻接矩阵:（2）邻接链表：（3）每个顶点的度：顶点度V1 3V2 3V3 2V4 3V5 36.4（1）邻接链表：（2）逆邻接链表：（3）顶点入度出度V1 3 0V2 2 2V3 1 2V4 1 3V5 2 1V6 2 36.5（1）深度优先查找遍历序列：V1 V2 V3 V4 V5; V1 V3 V5 V4 V2; V1 V4 V3 V5 V2 （1）广度优先查找遍历序列：V1 V2 V3 V4 V5; V1 V3 V2 V4 V5; V1 V4 V3 V2 V56.6有两个连通分量：6.7顶点（1）（2）（3）（4）（5）Low Close Cost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexV10 00 00 00 00 0V21 00 00 00 00 0V31 01 00 00 00 0V43 02 12 10 10 1V5∞ 05 13 22 30 3U{v1} {v1v2} {v1v2v3} {v1 v2 v3 v4} {v1 v2 v3 v4 v5} T {} { (v1 v2) } {(v1 v2) (v1 v3) } {(v1 v2) (v1 v3) (v2 v4) } {(v1 v2)(v1v3)(v2v4)(v4v5) }最小生成树的示意图如下：6.8拓扑排序结果： V3--> V1 --> V4 --> V5 --> V2 --> V66.9（1）建立无向图邻接矩阵算法：提示：参见算法6.1因为无向图的邻接矩阵是对称的所以有for (k=0; k<G ->e; k++) /*输入e条边建立无向图邻接矩阵*/{ scanf("\n%d%d"&i&j);G ->edges[i][j]= G ->edges[j][i]=1;}(2)建立无向网邻接矩阵算法:提示：参见算法6.1初始化邻接矩阵：#define INFINITY 32768 /* 表示极大值*/for(i=0;i<G->n;i++)for(j=0;j<G->n;j++) G->edges[i][j]= INFINITY;输入边的信息：不仅要输入边邻接的两个顶点序号还要输入边上的权值for (k=0; k<G ->e; k++) /*输入e条边建立无向网邻接矩阵*/{ scanf("\n%d%d%d"&i&j&cost); /*设权值为int型*/G ->edges[i][j]= G ->edges[j][i]=cost;/*对称矩阵*/}(3)建立有向图邻接矩阵算法:提示：参见算法6.16.10(1)建立无向图邻接链表算法：typedef VertexType char;int Create_NgAdjList(ALGraph *G){ /* 输入无向图的顶点数、边数、顶点信息和边的信息建立邻接表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*边数不能为负 */G->e=e;for(m=0;m< G->n ;m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e; m++){scanf("\n%d%d"&i&j); /* 输入一对邻接顶点序号*/if((i<0 || j<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/ p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/ p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;} /* for*/return 0; /*成功*/}//Create_NgAdjList(2)建立有向图逆邻接链表算法：typedef VertexType char;int Create_AdjList(ALGraph *G){ /* 输入有向图的顶点数、边数、顶点信息和边的信息建立逆邻接链表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*弧数不能为负 */G->e=e;for(m=0;m< G->n; m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e ; m++){scanf("\n%d%d"&t&h); /* 输入弧尾和弧头序号*/if((t<0 || h<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第h+1个链表中插入一个边表结点*/ p->adjvex=t;p->next= G-> adjlist [h].firstedge;G-> adjlist [h].firstedge=p;} /* for*/return 0; /*成功*/}//Create_AdjList6.11void Create_AdjM(ALGraph *G1MGraph *G2){ /*通过无向图的邻接链表G1生成无向图的邻接矩阵G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G2->n;i++) /* 置G2每个元素为0 */for(j=0;j<G2->n;j++) G2->edges[i][j]= 0;for(m=0;m< G1->n;m++)G2->vexs[m]=G1->adjlist[m].vertex; /*复制顶点信息*/num=（G1->n/2==0?G1->n/2:G1->n/2+1）; /*只要搜索前n/2个单链表即可*/for(m=0;m< num;m++){ p=G1->adjlist[m].firstedge;while(p){ /* 无向图的存储具有对称性*/G2->edges[m][ p->adjvex ]= G2->edges[p->adjvex ] [m] =1;p==p->next;}}/* for */}/*Create_AdjM */6.12void Create_AdjL(ALGraph *G1MGraph *G2){ /*通过无向图的邻接矩阵G1生成无向图的邻接链表G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G1->n;i++) /* 建立每个单链表 */{ G2->vexs[i]=G1->adjlist[i].vertex;G2->adjlist[i].firstedge=NULL；for(j=i; j<G1->n; j++) /*对称矩阵只要搜索主对角以上的元素即可*/{ if(G1->edges[i][j]== 1){ p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;}/*if*/}/* for*/}/* for*/}/* Create_AdjL */6.13(1) 邻接矩阵中1的个数的一半;(2) 若位于[i-1j-1]或[j-1i-1]位置的元素值等于1则有边相连否则没有(3) 顶点i的度等于第i-1行中或第i-1列中1的个数6.14(1) 邻接链表中边表结点的个数的一半;(2) 若第i-1（或j-1）个单链表中存在adjvex域值等于j-1（或i-1）的边表结点则有边相连否则没有(3) 顶点i的度等于第i-1个单链表中边表结点的个数6.15提示：参见算法6.2 和6.3习题 7参考答案7.1 选择题（1）C (2)C (3) C (4)B (5) A (6)A (7) D (8)B (9)D (10) B(11)B (12)A (13)C (14)C (15)A (16)D (17)C (18)BC (19)B (20)A7.2 填空题（1） O(n)O(log2n)（2） 12485log2(n+1)-1（3）小于大于（4）增序序列（5）m-1（6） 70; 342055（7） n/m（8）开放地址法链地址法（9）产生冲突的可能性就越大产生冲突的可能性就越小（10）关键码直接（11）②①⑦（12） 1616821（13）直接定址法数字分析法平方取中法折叠法除留余数法随机数法（14）开放地址法再哈希法链地址法建立一个公共溢出区（15）装满程度（16）索引快（17）哈希函数装填因子（18）一个结点（19）中序（20）等于7.3 一棵二叉排序树(又称二叉查找树)或者是一棵空树或者是一棵同时满足下列条件的二叉树：(1)若它的左子树不空则左子树上所有结点的键值均小于它根结点键值(2)若它的右子树不空则右子树上所有结点的键值均大于它根结点键值(3)它的左、右子树也分别为二叉排序树7.4 对地址单元d=H(K)如发生冲突以d为中心在左右两边交替进行探测按照二次探测法键值K的散列地址序列为：do=H(K)d1=(d0+12)mod md2=(d0-12)mod md3=(d0+22)mod md4=(d0-12)mod m......7.5 衡量算法的标准有很多时间复杂度只是其中之一尽管有些算法时间性能很好但是其他方面可能就存在着不足比如散列查找的时间性能很优越但是需要关注如何合理地构造散列函数问题而且总存在着冲突等现象为了解决冲突还得采用其他方法二分查找也是有代价的因为事先必须对整个查找区间进行排序而排序也是费时的所以常应用于频繁查找的场合对于顺序查找尽管效率不高但却比较简单常用于查找范围较小或偶而进行查找的情况7.6此法要求设立多个散列函数Hii=1...k当给定值K与闭散列表中的某个键值是相对于某个散列函数Hi的同义词因而发生冲突时继续计算该给定值K在下一个散列函数Hi+1下的散列地址直到不再产生冲突为止7.7散列表由两个一维数组组成一个称为基本表另一个称为溢出表插入首先在基本表上进行；假如发生冲突则将同义词存人溢出表7.8 结点个数为n时高度最小的树的高度为1有两层它有n-1个叶结点1个分支结点；高度最大的树的高度为n-l有n层它有1个叶结点n-1个分支结点7.9 设顺序查找以h为表头指针的有序链表若查找成功则返回结点指针p查找失败则返回null值pointer sqesrearch(pointer hint xpointerp){p=null；while(h)if(x>h->key)h=h->link；else{if(x==h->key)p=h；return(p)；}}虽然链表中的结点是按从小到大的顺序排列的但是其存储结构为单链表查找结点时只能从头指针开始逐步进行搜索故不能用折半(二分)查找7.10 分析：对二叉排序树来讲其中根遍历序列为一个递增有序序列因此对给定的二叉树进行中根遍历如果始终能保证前一个值比后一个值小则说明该二叉树是二叉排序树int bsbtr (bitreptr T) ／*predt记录当前结点前趋值初值为-∞*／{ if (T==NULL) return(1)；else{b1=bsbtr(T->lchild)；／*判断左子树*／if (!b1|| (predt>=T->data)) return(0)；*当前结点和前趋比较*／ predt=T->data；／*修改当前结点的前趋值*／return(bsbtr(T->rchild))；／*判断右子树并返回最终结果*／}}7.11 (1)使用线性探查再散列法来构造散列表如表下所示散列表───────────────────────────────地址 0 1 2 3 4 5 6 7 8 9 10───────────────────────────────数据 33 1 13 12 34 38 27 22───────────────────────────────（2）使用链地址法来构造散列表如下图(3)装填因子a=8／11使用线性探查再散列法查找成功所需的平均查找次数为Snl=0．5(1+1／(1-a))=0．5*(1+1／(1-8／11))=7／3使用线性探查再散列法查找不成功所需的平均查找次数为：Unl=0．5(1+1／(1-a)2)=0．5*(1+1／(1-8／11)2)=65／9 使用链地址法查找成功所需的平均查找次数为：Snc=l+a／2=1+8／22=15／11使用链地址法查找不成功所需的平均查找次数为： 'Unl=a+e-a=8／1l+e-8／117.12 分析：在等查区间的上、下界处设两个指针由此计算出中间元素的序号当中间元素大于给定值X时接下来到其低端区间去查找；当中间元素小于给定值X时接下来到其高端区间去查找；当中间元素等于给定值X时表示查找成功输出其序号Int binlist(sqtable Aint stkeytype X) ／*t、s分别为查找区间的上、下界*／{ if(s<t) return(0)；／*查找失败*／else{ mid=(S+t)／2；switCh(mid){case x<A.item[midJ.key： return(binlist(Asmid-lX))；／*在低端区间上递归*／case x==A.item[mid].key： return(mid)；／+查找成功*／ case x>A.item[mid].key： return(amid+ltX))；／*在高端区间上递归*／}}}7.13int sqsearch0 (sqtable Akeytype X) /*数组有元素n个*／{ i=l；A.item[n+1].key=X；／t设置哨兵*／while (A.item[n+1].key!=X) i++；return (i% (n／1))；／*找不到返回0找到返回其下标*／}查找成功平均查找长度为：(1+2+3+...+n)／n：(1+n)／2查找不成功平均查找长度为：n+17.14散列函数：H(key)=100+(key个位数+key十位数) mod l0；形成的散列表：100 101 102 103 104 105 106 107 108 10998 75 63 46 49 79 61 53 17查找成功时的平均长度为：(1+2+1+1+5+1+1+5+5+3)/10=2.5次由于长度为10的哈希表已满因此在插人第11个记录时所需作的比较次数的期望值为10查找不成功时的平均长度为10习题 8参考答案8．1 选择题（1）B (2)A (3)D (4)C (5)B (6)A (7)B (8)C (9)A (10)C(11)D (12)C (13) C （14）D （15）C (16)B (17) D （18）C （19）B （20）D8.2填空题（1）快速归并（2） O（log2n）O(nlog2n)（3）归并（4）向上根结点（5） 1918163022（6）（7）4913275076386597（8）88（9）插入选择（每次选择最大的）（10）快速归并(11)O(1)O(nlog2n)(12)稳定(13)3(14)(15205040)(15)O(log2n)(16)O(n2)(17)冒泡排序快速排序(18)完全二叉树n/2(19)稳定不稳定(20)2(204015)8.3. 假定给定含有n个记录的文件(r1f2...rn)其相应的关键字为(k1k2...kn)则排序就是确定文件的一个序列rrr2...rn使得k1'≤k2'≤...≤kn'从而使得文件中n个记录按其对应关键字有序排列如果整个排序过程在内存中进行则排序叫内部排序假设在待排序的文件中存在两个或两个以上的记录具有相同的关键字若采用某种排序方法后使得这些具有相同关键字的记录在排序前后相对次序依然保持不变则认为该排序方法是稳定的否则就认为排序方法是不稳定的8.4．稳定的有：直接插入排序、二分法插入排序、起泡排序、归并排序和直接选择排序8.5．初始记录序列按关键字有序或基本有序时比较次数为最多8.6．设5个元素分别用abcde表示取a与b、c与d进行比较若a>bc>d(也可能是a<bc<d此时情况类似)显然此时进行了两次比较取b与d再比较若b>d则a>b>d若b<d则有c>d>b此时已进行了3次比较要使排序比较最多7次可把另外两个元素按折半检索排序插入到上面所得的有序序列中此时共需要4次比较从而可得算法共只需7次比较8.7．题目中所说的几种排序方法中其排序速度都很快但快速排序、归并排序、基数排序和Shell排序都是在排序结束后才能确定数据元素的全部序列而排序过程中无法知道部分连续位置上的最终元素而堆排序则是每次输出一个堆顶元素(即最大或最少值的元素)然后对堆进行再调整保证堆顶元素总是当前剩下元素的最大或最小的从而可知欲在一个大量数据的文件中如含有15000个元素的记录文件中选取前10个最大的元素可采用堆排序进行8.8．二分法排序8.9．void insertsort(seqlist r)  ；{ ／／对顺序表中记录R[0一N-1)按递增序进行插入排序&NBSP；int ij；  ；for(i=n-2；i>=0; i--) ／／在有序区中依次插入r[n-2]．．r[0]  ；if(r[i].key>r[i+1].key) ／／若不是这样则r[i]原位不动 ；{  ；r[n]=r[i]；j=i+l；／／r[n]是哨兵 ；do{ ／／从左向右在有序区中查找插入位置 ；r[j-1]= r[j]；／／将关键字小于r[i]．key的记录向右移 ；j++；  ；}whle(r[j].key r[j-1]=r[n]；／／将引i)插入到正确位置上 ；}／／endif ；}／／insertsort．  ；8.10．建立初始堆：[937 694 863 265 438 751 742129075 3011]&NBSP；&NBSP；第一次排序重建堆：[863 694 751 765 438 301 742 129 075]9378.11．在排序过程中每次比较会有两种情况出现若整个排序过程至少需作t次比较则显然会有2^t个情况由于n个结点总共有n!种不同的排列因而必须有n!种不同的比较路径于是： 2t≥n!即t≥log2n!因为log2nl=nlog2n-n／ln2+log2n／2+O(1)故有log2n!≈nlog2n从而t≧nlog2n得证8.12．依据堆定义可知：序列(1)、(2)、(4)是堆(3)不是堆从而可对其调整使之为如下的大根堆(1009580604095821020)8.13．第一趟：[265 301] [129 751] [863 937] [694 742] [076 438]&NBSP； &NBSP；第二趟：[129 265 301 751] [694 742 863 937] [076 438]&NBSP；&NBSP；第三趟：[129 265 301 694 742 751 863 937] [076 438]&NBSP；&NBSP；第四趟：[076 129 265 301 438 694 742 751 863 937]&NBSP；8.14．(1)归并排序：(1829) (2547) (1258) (1051)(18252947) (10125158)(1012182529475158)(2)快速排序：(1018251229585147)(1018251229475158)(1012182529475158)(3)堆排序：初始堆(大顶堆)：(58 47512918122510)第一次调整：(51 472529181210)(58)第二次调整：(47 2925101812)(5158)第三次调整：(29 18251012)(475158)第四次调整：(25 181210)(29475158)第五次调整：(18 1012)(2529475158)第六次调整：(12 10) (182529475158)第七次调整：(1012182529475158)8.15．(1)直接插入排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 151=2 40 83 [63 13 84 35 96 57 39 79 61 15] 1=3 40 63 83 [13 84 35 96 57 39 79 61 15] 1=4 13 40 63 83 [84 3 5 96 57 39 79 61 15] I=5 13 40 63 83 84 [35 96 57 39 79 61 15] I=6 13 35 40 63 83 84 [96 57 39 79 61 15] 1=7 13 35 40 63 83 84 96 [57 39 79 61 15] 1=8 13 35 40 57 63 83 84 96 [ 39 79 61 15] 1=9 13 35 39 40 57 63 83 84 96 [79 61 15] I=10 13 35 39 40 57 63 79 83 84 96 [61 15] I=11 13 35 39 40 57 61 63 79 83 84 96 [15] 1=12 13 15 35 39 40 57 61 63 79 83 84 96 (2)直接选择排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 15i=1 13 [ 40 63 83 84 35 96 57 39 79 61 15] i=2 13 15 [63 83 84 35 96 57 39 79 61 40] i=3 13 15 35 [83 84 63 96 57 39 79 61 40] i=4 13 15 35 39 [84 63 96 57 83 79 61 40] i=5 13 15 35 39 40 [63 96 57 83 79 61 84] i=6 13 15 35 39 40 57 [96 63 83 79 61 84] i=7 13 15 35 39 40 57 61 [63 83 79 96 84] i=8 13 15 35 39 40 57 61 63 [83 79 96 84] i=9 13 15 35 39 40 57 61 63 79 183 96 84] i=10 13 15 35 39 40 57 61 63 79 83 [96 84] i=11 13 15 35 39 40 57 61 63 79 83 84 [96] (3)快速排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [15 40 63 13 61 35 79 57 39] 83 [96 84] 第二趟排序后 [13] 15 [63 40 61 35 79 57 39] 83 84 [96]第三趟排序后 13 15 [39 40 61 35 57] 63 [79] 83 84 96 第四趟排序后 13 15 [35] 39 [61 40 57] 63 79 83 84 96 第五趟排序后 13 15 35 39 [57 40] 61 63 79 83 84 96 第六趟排序后 13 15 35 39 40 [57] 61 63 79 83 84 96 第七趟排序后 13 15 35 39 40 57 61 63 79 83 84 96 (4)堆排序关键字 83 40 63 13 84 35 96 57 39 79 61 15排序成功的序列 96 84 83 79 63 61 57 40 39 35 15 13(5)归并排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [40 83] [13 63] [3584] [57 96] [39 79] [15 61]第二趟排序后 [13 40 63 83] [35 57 84 96] [15 39 61 79] 第三趟排序后 [13 35 40 57 63 83 84 96]] [15 39 61 79] 第四趟排序后 13 15 35 39 40 57 61 63 79 83 84 96。
数据结构(C语言版)第三版__清华大学出版社_习题参考答案
数据结构(C语言版)第三版__清华大学出版社_习题参考答案数据结构(C语言版)第三版__清华大学出版社_习题参考答案引言：数据结构是计算机科学的基础，对于学习和理解数据结构的相关概念和算法非常重要。
本文将对清华大学出版社出版的《数据结构(C语言版)第三版》中的习题进行参考答案的提供。
通过正确的理解和掌握这些习题的解答，读者可以加深对数据结构的认识，并提高自己的编程能力。
第一章：绪论1.1 数据结构的定义与作用数据结构是指数据对象以及数据对象之间的关系、运算和存储结构的总称。
数据结构的作用是在计算机中高效地组织和存储数据，同时支持常见的数据操作和算法。
1.2 算法的定义与特性算法是解决特定问题的一系列步骤和规则。
算法具有确定性、有穷性、可行性和输入输出性等特点。
第二章：线性表2.1 线性表的定义和基本操作线性表是同类型数据元素的一个有限序列。
线性表的基本操作包括初始化、查找、插入、删除和遍历等。
2.2 顺序存储结构顺序存储结构是将线性表中的元素按顺序存放在一块连续的存储空间中。
顺序存储结构的特点是随机存取、插入和删除操作需要移动大量元素。
2.3 链式存储结构链式存储结构通过结点之间的指针链表来表示线性表。
链式存储结构的特点是插入和删除操作方便，但查找操作需要遍历整个链表。
第三章：栈和队列3.1 栈的定义和基本操作栈是只能在一端进行插入和删除操作的线性表。
栈的基本操作包括初始化、入栈、出栈和获取栈顶元素等。
3.2 队列的定义和基本操作队列是只能在一端插入操作，在另一端进行删除操作的线性表。
队列的基本操作包括初始化、入队、出队和获取队头元素等。
第四章：串4.1 串的定义和基本操作串是由零个或多个字符组成的有限序列。
串的基本操作包括初始化、串的赋值、串的连接和串的比较等。
第五章：树5.1 树的基本概念和术语树是n（n>=0）个结点的有限集。
树的基本概念包括根结点、子树、深度和高度等。
5.2 二叉树二叉树是每个结点最多有两个子树的树结构。
北大C与C++语言课程 第4讲数据的组织结构(一)
第4讲数据的组织结构（一）1．某选举活动有C位候选人，候选人从1开始顺序编号。
E个人参加投票，每人限选一位侯选人。
请编写程序，E人都通过键盘输入候选人编号进行投票，要求在屏幕上输出每位候选人的得票数。
（C和E用符号常量表示）2．键盘输入字符串数据，存入数组中，分别统计其中字母，数字和空格的个数。
3．下列程序段的功能是：输出两个字符串中对应位置字符相等的字符（该程序的输出结果应该为：“sd”，不包括引号）。
现在的这段程序存在一些问题，请改正并说明原因。
#include <stdio.h>void main(){char x[8]="student";char y[8]="sstdde";int i=0;while(i<=8){if(x[i]==y[i]) printf("%c",x[i]);i++;}}4．修改上课ppt中的顺序查找例题，数组的大小为学生人数加1，学生成绩从数组下标为1的位置开始存储，将分数59赋值到下标为0的位置，称之为哨兵。
查找操作从数组下标高端向低端进行，遇到小于60的分数，查找循环结束。
若循环结束位置下标不为0，则查找成功，有不及格的学生；找到位置的下标为0，则查找失败，无不及格的学生。
同时，编程测试你编写的函数。
5．填写程序代码，完成下面的选择排序程序。
#define NUM 10int main(){int i;int b[NUM];printf("Please put in %d numbers:\n",NUM);for(i=0;i<NUM;i++)scanf("%d",&b[i]);// 在此填写程序代码，完成对数组b中的数据进行选择排序。
// 输出排序后的结果for(i=0;i<NUM;i++)printf("%4d",b[i]);return 0;}6．填写程序代码，完成下面的二分查找程序。
北京大学《数据结构与算法》精品课程
北京大学《数据结构与算法》精品课程本课程为北京大学张铭教授主讲的数据结构与算法精品课程教学视频，全套课程共46集，由壹课堂整理免费共享。
数据结构与算法课程是计算机专业的核心基础课程，是一门理论与实践相结合的课程，整个计算机专业教学体系中处于举足轻重的地位。
数据结构是程序设计（特别是非数值计算的程序设计）的基础，也是设计和实现编译程序、操作系统、数据库系统及其它系统程序和大型应用程序的重要基础。
基于该门课程的重要性，现在该课程已经是计算机相关专业研究生考试必考专业课之一，是反映学生数据抽象能力、编程能力的重要体现。
北大数据结构课讲义7
• return (Q.rear+1)%QueueMaxSize==Q.front;
•}
北大数据结构课讲义7
• 2. 队列运算在链接存储结构上的实现
•（1）初始化链队
•void InitQueue (LinkQueue& HQ) {
• HQ.front = HQ.rear = NULL;
•}
•（2）清空链队
•（6）从队列中删除一个元素
•ElemType OutQueue(LinkQueue& HQ)
•{
• if (HQ.front==NULL) {
•
cerr<<“Linked queue is empty."<<endl;
•
exit(1);
•}
•
ElemType temp=HQ.front->data;
•(!) 4.4.1~2,7 能在书上程序的基础上编写
• 程序实现
•(#) 4.4.3~6,8~11 有兴趣者课外思考
北大数据结构课讲义7
书面回答,请以纸面形式上交课代表,要求整洁清楚，
时间期限:5月10日 [格式提头:学号/序号/姓名/第四章]
1、对于一个栈，如果输入项序列由A，B，C组成，给出全部可能和 不可能的输出序列。
•
Lnode* p=HQ.front;
•
HQ.front=p->next;
•
if (HQ.front==NULL)
HQ.rear=NULL;
•
delete p;
•
return temp;
•}
•//不妨与书上P79的算法10(ppt4,算法12)：从单链表中
北京大学软件与微电子学院考研考情分析及经验指导【盛世清北】
北京大学软件与微电子学院考研考情分析及经验指导【盛世清北】【简介】本文重点说明北京大学软件与微电子学院考研招生变化，复试内容及分数线，参考书，历年真题，盛世清北内部资料，北京大学软件与微电子学院考研经验等。
【考情分析】北京大学软件与微电子学院专业课历年考试难度大，考的深，考的活，即使是同一本教材，但是掌握程度与考生高校要求不可同日而语。
考什么，怎么考，怎么学，怎么考高分是在报考北京大学考生面前的拦路虎。
因此，考生要了解和掌握北京大学考试风格，考试题型，考试重点，难点，突破跨越顶尖名校的障碍。
由于北京大学考试要求及难度大于其他高校，因此，北京大学专业课程的备考，也可用于其他高校通科目专业课程备考使用。
【2021招生目录】【院系招生变化】对比北京大学软件与微电子学院2021年与2020年招生目录，总结出：1、招生专业不变；2、电子信息专业的研究方向增加软件工程实验班好集成电路实验班，工程管理硕士专业的研究方向减少互联网金融方向；3、电子信息专业的招生目录备注减少考试科目情况；4、电子信息专业计算机技术方向的考试科目减少了命题创作和英汉互译，增加了语言信息综合和数字艺术综合，其他专业考试科目不变；5、电子信息专业招生人数增加38人，工程管理硕士专业招生人数减少43人；6、科目代码改变：869变为839；918变为858；916变为857；综述，北大软件与微电子学院招生变化较大，备考考生注意报考。
【复试分数线】【复试内容】一、复试时间、方式：复试时间：5月6日开始进行（具体时间请查收邮件）复试方式：由于受疫情影响，此次复试采取远程复试二、复试基本内容和复试程序：1、资格审查材料：参见《附件1：北京大学软件与微电子学院2020年统考研究生复试通知》。
2、按照各招生专业方向及考试类别分组，差额复试。
3、复试以综合面试为主，对综合能力较强且具备今后专业学习能力的考生予以择优录取。
复试将综合考查考生的既往学业、一贯表现、科研实践能力、综合素质和思想品德等情况。
北京大学2016年秋季学期《数据结构》课程作业【答案】
树形结构中元素之间存在一对多_关系。（第一章）
2
n
3.一个算法的最基本的原操作执行次数为(3n +2nlog2 +4n-7)/(7n),则该算法的时间
复杂度为_ O(n)______。（第一章）
4.链式存储结构用一组地址任意的存储单元依次存放数据元素，数据元素之间的逻辑
关系通过__指针________间接地反映。（第二章）
答 顺序表的优点势可以随机访问数据元素；缺点是大小固定，不利于增减结点（增 减操作需要移动元素）。链表的优点是采用指针方式增减结点，非常方便（只需要改 变指针指向，不移动结点）。其缺点是不能进行随机访问，只能顺序访问；另外，每
第５页 共 10 页
个结点上增加指针域，造成额外存储空间增大。
2. （第二章）在一个单链表 HL 中删除指针 p 所指结点，应执行如下关键操作： if(________) HL = HL->next; else { q = HL; while(________) q = q->next; _____________; } delete p;
件是_____B_____。（第五章）
a 空或只有一个结点
b 高度等于其结点数
c 任一结点无右孩子
d 任一结点无左孩子
21. 树的基本遍历策略分为先根遍历和后根遍历；二叉树的基本遍历策略可分为先序
遍历、中序遍历和后序遍历。结论___A_______是正确的。（第五章）
a.树的先根遍历序列与其对应的二叉树的先序遍历序列相同
08，09}，R={r}，r={<01，02>，<01，03>，<01，04>，<02，05>，<02，06>，<03，
991“数据结构与C语言程序设计”考试大纲(2019年)北航自命题科目考研
991“数据结构与C语言程序设计”考试大纲（2019版）2019年“数据结构与C语言程序设计”考试内容包括“数据结构”与“C语言程序设计”两门课程的内容，各占比例50%。
试卷满分为150分。
“数据结构”部分一、概述1．数据的逻辑结构与存储结构的基本概念；2．算法的定义、基本性质以及算法分析的基本概念，包括采用大 形式表示时间复杂度和空间复杂度。
二、线性表1．线性关系、线性表的定义，线性表的基本操作；2．线性表的顺序存储结构与链式存储结构(包括单(向)链表、循环链表和双向链表)的构造原理；3．在以上两种存储结构的基础上对线性表实施的基本操作，包括顺序表的插入与删除、链表的建立、插入与删除、查找等操作对应的算法设计(含递归算法的设计)。
三、数组1．一维数组和二维数组的存储；2．矩阵的压缩存储的基本概念；3．对称矩阵、对角矩阵以及三角矩阵的压缩存储。
四、堆栈与队列1．堆栈与队列的基本概念与基本操作；2．堆栈与队列的顺序存储结构与链式存储结构的构造原理；3．在不同存储结构的基础上对堆栈与队列实施插入与删除等基本操作的算法设计；4．堆栈和队列在解决实际问题中应用。
五、树与二叉树1．树与二叉树的基本概念，基本特征、名词术语；2．完全二叉树与满二叉树的基本概念，二叉树的基本性质及其应用；3．二叉树的顺序存储结构与二叉链表存储结的基本原理；4．二叉树的前序遍历、中序遍历、后序遍历和按层次遍历，重点是二叉树在以二叉链表作为存储结构基础上各种遍历算法(包括非递归算法)的设计与应用；5．二叉排序树的基本概念、建立(插入)、查找以及平均查找长度ASL的计算。
六、图1．图的基本概念、名词术语；2．图的邻接矩阵存储方法和邻接表(含逆邻接表)存储方法的构造原理及特点；3．图的深度优先搜索与广度优先搜索；4．最小(代价)生成树、最短路径、AOV网与拓扑排序的基本概念。
七、文件及查找1．顺序查找法以及平均查找长度(ASL)的计算；2．折半查找法以及平均查找长度(ASL)的计算，包括查找过程对应的“判定树”的构造；3．散列(Hash)表的构造、散列函数的构造，散列冲突的基本概念、处理散列冲突的基本方法以及散列表的查找和平均查找长度的计算。
数据结构(C语言版)(第2版)(2017年清华大学出版社出版
成书过程
修订过程
出版工作
该教材是根据教育部《高等学校计算机科学与技术专业公共核心知识体系与课程》编写的数据结构主教材。 该教材的编写得到清华大学2015年精品教材建设项目的资助。
教材目录
（注：目录排版顺序为从左列至右列 ）
教学资源
该教材有配套教材——《数据结构精讲与习题详解（C语言版）（第2版）》。
作者简介
殷人昆，男，清华大学计算机系教授，1985年赴日本国东京理科大学做访问学者，研究方向为软件工程过程 的质量管理和软件产品的质量评价。主要教学工作为计算机系大学本科“数据结构”“软件工程”和研究生“软 件工程设计与技术”“软件项目管理”课程负责人，主持教育部微软精品课程“数据结构”的建设。
该教材的初稿完成于2015年12月，作为另一本教材《数据结构精讲与习题详解（第2版）》的写作参照，相 互补充，首先完成了《数据结构精讲与习题详解（第2版）》，再回过头来第二次修改该教材。
该教材修改部分包括：
2017年5月1日，该教材由清华大学出版社出版。
内容简介
全书共8章。第1章介绍数据结构的地位和主要知识点，数据结构和算法的基本概念和算法分析的简单方法， 以及C语言编程的要点。第2～8章分别介绍了线性表、栈和队列及其应用、多维数组、特殊矩阵、稀疏矩阵、字 符串和广义表、树与二叉树、图、查找、排序，并做了适当延伸。此外，附录还包含实训作业要求与样例（实训 作业要求和实训作业样例）、词汇索引。
感谢观看
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
x y
y x
存储结构只含数据元素本身 的信息，无附加信息
链式映象中，存储结构除数据 元素本身信息外，需要附加信息 指示存储位置
基本概念
算法 是能够解决某类问题的由若干指令组成的有限序
列。 一个算法可以用自然语言、程序设计语言或专门设计 的伪语言描述。 算法必须满足五个特性：
（1）有限性
（3）输入 （5）可行性
基本概念
算法的设计原则：
正确性 可读性 坚固性(健壮性) 高效率与低存储量需求
基本概念
正确性:说一个算法是正确的，是指对于一切合法的输 入数据，该算法经过有限时间（算法意义上的有限） 的执行都能产生正确（或者说满足规格说明要求）的 结果。 可读性: 可读性好的算法有助于设计者和他人阅读、理 解、修改和重用。晦涩难读的程序易于隐藏较多错误。 坚固性: 当输入数据非法时，算法能适当地作出合适的 反应。 高效率与低存储量需求:通常，效率指的是算法执行时 间；存储量指的是算法执行过程中所需的最大存储空 间，两者都与问题的规模有关。
基本概念
数据的存储结构
“数据元素”的映象 “关系”的映象
数据元素的映象方法 用二进制位(bit)的位串表示数据元素
(321)10 = (101000001)2 A = (001000001)2
基本概念
关系的映象方法
顺序映象 以相对的存储位置表示后继关系 链式映象 以附加信息(指针)表示后继关系
void mult(int a[][n], int b[][n], int(&c)[n][n] ) {
// 以二维数组存储矩阵元素，c 为 a 和 b 的乘积
for (i=0; i<n; ++i) for (j=0; j<n; ++j) { c[i][j] = 0; for (k=0; k<n; ++k) c[i][j] += a[i][k]*b[k][j]; } //for O(n3)
} //mult
基本概念
例子：
(a) x=x+1; O(1) (b) for(i=0; i<n; i++) x=x+1; (c) for(i=0; i<n; i++) for( j=0; j<n; j++) x=x+1; O (n) O (n2)
（2）确定性
（4）输出
基本概念
1.
2. 3. 4. 5.
有限性：任何一条指令都只能执行有限次，换句话说，算法必 须在执行有限步后结束。
确定性：算法中每条指令的含义必须明确，不允许有二义性， 对于相同的输入只能得出相同的输出。 输入：一个算法可以有零个或多个输入数据，这些输入数据取 自确定的对象集合。 输出：算法有一个或多个输出，这些输出是同输入有某个特定 关系的量。 可行性：算法中的所有操作都必须足够基本，都可以通过已经 实现的基本操作运算有限次实现之。
组成数据的基本单位。 是数据中的一个“个体”。 又称元素、记录、结点或者顶点。
数据项
数据元素由数据项组成。 是数据结构中讨论的最小单位。 又称域、字段。
姓名 王二 俱乐部名称 工人俱乐部
出生日期 参加日期 职务 1970-10-3 2000-9-10 会员
基本概念
数据结构
相互之间存在着某种关系的数据元素的集合。
基本概念
设L=( N, R )是一个逻辑结构，R={ r }， 若a, b∈N，且关系( a, b )∈r，
则：
称 a 是 b 的 前趋结点， 称 b 是 a 的 后继结点， 称 a 和 b 是 相邻结点， 如果不存在a∈N，使( a, b )∈r ，则称b为始结点， 如果不存在b∈N，使( a, b )∈r，则称a为终结点， 既非始结点又非终结点的结点被称为内结点。
事后统计法 必须执行程序 其它因素掩盖算法本质 事前分析估算法
基本概念
和算法执行时间相关的因素：
算法选用的策略 问题的规模 编写程序的语言 编译程序产生的机器代码的质量 计算机执行指令的速度 ——用绝对的时间单位衡量算法效率不合适
基本概念
撇开影响算法效率的软硬件因素，一个特定算法的
“运行工作量”的大小，只依赖于问题的规模（通常 用整数量n表示），或者说，它是问题规模的函数。 假如，随着问题规模 n 的增长，算法执行时间的增长 率和 f (n) 的增长率相同，则可记作：
T (n) = O( f (n) )
称T (n) 为算法的(渐近)时间复杂度。
பைடு நூலகம்
基本概念
算法 = 控制结构 + 基本运算 为了比较同一问题的不同算法，通常的做法是，从算 法中选取一些基本运算，以基本运算的重复执行次数 作为算法的时间量度。
数据结构（一）
常宝宝 北京大学计算机科学与技术系 chbb@
基本概念
数据
可以被计算机识别、存储和加工处理的符号的集合。 是计算机操作的对象的总称。 是信息的载体。
例子
数值计算程序（实数或整数） 编译程序（源程序） 图像处理程序（图像）
基本概念
数据元素
基本概念
数据的逻辑结构
线性结构 树形结构 图状结构 集合结构
基本概念
线性结构 结构中有且仅有一个始结点和一个终结点， 每个内结点有且仅有一个前趋结点和一个后继 结点。
非线性结构 结构中的结点可能有多个前趋结点和多个 后继结点。
基本概念
一行表示一个结点（元素），每个结点由学号、姓名、性别等九 个域（数据项）组成。 表的第一行是始结点；最后一行是终结点；中间的行都是内结点。 表的逻辑结构是线性结构。
逻辑结构
数据元素之间的逻辑关系。
存储结构
逻辑结构在存储器中的映象。
基本概念
数据的逻辑结构，可形式表示为二元组：
L = ( N, R )
其中 N 是结点的有限集合 R 是 N 上的关系集合
例子
L = ( N, R ) N = { a0, a1, a2 } R={r} r = { ( a0, a1 ), ( a0, a2 ) }
基本概念
目前不存在证明算法正确性的形式化方法 算法正确性的四个层次
程序中不含语法错误； 程序对于几组输入数据能够得出满足要求的结果； 程序对于精心选择的、典型、苛刻且带有刁难性的 几组输入数据能够得出满足要求的结果； 程序对于一切合法的输入数据都能得出满足要求的 结果；
基本概念
算法效率的衡量方法和准则 两种方法