Introduction to Algorithms

合集下载

第1章算法设计与分析绪论

• 求gcd(m,n)的原理：（结构化的描述） • 第一步：如果n=0,返回m的值作为结果，结束；否则进入第二步。 • 第二步：用n除m,余数赋值给r，进入第三步。 • 第三步：将n的值赋给m，将r的值赋给n，返回第一步。
例： gcd(60,24)=? 1-1、m=60, n=24 1-2、60 mod 24=12, r=12, 1-3、m=24, n=12 2-1、24 mod 12=0,r=0 2-2、m=12, n=0 2-3、条件“n=0”满足，返回gcd(m, n)=m=12
• 算法二：连续整数检测法
第一步：将min{m,n}赋值给t。第二步：m除以t，如果余数为0，进入第三步，否则进入第四步。第三步：n除以t，如果余数为0，返回t的值；否则进入第四步。第四步：把t的值减1，返回第三步。例：gcd(60, 24) t=min{60, 24}=24, m=60, n=24 60mod24=12≠0, t=23, 24 mod 23=1 ≠0 t=22, 24 mod 22=2 ≠0 t=21, 24 mod 21=3 ≠0 ….. t=12, 24 mod 12=0, 返回gcd(m, n)=t=12
第1章绪论
1.1 什么是算法 1.2 算法问题求解基础 1.3 重要问题类型 1.4 基本数据结构本章小结
1.1 算法的概念
• 没有一个统一的严谨的定义。一般而言，对于计算机算法的概念是这样描述的：算法是在有限步骤内求解某一问题所使用的一组定义明确的指令。 • 本书采用的定义：An algorithm is a sequence of unambiguous instructions for solving a problem=算法是求解某一问题所使用的一系列清晰的指令。

Algorithms Chapter 1 绪论

怎么处理？
30
The Design and Analysis of Algorithms
Chapter 1 Introduction to Algorithms
What’s an Algorithm?
算法是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。
16
The Design and Analysis of Algorithms
算法可以解决哪些问题
找出人类DNA中所有100000种基因，确定构成人类DNA的30亿种化学基 17 对的各种序列。
The Design and Analysis of Algorithms
算法可以解决哪些问题
快速访问和检索互联网数据
The Design and Analysis of Algorithms
例子
• “贝格尔”编排法(Beiger Arrangement) 把参赛队数分一半(参赛队为单数时，最后以“0” 表示形成双数)，前一半由1号开始，自上而下写在左边；后一半的数自下而上写在右边，然后用横线把相对的号数连接起来。这即是第一轮的比赛。第二轮将第一轮右上角的编号(“0”或最大的一个代号数)移到左角上，第三轮又移到右角上，以此类推。即单数轮次时“0”或最大的一个代号在右上角，双数轮次时则在左上角。
//使用欧几里得算法计算gcd(m,n) //输入：两个不全为0的非负整数m,n //输出：m，n的最大公约数
28
The Design and Analysis of Algorithms
例子
• “贝格尔”编排法(Beiger Arrangement)
这种编排方法是否完美？

IntroductiontoAlgorithms第三版教学设计

Introduction to Algorithms第三版教学设计一、课程概要1.1 课程名称本课程名称为Introduction to Algorithms，是计算机科学专业必修课程。

1.2 学时安排本课程总共为72学时，每周3学时，共计24周。

1.3 教材《算法导论(原书第3版)》（英文版）（Introduction to Algorithms, Third Edition）。

1.4 教学目的本课程旨在使学生掌握算法与数据结构的基本概念、常用算法设计技巧和分析方法，并培养学生独立思考和解决问题的能力。

1.5 先修课程本课程的先修课程包括数据结构、离散数学、算法分析与设计等。

1.6 课程内容简介本课程包括以下内容：•算法基础知识•分治算法和递归•动态规划•贪心算法•图论算法•字符串匹配•NP完全性理论二、课程教学设计2.1 教学方法本课程采用理论讲授、实验操作、课堂讨论等多种教学方法相结合的方式，重视学生自主学习和动手实践的能力培养。

2.2 教学内容和教学进度本课程的教学内容和教学进度如下：第一讲：算法基础知识讲授主要内容包括算法的概念、算法的正确性和复杂度分析。

第二讲：分治算法和递归讲授主要内容包括分治算法的适用场景、递归的概念和应用。

第三讲：动态规划讲授主要内容包括动态规划的基本思想、常用动态规划算法和实践应用。

第四讲：贪心算法讲授主要内容包括贪心算法的基本思想、贪心算法设计和分析方法。

第五讲：图论算法讲授主要内容包括最短路径算法、最小生成树算法、网络流算法等。

第六讲：字符串匹配讲授主要内容包括朴素算法、KMP算法、Boyer-Moore算法等字符串匹配算法。

第七讲：NP完全性讲授主要内容包括P和NP问题的概念、NP完全性理论、NP问题求解方法等。

2.3 课堂互动与实践本课程还将开展相关实践项目，包括算法设计实验、算法实现与优化、算法竞赛和创新项目等，以培养学生动手实践和解决实际问题的能力。

Introduction_to_Algorithms

和式的界
思考题 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
第一部分基础知识
2 在学习本篇的内容时，我们建议读者不必一次将这些数学内容全部消化。先浏览一下这部分的各章，看看它们包含哪些内容，然后直接去读集中谈算法的章节。在阅读这些章节时，如果需要对算法分析中所用到的数学工具有个更好的理解的话，再回过头来看这部分。当然，读者也可顺序地学习这几章，以便很好地掌握有关的数学技巧。本篇各章的内容安排如下： • 第一章介绍本书将用到的算法分析和设计的框架。 • 第二章精确定义了几种渐近记号，其目的是使读者采用的记号与本书中的一致，而不在于向读者介绍新的数学概念。 • 第三章给出了对和式求值和限界的方法，这在算法分析中是常常会遇到的。 • 第四章将给出求解递归式的几种方法。我们已在第一章中用这些方法分析了合并排序，后面还将多次用到它们。一种有效的技术是“主方法”，它可被用来解决分治算法中出现的递归式。第四章的大部分内容花在证明主方法的正确性，读者若不感兴趣可以略过。 • 第五章包含了有关集合、关系、函数、图和树的基本定义和记号。这一章还给出了这些数学对象的一些基本性质。如果读者已学过离散数学课程，则可以略过这部分内容。 • 第六章首先介绍计数的基本原则，即排列和组合等内容。这一章的其余部分包含基本概率的定义和性质。
求和公式和性质 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 线性性质 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 算术级数 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 几何级数 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 调和级数 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 积分级数与微分级数 . . . . . . . . . . . . . . . . . . . . . . . . . . 39 套迭级数 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 积 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 数学归纳法 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 对项的限界 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 分解和式 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 积分近似公式 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

数据结构经典书籍

数据结构经典书籍摘要：一、数据结构的重要性二、数据结构的经典书籍介绍1.《数据结构与算法分析》2.《大话数据结构》3.《数据结构与算法》4.《算法导论》5.《数据结构与算法之美》三、如何选择适合自己的数据结构书籍四、结论正文：数据结构是计算机科学中至关重要的一个领域，掌握数据结构有助于编写高效、可读和可维护的代码。

在众多数据结构书籍中，有几本被广泛认为是经典之作。

本文将介绍其中的五本，并讨论如何选择适合自己的数据结构书籍。

1.《数据结构与算法分析》(Data Structures and Algorithm Analysis in Java)作者：Mark Allen Weiss这本书以Java 语言为例，详细讲述了数据结构和算法的基本概念、原理和实现。

书中包含大量实例和习题，适合初学者入门。

2.《大话数据结构》作者：程云本书采用轻松幽默的语言和丰富的图解，讲解了数据结构的基本原理和常用算法。

内容通俗易懂，适合编程初学者。

3.《数据结构与算法》(Data Structures and Algorithms)作者：Alfred V.Aho, John E.Hopcroft, and Jeffrey D.Ullman这本书是数据结构和算法的经典教材，详细介绍了各种数据结构及其操作，以及排序、查找等基本算法。

内容较为深入，适合已经掌握基本编程技能的读者。

4.《算法导论》(Introduction to Algorithms)作者：Thomas H.Cormen, Charles E.Leiserson, Ronald L.Rivest, and Clifford Stein本书全面讲述了算法设计与分析的基本概念，涵盖了许多经典算法和数据结构。

书中包含大量实例和习题，适合对算法有一定了解的读者深入学习。

5.《数据结构与算法之美》(The Art of Computer Programming, Volume 1: Fundamental Algorithms)作者：Donald E.Knuth本书是计算机编程艺术的卷一，讲述了计算机科学的基本算法。

MIT麻省理工学院算法导论公开课 Problem Set 4 solution

Introduction to Algorithms October 29, 2005 Massachusetts Institute of Technology 6.046J/18.410J Professors Erik D. Demaine and Charles E. Leiserson Handout 18Problem Set 4 SolutionsProblem 4-1. TreapsIf we insert a set of n items into a binary search tree using T REE-I NSERT, the resulting tree may be horribly unbalanced. As we saw in class, however, we expect randomly built binary search trees to be balanced. (Precisely, a randomly built binary search tree has expected height O(lg n).) Therefore, if we want to build an expected balanced tree for a ﬁxed set of items, we could randomly permute the items and then insert them in that order into the tree.What if we do not have all the items at once? If we receive the items one at a time, can we still randomly build a binary search tree out of them?We will examine a data structure that answers this question in the afﬁrmative. A treap is a binary search tree with a modiﬁed way of ordering the nodes. Figure 1 shows an example of a treap. As usual, each item x in the tree has a key key[x]. In addition, we assign priority[x], which is a random number chosen independently for each x. We assume that all priorities are distinct and also that all keys are distinct. The nodes of the treap are ordered so that (1) the keys obey the binary-search-tree property and (2) the priorities obey the min-heap order property. In other words,•if v is a left child of u, then key[v]<key[u];•if v is a right child of u, then key[v]>key[u]; and•if v is a child of u, then priority(v)>priority(u).(This combination of properties is why the tree is called a “treap”: it has features of both a binary search tree and a heap.)Figure 1: A treap. Each node x is labeled with key[x]:p riority[x]. For example, the root has key G and priority 4.It helps to think of treaps in the following way. Suppose that we insert nodes x1,x2,...,x n, each with an associated key, into a treap in arbitrary order. Then the resulting treap is the tree that wouldhave been formed if the nodes had been inserted into a normal binary search tree in the order given by their (randomly chosen) priorities. In other words, priority[x i]<priority[x j]means that x i is effectively inserted before x j.(a) Given a set of nodes x1,x2,...,x n with keys and priorities all distinct, show that thereis a unique treap with these nodes.Solution:Prove by induction on the number of nodes in the tree. The base case is a tree withzero nodes, which is trivially unique. Assume for induction that treaps with k−1orfewer nodes are unique. We prove that a treap with k nodes is unique. In this treap, theitem x with minimum priority must be at the root. The left subtree has items with keys<key[x]and the right subtree has items with keys >key[x]. This uniquely deﬁnes theroot and both subtrees of the root. Each subtree is a treap of size ≤k−1, so they areunique by induction.Alternatively, one can also prove this by considering a treap in which nodes are inserted in order of their priority. Assume for induction that the treap with the k−1nodes with smallest priority is unique. For k=0t his is trivially true. Now considerthe treap with the k nodes with smallest priority. Since we know that the structureof a treap is the same as the structure of a binary search tree in which the keys areinserted in increasing priority order, the treap with the k nodes with smallest priorityis the same as the treap with the k−1nodes with smallest priority after inserting thek-th node. Since BST insert is a deterministic algorithm, there is only one place thek-th node could be inserted. Therefore the treap with k nodes is also unique, provingthe inductive hypothesis.(b) Show that the expected height of a treap is O(lg n), and hence the expected time tosearch for a value in the treap is O(lg n).Solution: The idea is to realize that a treap on n nodes is equivalent to a randomlybuilt binary search tree on n nodes. Recall that assigning priorities to nodes as theyare inserted into the treap is the same as inserting the n nodes in the increasing orderdeﬁned by their priorities. So if we assign the priorities randomly, we get a randomorder of n priorities, which is the same as a random permutation of the n inputs, sowe can view this as inserting the n items in random order.The time to search for an item is O(h)where h is the height of the tree. As we saw inlecture, E[h]=O(lg n). (The expectation is taken over permutations of the n nodes,i.e., the random choices of the priorities.)Let us see how to insert a new node x into an existing treap. The ﬁrst thing we do is assign x a random priority priority[x]. Then we call the insertion algorithm, which we call T REAP-I NSERT, whose operation is illustrated in Figure 2.(e) (f)Figure 2: Operation of T REAP-I NSERT. As in Figure 1, each node x is labeled with key[x]: priority[x]. (a) Original treap prior to insertion. (b) The treap after inserting a node with key C and priority 25. (c)–(d) Intermediate stages when inserting a node with key D and priority 9.(e) The treap after insertion of parts (c) and (d) is done. (f) The treap after inserting a node with key F and priority 2.(c) Explain how T REAP-I NSERT works. Explain the idea in English and give pseudocode.(Hint: Execute the usual binary search tree insert and then perform rotations to restorethe min-heap order property.)Solution: The hint gives the idea: do the usual binary search tree insert and thenperform rotations to restore the min-heap order property.T REAP-I NSERT (T,x)inserts x into the treap T(by modifying T). It requires that xhas deﬁned key and priority values. We have used the subroutines T REE-I NSERT,R IGHT-R OTATE, and R IGHT-R OTATE as deﬁned in CLRS.T REAP-I NSERT (T,x)1T REE-I NSERT (T,x)2 while x =root[T]and priority[x]<priority[p[x]]3 do if x=left[p[x]]4 then R IGHT-R OTATE (T,p[x])5 else L EFT-R OTATE (T,p[x])Note that parent pointers simplify the code but are not necessary. Since we only needto know the parent of each node on the path from the root to x(after the call toT REE-I NSERT), we can keep track of these ourselves.(d) Show that the expected running time of T REAP-I NSERT is O(lg n). Solution:T REAP-I NSERT ﬁrst inserts an item in the tree using the normal binary search treeinsert and then performs a number of rotations to restore the min-heap property.The normal binary-search-tree insertion algorithm T REE-I NSERT always places thenew item at a new leaf of tree. Therefore the time to insert an item into a treap isproportional to the height of a randomly built binary search tree, which as we saw inlecture is O(lg n)in expectation.The maximum number of rotations occurs when the new item receives a priority lessthan all priorities in the tree. In this case it needs to be rotated from a leaf to the root.An upper bound on the number of rotations is therefore the height of a randomly builtbinary search tree, which is O(lg n)in expectation. (We will see that this is a fairlyloose bound.) Because each rotation take constant time, the expected time to rotate isO(lg n).Thus the expected running time of T REAP-I NSERT is O(lg n+lg n)=O(lg n).T REAP-I NSERT performs a search and then a sequence of rotations. Although searching and rotating have the same asymptotic running time, they have different costs in practice. A search reads information from the treap without modifying it, while a rotation changes parent and child pointers within the treap. On most computers, read operations are much faster than write operations. Thus we would like T REAP-I NSERT to perform few rotations. We will show that the expected number of rotations performed is bounded by a constant (in fact, less than 2)!(a) (b)Figure 3: Spines of a binary search tree. The left spine is shaded in (a), and the right spine is shaded in (b).In order to show this property, we need some deﬁnitions, illustrated in Figure 3. The left spine of a binary search tree T is the path which runs from the root to the item with the smallest key. In other words, the left spine is the maximal path from the root that consists only of left edges. Symmetrically, the right spine of T is the maximal path from the root consisting only of right edges. The length of a spine is the number of nodes it contains.(e) Consider the treap T immediately after x is inserted using T REAP-I NSERT. Let Cbe the length of the right spine of the left subtree of x. Let D be the length of theleft spine of the right subtree of x. Prove that the total number of rotations that wereperformed during the insertion of x is equal to C+D.Solution: Prove the claim by induction on the number of rotations performed. Thebase case is when x is the parent of y. Performing the rotation so that y is the new rootgives y exactly one child, so C+D=1.Assume for induction that the number of rotations k performed during the insertionof x equals C+D. The base case is when 0 rotations are necessary and x is insertedas a leaf. Then C+D=0. To prove the inductive step, we show that if after k−1rotations C+D=k−1, then after k rotations C+D=k. Draw a picture of aleft and right rotation and observe that C+D increases by 1 in each case. Let y bethe parent of x, and suppose x is a left child of y. After performing a right rotation, ybecomes the right child of x, and the previous right child of x becomes the left childof y. That is, the left spine of the right subtree of x before the rotation is tacked onto y, so the length of that spine increases by one. The left subtree of x is unaffectedby a right rotation. The case of a left rotation is symmetric. Therefore after one morerotation C+D increases by one and k=C+D, proving the inductive hypothesis.We will now calculate the expected values of C and D. For simplicity, we assume that the keys are 1,2,...,n. This assumption is without loss of generality because we only compare keys.�For two distinct nodes x and y , let k = key [x ]and i = key [y ], and deﬁne the indicator random variableX 1 if y is a node on the right spine of the left subtree of x (in T ),i,k =0 otherwise .(f) Show that X i,k =1if and only if (1) priority [y ]> priority [x ], (2) key [y ]< key [x ], and(3) for every z such that key [y ]< key [z ]< key [x ],we have p riority [y ]< priority [z ].Solution:To prove this statement, we must prove both directions of the “if and only if”. Firstwe prove the “if” direction. We prove that if (1) priority [y ]> priority [x ], (2) key [y ]<key [x ], and (3) for every z such that key [y ]< key [z ]< key [x ]are true, priority [y ]< priority [z ], then X i,k =1. We prove this by contradiction. Assume that X i,k =0. That is, assume that y is not on the right spine of the left subtree of x . We show thatthis leads to a contradiction. If y is not on the right spine of the left subtree of x ,it could be in one of three places:1. Suppose y is in the right subtree of x . This contradicts condition (2) becausekey [y ]< key [x ].2. Suppose y is not in one of the subtrees of x . Then x and y must share somecommon ancestor z . Since key [y ]< key [x ], we know that y is in the left subtreeof z and x is in the right subtree of z and key [y ]< key [z ] < key [x ]. Since y isbelow z in the tree, priority [z ]< priority [x ]and priority [z ]< priority [y ]. Thiscontradicts condition (3).3. Suppose that y is in the left subtree of x but not on the right spine of the leftsubtree of x . This implies that there exists some ancestor z of y in the left subtreeof x such that y is in the left subtree of z . Hence key [y ]< key [z ]< key [x ]. Sincez is an ancestor of y , priority [z ]< priority [y ], which contradicts condition (3).All possible cases lead to contradictions, and so X i,k =1.Now for the “only if” part. We prove that if X i,k =1, then statements (1), (2), and (3) are true. If X i,k =1, then y is in the right spine of the left subtree of x . Since y is ina subtree of x , y must have been inserted after x ,so p riority [y ]> priority [x ], proving(1). Since y is in the left subtree of x , key [y ]< key [x ], proving (2). We prove (3) by contradiction: suppose that X i,k =1and there exists a z such that key [y ]< key [z ]< key [x ]and priority [z ]< priority [y ]. In other words, z was inserted before y . There arethree possible cases that satisfy the condition key [z ]< key [x ]:1. Suppose z is in the right spine of the left subtree of x .For y to be inserted into theright spine of the left subtree of x , it will have to be inserted into the right subtreeof z . Since key [y ]< key [z ], this leads to a contradiction.2. Suppose z is in the left subtree of x but not in the right spine. This implies thatz is in the left subtree of some node z in the right spine of x . Therefore for y tobe inserted into the right spine of the left subtree of x , it must be inserted into theright subtree of z . This leads to a contradiction by reasoning similar to case 1.3. Suppose that z is not in one of the subtrees of x . Then z and x have a commonancestor z such that z is in the left subtree of z and x is in the right subtree of x .This implies key [z ] < key [z ] < key [x ]. Since key [y ]< key [z ]< key [z ], y cannotbe inserted into the right subtree of z . Therefore it cannot be inserted in a subtreeof x , which is a contradiction.Therefore there can be no z such that key [y ] < key [z ] < key [x ] and priority [z ] < priority [y ]. This proves statement (3). We have proven both the “if” and “only if” directions, proving the claim.(g) Show that(k − i − 1)! 1 Pr {X i,k =1} == . (k − i +1)! (k − i +1)(k − i )Solution: We showed in the previous part that X i,k =1if and only if the priorities of the items between y and x are ordered in a certain way. Since all orderings are equally likely, to calculate the probability we count the number of permutations of priorities that obey this order and divide by the number of total number of priority permutations. We proved in (e) that whether or not X i,k =1depends only on the relative ordering of the priorities of y , x , and all z such that key [y ] < key [z ] < key [x ]. Since we assumed that the keys of the items come from {1,...,n }, the keys of the items in question are i,i +1,i +2,...,k − 1,k . There are (k − i +1)!permutations of the priorities of these items. Of these permutations, the ones for which X i,k =1are those where i has minimum priority, k has the second smallest priority, and the priorities of the remaining k − i − 1 items follow in any order. There are (k − i − 1)! of these permutations. Thus the probability that we get a “bad” order is (k −i −1)!/(k −i +1)!= 1/(k − i )(k − i +1).(h) Show thatk −1 � 1 1 E [C ]= =1− . j (j +1)k j =1 Solution:X For a node x with key k , E [C ]is the expected number of nodes in the right spine of the left subtree of x . This equals the sum of the expected value of the random variables i,k for all i in the tree. Since X i,k =0for all nodes i ≥ k , we only need to consider i <k .� � � k −1 �k −1 � E [C ]=E [X i,k ]=E X i,k i =1 i =1 k −1 =Pr {X i,k =1}i =1 k −1 � 1 =(k − i )(k − i +1) i =1 k −1 � 1= j (j +1)j =1 1To simplify this sum, observe that j (j 1+1) = j +1−j = − 1 . Therefore the sumj (j +1) j j +1 telescopes and we have 1 E [C ]=1− . kIf you didn’t see this, you could have proven that the equationk −1 � 1 1 =1− j (j +1)k j =1 holds by induction on k . In the proving the inductive hypothesis you might have 11discovered 1 − = .j j +1 j (j +1)(i) Use a symmetry argument to show that1 E [D ]=1− . n − k +1Solution: The idea is to consider the treap produced if the ordering relationship amongthe keys is reversed. That is, for all items x , leave priority [x ]unchanged but replacekey [x ]with n − key [x ]+1.Let T be the binary tree we get when inserting the items (in increasing order of priority) using the original keys. Once we remap the keys and insert them into a newbinary search tree, we get a tree T whose shape is the mirror image of the shape ofT . (reﬂected left to right). Consider the item x with key k in T and therefore has key n − k +1 i n T . The length of the left spine of x ’s right subtree in T has becomethe length of the right spine of x ’s left subtree in T . We know by part (g) that the expected length of the right spine of a left subtree of a node y is 1− 1/idkey [y ],so the expected length of the right spine of the left subtree of x in T is 1− 1/(n − k +1), which means that 1 E [D ]=1− . n − k +1(j) Conclude that the expected number of rotations performed when inserting a node into a treap is less than 2.Solution:11 E [number of rotations ]= E [C +D ]=E [C ]+E [D ]=1− +1− k n − k +1 ≤ 1+1=2. Problem 4-2. Being balancedCall a family of trees balanced if every tree in the family has height O (lg n ), where n is the number of nodes in the tree. (Recall that the height of a tree is the maximum number of edges along any path from the root of the tree to a leaf of the tree. In particular, the height of a tree with just one node is 0.)For each property below, determine whether the family of binary trees satisfying that property is balanced. If you answer is “no”, provide a counterexample. If your answer is “yes”, give a proof (hint: it should be a proof by induction). Remember that being balanced is an asymptotic property, so your counterexamples must specify an inﬁnite set of trees in the family, not just one tree. (a) Every node of the tree is either a leaf or it has two children.Solution: No. Counterexample is a right chain, with each node having a leaf hanging off to the left(b) The size of each subtree can be written as 2k − 1, where k is an integer (k is not the same for each subtree).Solution: Yes.Consider any subtree with root r . We know from the condition that the size of this subtree is 2k 1 − 1. We also know that the size of the subtree rooted at the left child of r is 2k 2 − 1, and the size of the subtree rooted at the right child of r is 2k 3 − 1. But the size of the subtree at r is simply the node r together with the nodes in the left and right subtrees. This leads to the equation 2k 1 − 1=1+(2k 2 − 1)+(2k 3 − 1),or 2k 1 =2k 2 +2k 3. Now we show that k 2 =k 3. This is easy to see if you consider the binary representations of k 1, k 2, and k 3.Otherwise, if we assume WLOG that k 2 ≤ k 3, then we have 2k 1−k 2 =1+2k 3−k 2. 2Now, the only pair of integer powers of 2 that could satisfy this equation are 21 and 0 . Thus k 3 − k 2 =0,or k 2 =k 3, and the left and right subtrees of r have an equal number of nodes. It follows that the tree is perfectly balanced.(c) There is a constant c>0such that, for each node of the tree, the size of the smallerchild subtree of this node is at least c times the size of the larger child subtree.Solution:Yes1. The proof is by induction. Assume that the two subtrees of x with n nodes in itssubtree has two children y and z with subtree sizes n1 and n2. By inductive hypothesis,the height of y’s subtree is at most d lg n1 and the height of z’s subtree is at most d lg n2for some constant d. We now prove that the height of x’s subtree is at most d lg n.Assume wlog that n1 ≥n2. Therefore, by the problem statement, we have n2 ≥cn1.Therefore, we have n=n1 +n2 +1≥(1+c)n1 +1≥(1+c)n1 and the height hof x’s subtree is d lg n1 +1≤d lg(n/(c+1))+1≤d lg n−d lg(1+c)+1≤d lg nif d lg(1+c)≥1. Therefore, for sufﬁciently large d, the height of a tree with n nodesis at most d lg n.(d) There is a constant c such that, for each node of the tree, the heights of its childrensubtrees differ by at most c.Solution: Yes1. Let n(h)be the minimum number of nodes that a tree of height h thatsatisﬁes the stated property can have. We show by induction that n(h)≥(1+α)h−1,for some constant 0<α≤1. We can then conclude that for a tree with n nodes,h≤log1+α(n+1)=O(lg n).For the base case, a subtree of height 0has a single node, and 1≥(1+α)0 −1forany constant α≤1.In the inductive step, assume for all trees of height k<h, that the n(k)≥(1+α)k−1.Now consider a tree of height h, and look at its two subtrees. We know one subtreemust have height h−1, and the other must have height at least h−1−c. Therefore,we known(h)≥n(h−1)+n(h−1−c)+1.Using the inductive hypothesis, we getn(h) ≥(1+α)h−1 −1+(1+α)h−1−c−1+1≥2(1+α)h−1−c−1.Suppose we picked αsmall enough so that (1+α)<21/(c+1). Then (1+α)c+1 <2.Therefore, we getn(h)≥2(1+α)h−1−c−1≥(1+α)h−1.1Note that in this problem we assume that a nil pointer is a subtree of size 0, and so a node with only one child has two subtrees, one of which has size 0. If you assume that a node with only one child has only one subtree, then the answer to this problem part is “no”.�11Handout18: Problem Set4SolutionsTherefore, we satisfy the inductive hypothesis.Note that if we plug this value for αback into h≤log1+α(n+1),we getlg(n+1)h≤≤(c+1)l g(n+1).lg(1+2c+1)(e) The average depth of a node is O(lg n). (Recall that the depth of a node x is thenumber of edges along the path from the root of the tree to x.)Solution: No.√Consider a tree with n−n nodes organized as a complete binary tree, and the other √ √n nodes sticking out as a chain of length n from the balanced tree. The height of√√√the tree is lg(n−n)+n=Ω(n), while the average depth of a node is at most�√√ √(1/n)n·(n+lg n)+(n−n)·lg n√√=(1/n)(n+n lg n+n lg n−nlgn)=(1/n)(n+n lg n)=O(lg n)√Thus, we have a tree with average node depth O(lg n), but height Ω(n).。

introduction-to-algorithms-13144

Data Structures
The IP packet forwarding is a Data Structure problem! Efficiency, scalability is very important.

Similarly, how does Google find the documents matching your query so fast? Uses sophisticated algorithms to create index structures, which are just data structures. Algorithms and data structures are ubiquitous. With the data glut created by the new technologies, the need to organize, search, and update MASSIVE amounts of information FAST is more severe than ever before.

Role of Algorithms in Modern World

Enormous amount of data Network traffic (telecom billing, monitoring) Database transactions (Sales, inventory) Scientific measurements (astrophysics, geology) Sensor networks. RFID tags Radio frequency identification (RFID) is a method of remotely storing and retrieving data using devices called RFID tags. Bioinformatics (genome, protein bank)

有关于计算机科学与技术专业的书籍

有关于计算机科学与技术专业的书籍English Answer：1. Introduction to Algorithms by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein: This classic textbook provides a comprehensive introduction to the fundamental algorithms used in computer science. It covers topics such as sorting, searching, dynamic programming, and graph algorithms.2. The Art of Computer Programming by Donald E. Knuth: This multi-volume series is considered a masterpiece of computer science literature. It covers a wide range of topics, including algorithms, data structures, and programming techniques.3. Computer Architecture: A Quantitative Approach by John L. Hennessy and David A. Patterson: This textbook provides a thorough introduction to computer architecture, covering topics such as processor design, memory systems,and I/O devices.4. Operating Systems: Three Easy Pieces by Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau: This textbook provides a concise and accessible introduction to operating systems, covering topics such as processes, threads, memory management, and file systems.5. Computer Networks: A Top-Down Approach by James F. Kurose and Keith W. Ross: This textbook provides a comprehensive introduction to computer networks, covering topics such as network protocols, routing algorithms, and network security.6. Database Systems: The Complete Book by HectorGarcia-Molina, Jeffrey D. Ullman, and Jennifer Widom: This textbook provides a comprehensive introduction to database systems, covering topics such as data models, query processing, and transaction management.7. Programming Language Concepts by Robert W. Sebesta: This textbook provides a comprehensive introduction toprogramming language concepts, covering topics such as syntax, semantics, and programming paradigms.8. Software Engineering: A Practitioner's Approach by Roger S. Pressman: This textbook provides a practical introduction to software engineering, covering topics such as software development process models, software design principles, and software testing techniques.9. Artificial Intelligence: A Modern Approach by Stuart Russell and Peter Norvig: This textbook provides a comprehensive introduction to artificial intelligence, covering topics such as search algorithms, machine learning, and natural language processing.10. Machine Learning by Tom M. Mitchell: This textbook provides a comprehensive introduction to machine learning, covering topics such as supervised learning, unsupervised learning, and reinforcement learning.Chinese Answer：1. 算法导论（Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest、Clifford Stein），这本经典教材全面介绍了计算机科学中使用的基本算法。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

• 本文對基本算法説明的基本方式
– 説明算法的基本原理 – 給出由此算法解決的實例
定義我們要解決的問題
給定有待排序的N 給定有待排序的N個項目 R1,R2,…,RN 我們稱這些項目為記錄(record),並稱N 我們稱這些項目為記錄(record),並稱N個記錄的整個集合為一個文件(file)。每一個R 個集合為一個文件(file)。每一個Rj有一個鍵碼 (key) Kj ，支配排序過程。排序的目標，是確定下標為{1,2,…,N}的一個排列排序的目標，是確定下標為{1,2,…,N}的一個排列 p(1) p(2)…p(N),它以非遞降的次序來放置所有的 p(2)…p(N),它以非遞降的次序來放置所有的鍵碼： Kp(1) ≤ Kp(2) ≤ …≤ Kp(N)
合併兩個已經排列好的序列
MERGE(A, p, q, r)
1 n1 ← q - p + 1 2 n2 ← r - q 3 create arrays L[1 ‥ n1 + 1] and R[1 ‥ n2 + 1] 4 for i ← 1 to n1 5 do L[i] ← A[p + i - 1] 6 for j ← 1 to n2 7 do R[j] ← A[q + j] 8 L[n1 + 1] ← ∞ 9 R[n2 + 1] ← ∞ 10 i ← 1 11 j ← 1 12 for k ← p to r 13 do if L[i] ≤ R[j] 14 then A[k] ← L[i] i←i+1 15 16 else A[k] ← R[j] 17 j←j+1
算法講義
目的
• 算法(algorithm)是一個優秀程序員的基本功，算法(algorithm)
本文章介紹了算法的基本概念和一些基本的算法，希望可以起到抛磚引玉的作用
内容
• 本講義分爲以下3大部分本講義分爲以下3
– 基本概念 – 排序 – 基本算法
定義
• 算法是把一些輸入經過一系列的運算轉化
• The merge sort algorithm closely follows the • • •
divide-anddivide-and-conquer paradigm. Intuitively, it operates as follows. Divide: Divide the n-element sequence to be sorted into two subsequences of n/2 elements each. Conquer: Sort the two subsequences recursively using merge sort. Combine: Merge the two sorted subsequences to produce the sorted answer.
The operation of INSERTION-SORT on the array A = 〈5, 2, 4, 6, 1, 3〉. INSERTION3〉
The divide-and-conquer approach divide-and• 把一個問題切分成幾個與原問題相似,但是把一個問題切分成幾個與原問題相似,
調整最大堆
MAXMAX-HEAPIFY(A, i)
1 l ← LEFT(i) 2 r ← RIGHT(i) 3 if l ≤ heap-size[A] and A[l] > A[i] heap4 then largest ← l 5 else largest ← i 6 if r ≤ heap-size[A] and A[r] > A[largest] heap7 then largest ← r 8 if largest ≠ i 9 then exchange A[i] ↔ A[largest] 10 MAX-HEAPIFY(A, largest) MAX-
The operation of PARTITION on a sample array.
思考
• 至今爲止介紹的排序有什麽共同點？ • 排列的順序是基於比較的排列的順序是基於比較的 • 我們稱這些排序算法為comparison sorts
The decision-tree model decision• 一個decision-tree是一棵完全二插樹，，它一個decision-tree是一棵完全二插樹，，它
The operation of HEAPSORT.
QuickSort
• 取一個記錄，並把它移動到在排了序的文
件中它將佔據的最終位置 • 更偏愛一個無次序的序列
分割文件
PARTITION(A, p, r)
1 2 3 4 5 6 7 8
x ← A[r] i←p-1 for j ← p to r - 1 do if A[j] ≤ x then i ← i + 1
内精確的完成
算法解決了什麽
• 人類基因工程 • 網絡查詢信息 • 電子商務 • 最佳分配 • 衆多的數學問題(4色問題) 衆多的數學問題(4色問題)
對算法的説明
• 本文對排序説明的基本方式
– 説明算法的基本原理 – 給出算法的偽代碼，對任何一門語言熟悉的讀者都將可以輕鬆的讀懂 – 給出算法的圖例
規模比原問題小的子問題, 規模比原問題小的子問題,遞歸的求解這些子問題,最後再把這些結果組合起來, 子問題,最後再把這些結果組合起來,得到原問題的解. 問題的解. • 分爲3個步驟: 分爲3個步驟:
– 把問題切分為子問題 – 分別解決每一個子問題 – 把子問題的解綜合得到原問題的解
MergeSort
代表了用特殊的比較算法對給定的輸入中的元素進行的比較
The decision tree for insertion sort operating on three elements
comparison sorts的最優情況分析 sorts的最優情況分析
1 for j ← 2 to length[A] 2 do key ← A[j] 3 ▹ Insert A[j] into the sorted sequence A[1 ‥ j - 1]. 4 i←j-1 5 while i > 0 and A[i] > key 6 do A[i + 1] ← A[i] 7 i←i-1 8 A[i + 1] ← key
HeapSort
• 實際上是一種選擇排序 • 使用堆作爲數據結構，首先安排文件，使
得它形成一個堆，然後反復撤銷堆頂，並把它傳送到適當的最後位置 • 優先隊列的實現原理就是堆
堆
• 堆，作爲一種基礎的數據結構，可以被看
成是一棵近似的完全二叉樹 • 每個節點的值都大於(小於)或等於其子節點每個節點的值都大於(小於) 值的樹 • 分爲最大堆和最小堆 • 最大堆的性質：
爲什麽要排序
• 在算法的學習中，是最基本的問題
– 在應用中經常需要排序 – 排序算法衆多，並且運用了不同的技術 – 排序是一個有最優解決方案的算法 – 很多算法需要以排序作爲基礎 – 排序之前還需要考慮許多工程學的問題
排序分類
• 排序可分爲内部排序和外部排序 • 在内部排序中，記錄被整個的保留在計算
機的高速隨機存取存儲器中 • 當記錄比内存一次所能容納的還多時，則使用外部排序
當著手解決一個問題的時候當著手解決一個問題的時候先找出某些相當明顯的解決先找出某些相當明顯的解決方法然後再試圖改進它然後再試圖改進它往往是明智的
我們所涉及到的排序
• InsertSort • MergeSort • QuickSort • HeapSort • Counting sort • Bucket sort
– 對序列A，滿足條件A[PARENT(i)] ≥ A[i] 對序列A – 在Root保存的是堆中的最大值 Root保存的是堆中的最大值
A max-heap viewed as (a) a binary tree and (b) an array. The maxnumber within the circle at each node in the tree is the value stored at that node. The number above a node is the corresponding index in the array. Above and below the array are lines showing parentparentchild relationships; parents are always to the left of their children. The tree has height three; the node at index 4 (with value 8) has height one.
The action of MAX-HEAPIFY(A, 2), where heap-size[A] = 10. MAXheap-
創建一個堆
BUILD-MAXBUILD-MAX-HEAP(A)
1 heap-size[A] ← length[A] heap2 for i ← ⌊length[A]/2⌋ downto 1 ]/2⌋ 3 do MAX-HEAPIFY(A, i) MAX-
The operation of BUILD-MAX-HEAP, showing the data structure BUILD-MAXbefore the call to MAX-HEAPIFY MAX-
堆排序
HEAPSORT(A)
1 BUILD-MAX-HEAP(A) BUILD-MAX2 for i ← length[A] downto 2 3 do exchange A[1] ↔ A[i] 4 heapheap-size[A] ← heap-size[A] - 1 heap5 MAX-HEAPIFY(A, 1) MAX-