有哪些用 Python 语言讲算法和数据结构的书_百度知道
有哪些用 Python 语言讲算法和数据结构的书
我有更好的答案
直接看python相关教程就行啦，麦子学院、百度传课、腾讯课堂、网易云课堂里面都有
其他类似问题
为您推荐：
您可能关注的推广
python的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁Python数据结构与算法--算法分析
一个有趣的问题经常出现，那就是两个看似不同的程序，到底哪个更好呢?
要回答这个问题, 我们必须知道程序和代表程序的算法有很大的区别. 算法是一个通用的, 解决问题的一条条的指令. 提供一个解决任何具有指定输入的实例问题方法, 算法产生期望的结果. 一个程序, 另一方面, 是将算法用某一门语言代码实现. 有很多的程序实现的同一算法, 取决于程序员和编程语言的使用.
进一步的探究这种差异, 考察下面的函数代码. 这个函数解决一个简单的问题, 计算前n个自然数的和. 解决方案遍历这 n 个整数, 相加后赋值到累加器.
def sumOfN(n):
& &theSum = 0
& &for i in range(1,n+1):
& & & &theSum = theSum + i
& &return theSum
print(sumOfN(10))
接下来看下面的代码. 第一眼看上去感觉很奇怪, 但是深入理解之后你将发现这个函数和上面的函数完成同样的工作. T原因是这个函数不是那么明显，代码难看. 我们没有使用好的变量名导致可读性很差, 并且还声明了没有必要声明的变量.
def foo(tom):
& & fred = 0
& & for bill in range(1,tom+1):
& & & &barney = bill
& & & &fred = fred + barney
& & return fred
print(foo(10))
到底哪段代码更好呢.问题的答案取决于你的标准.如果你只关注可读性，函数sumOfN 肯定比 foo 好. 事实上, 你可能在你的编程启蒙课上见到过很多教你编写可读性好和易于理解的程序的例子. 然而在这里, 我们还对算法感兴趣.&
作为替代空间的需求, 我们基于它们执行时间来分析和比较算法. 这种度量有时候被称为算法的&执行时间&或&运行时间&. 我们测量 sumOfN 函数执行时间的一种方法是做个基准分析. 在, 我们可以通过一个函数针对我们所使用的上标记程序的起始和结束时刻. 在 time 模块有一个被称为 time 的函数，将返回系统的当前时间. 通过两次调用这个函数, 起始和结束, 然后计算差值, 我们可以得到准确的执行时间.
import time
def sumOfN2(n):
& &start = time.time()
& &theSum = 0
& &for i in range(1,n+1):
& & & theSum = theSum + i
& &end = time.time()
& &return theSum,end-start
Listing 1 展示了sumOfN 函数在求和前后的时间开销. 测试结果如下:
&&&for i in range(5):
& & & &print(&Sum is %d required %10.7f seconds&%sumOfN(10000))
required &0.0018950 seconds
required &0.0018620 seconds
required &0.0019171 seconds
required &0.0019162 seconds
required &0.0019360 seconds
我们发现时间相当的一致并且都平均花费 0.0019 秒执行程序. 那么假如我们将n增大到 100,000 会怎样呢?
&&&for i in range(5):
& & & &print(&Sum is %d required %10.7f seconds&%sumOfN(100000))
required &0.0199420 seconds
required &0.0180972 seconds
required &0.0194821 seconds
required &0.0178988 seconds
required &0.0188949 seconds
再次, 时间更长, 非常的一致, 平均10倍的时间. 将 n 增大到 1,000,000 我们达到:
&&&for i in range(5):
& & & &print(&Sum is %d required %10.7f seconds&%sumOfN(1000000))
required &0.1948988 seconds
required &0.1850290 seconds
required &0.1809771 seconds
required &0.1729250 seconds
required &0.1646299 seconds
在这种情况下, 平均执行时间又一次被证实是之前的10倍.
现在来看一下 Listing 2, 提出了一个不同的解决求和问题的方法. 这个函数, sumOfN3, 运用了一个等式：&ni = (n+1)n/2来计算前 n 个自然数取代循环计算.
def sumOfN3(n):
& &return (n*(n+1))/2
print(sumOfN3(10))
如果我们针对 sumOfN3 做一些测试, 使用5种不同的n值(10,000, 100,000, 1,000,000, 10,000,000, and 100,000,000), 我们得到下面的结果:
required 0. seconds
required 0. seconds
required 0. seconds
Sum is 00 required 0. seconds
Sum is 0000 required 0. seconds
对于这个输出，有两个方面需要注意. 第一, 上面程序的运行时间比前面的任意一个的运行时间都短. 第二, 无论n为多大执行时间都是一致的.&
但是这个标准真正地告诉我们什么?直观地说, 我们可以看到，迭代的解决方案似乎是因为一些程序步骤被重复而做更多的工作. 这是它占用更多运行时间可能的原因. 当我们增加 n的时候循环方案执行时间也在增加. 然而,有一个问题. 如果我们跑相同的功能在不同的计算机或使用不同的编程语言,我们可能会得到不同的结果. 如果是老式计算机将可能在 sumOfN3上执行更多的时间.
我们需要一种更好的方式来描述这些算法的执行时间。基准的方法计算实际的执行时间。它并不真的为我们提供了一个有用的测量，因为它是依赖于特定的机器，当前时间，编译，和编程语言。相反，我们要有一个特性，是独立于程序或计算机的使用。这一方法将独立地判断使用的算法是有用的，可以用来在实现算法比较。
一个易位构词实例
一个展示算法不同的数量级的例子是经典的字符串易位问题. 一个字符串和另一个字符串如果仅仅是字母的位置发生改变我们就称为易位. 例如, 'heart' 和 'earth' 就互为易位. 字符串'python'和 'typhon' 也是. 为简化问题的讨论,我们假设字符串中的字符为26个英文字母并且两个字符串的长度相同. 我们的目标是写一个boolean 类型的函数来判断两个给定的字符串是否互为易位.
方法1: 逐一检测
对于易位问题，我们的第一个解决方案是检测第一个字符串的每一个字母是否在第二个字符串中. 如果成功检测所有的字母, 那么两个字符串是易位的. 检查一个字母成功后将使用 Python的特殊值 None 取代. 然而, 因为在 Python 中string是不可变的, 第一步将字符串转换成 list. 看下面的代码：
def anagramSolution1(s1,s2):
& & alist = list(s2)
& & pos1 = 0
& & stillOK = True
& & while pos1 & len(s1) and stillOK:
& & & & pos2 = 0
& & & & found = False
& & & & while pos2 & len(alist) and not found:
& & & & & & if s1[pos1] == alist[pos2]:
& & & & & & & & found = True
& & & & & & else:
& & & & & & & & pos2 = pos2 + 1
& & & & if found:
& & & & & & alist[pos2] = None
& & & & else:
& & & & & & stillOK = False
& & & & pos1 = pos1 + 1
& & return stillOK
print(anagramSolution1('abcd','dcba'))
方法2: 排序比较
另一个解决方案基于的思想是：即使两个字符串 s1 和 s2 不同, t它们易位当且仅当它们包含完全相同的字母集合. 因此, 如果我们首先将两个字符串的字符按照字典排序, 如果两个字符串易位，那么我们将得到完全一样的两个字符串. 在 Python 我们可以使用list的内建方法 sort 来简单的实现排序.看下面的代码：
def anagramSolution2(s1,s2):
& & alist1 = list(s1)
& & alist2 = list(s2)
& & alist1.sort()
& & alist2.sort()
& & pos = 0
& & matches = True
& & while pos & len(s1) and matches:
& & & & if alist1[pos]==alist2[pos]:
& & & & & & pos = pos + 1
& & & & else:
& & & & & & matches = False
& & return matches
print(anagramSolution2('abcde','edcba'))
第一眼看上去，你可能认为程序的时间复杂度为O(n), 因为只有一个简单的比较n个字母的循环. 然而, 两次调用 Python sort 函数都没有考虑开销. 以后我们会介绍, 排序将花费的时间复杂度为 O(n2) 或 O(nlogn), 于是排序相比循环占主导地位.
方法3: 暴力
一个 brute force 计数方法是枚举出所有的可能性. 对于这个问题, 我们可以使用 s1 的字母简单地生成所有的可能字符串并看 s2 是否出现. 然而,这种方法有一个难点. 我们列举出s1的所有可能性,第一个字母有 n 种可能,第二个位置有n-1种可能, 第三个位置有n-2种可能,&&. 总共的可能性为：n*(n-1)*(n-1)*3*2*1 = n!.已经证明 n!递增非常快,当n非常大的时候, n! 递增速度超过 2n .
方法4: 计算和比较
最后一个解决方案是基于这样的一个事实：任意两个易位的字符串都有相同的'a'的数目,相同的'b'的数目,相同的'c'的数目&&. 为了判断两个字符串是否易位,我们首先计算每一个字母的次数. 因为只有26个可能的字母, 我们可以使用一个list来保存26个计数, 每一个保存可能的字母. 每次当我们看到一个特别的字母，我们就增加对应的计数. 最后, 如果两个list的对应计数完全相同, 两个字符串就是易位的. 看下面的代码：
def anagramSolution4(s1,s2):
& & c1 = [0]*26
& & c2 = [0]*26
& & for i in range(len(s1)):
& & & & pos = ord(s1[i])-ord('a')
& & & & c1[pos] = c1[pos] + 1
& & for i in range(len(s2)):
& & & & pos = ord(s2[i])-ord('a')
& & & & c2[pos] = c2[pos] + 1
& & stillOK = True
& & while j&26 and stillOK:
& & & & if c1[j]==c2[j]:
& & & & & & j = j + 1
& & & & else:
& & & & & & stillOK = False
& & return stillOK
print(anagramSolution4('apple','pleap'))
依然, 这种解决方案包含大量的循环. 然而, 与第一种方案不同, 它们都没有被嵌入. 前两个循环方案都在n的基础上计算字母. 第三个方案的循环, 比较两个字符串中counts的数目, 只需要 26 步 因为一个字符串只有26种可能的字母. 累加在一起我们得到 T(n)=2n+26 步. 即是 O(n). 我们找到了这个问题的线性时间解法.
离开这个例子之前，我们需要说的是空间开销.虽然最后的解决方案能够在线性时间内运行，它能成功必须要通过使用额外的存储保持两个列表中的字符数。换句话说，该算法使用了空间换时间.
这是一种常见的情况. 在许多场合，你需要做出决定的时间和空间之间的权衡。在目前的情况下，额外空间量是不显著的。然而，如果下面的字母有数百万字，就必须更多的关注空间开销。作为一个计算机科学家，当在选定算法的时候，主要由你来决定如何利用计算机资源来解决一个特定的问题.
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'有没有用Python讲解数据结构和算法的书或者公开课_百度知道
有没有用Python讲解数据结构和算法的书或者公开课
提问者采纳
htmlhttps。如果解决了您的问题请采纳.com/course/cs215都是python相关的算法或者数据结构讲解.udacity：
来自团队：
其他类似问题
为您推荐：
python的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁有哪些用 Python 语言讲算法和数据结构的书？
按投票排序
1.Python数据结构篇数据结构篇主要是阅读[Problem Solving with Python]() [该网址链接可能会比较慢]时写下的阅读记录，当然，也结合了部分[算法导论]()中的内容，此外还有不少wikipedia上的内容，所以内容比较多，可能有点杂乱。这部分主要是介绍了如何使用Python实现常用的一些数据结构，例如堆栈、队列、二叉树等等，也有Python内置的数据结构性能的分析，同时还包括了搜索和排序(在算法设计篇中会有更加详细的介绍)的简单总结。每篇文章都有实现代码，内容比较多，简单算法一般是大致介绍下思想及算法流程，复杂的算法会给出各种图示和代码实现详细介绍。**这一部分是下面算法设计篇的前篇，如果数据结构还不错的可以直接看算法设计篇，遇到问题可以回来看数据结构篇中的某个具体内容充电一下，我个人认为直接读算法设计篇比较好，因为大家时间也都比较宝贵，如果你会来读这些文章说明你肯定有一定基础了，后面的算法设计篇中更多的是思想，这里更多的是代码而已，嘿嘿。**(1)[搜索]() 简述顺序查找和二分查找，详述Hash查找(hash函数的设计以及如何避免冲突)(2)[排序]()
简述各种排序算法的思想以及它的图示和实现(3)[数据结构]()
简述Python内置数据结构的性能分析和实现常用的数据结构：栈、队列和二叉堆(4)[树总结]()
简述二叉树，详述二叉搜索树和AVL树的思想和实现2.Python算法设计篇算法设计篇主要是阅读[Python Algorithms: Mastering Basic Algorithms in the Python Language]()[**点击链接可进入Springer免费下载原书电子版**]之后写下的读书总结，原书大部分内容结合了经典书籍[算法导论]()，内容更加细致深入，主要是介绍了各种常用的算法设计思想，以及如何使用Python高效巧妙地实现这些算法，这里有别于前面的数据结构篇，部分算法例如排序就不会详细介绍它的实现细节，而是侧重于它内在的算法思想。这部分使用了一些与数据结构有关的第三方模块，因为这篇的重点是算法的思想以及实现，所以并没有去重新实现每个数据结构，但是在介绍算法的同时会分析Python内置数据结构以及第三方数据结构模块的优缺点，也就意味着该篇比前面都要难不少，但是我想我的介绍应该还算简单明了，因为我用的都是比较朴实的语言，并没有像算法导论一样列出一堆性质和定理，主要是对着某个问题一步步思考然后算法就出来了，嘿嘿，除此之外，里面还有很多关于python开发的内容，精彩真的不容错过！这里每篇文章都有实现代码，但是代码我一般都不会分析，更多地是分析算法思想，所以内容都比较多，即便如此也没有包括原书对应章节的所有内容，因为内容实在太丰富了，所以我只是选择经典的算法实例来介绍算法核心思想，除此之外，还有不少内容是原书没有的，部分是来自算法导论，部分是来自我自己的感悟，嘻嘻。该篇对于大神们来说是小菜，请一笑而过，对于菜鸟们来说可能有点难啃，所以最适合的是和我水平差不多的，对各个算法都有所了解但是理解还不算深刻的半桶水的程序猿，嘿嘿。本篇的顺序按照原书[Python Algorithms: Mastering Basic Algorithms in the Python Language]()的章节来安排的(章节标题部分相同部分不同哟)，为了节省时间以及保持原著的原滋原味，部分内容(一般是比较难以翻译和理解的内容)直接摘自原著英文内容。 **1.你也许觉得很多内容你都知道嘛，没有看的必要，其实如果是我的话我也会这么想，但是如果只是归纳一个算法有哪些步骤，那这个总结也就没有意义了，我觉得这个总结的亮点在于想办法说清楚一个算法是怎么想出来的，有哪些需要注意的，如何进行优化的等等，采用问答式的方式让读者和我一起来想出某个问题的解，每篇文章之后都还有一两道小题练手哟****2.你也许还会说算法导论不是既权威又全面么，基本上每个算法都还有详细的证明呢，读算法导论岂不更好些，当然，你如果想读算法导论的话我不拦着你，读完了感觉自己整个人都不好了别怪小弟没有提醒你哟，嘻嘻嘻，左一个性质右一个定理实在不适合算法科普的啦，没有多少人能够坚持读完的。但是码农与蛇的故事内容不多哟，呵呵呵****3.如果你细读本系列的话我保证你会有不少收获的，需要看算法导论哪个部分的地方我会给出提示的，嘿嘿。温馨提示，前面三节内容都是介绍基础知识，所以精彩内容从第4节开始哟，么么哒 O(∩_∩)O~**(1)[Python Algorithms - C1 Introduction]() 本节主要是对原书中的内容做些简单介绍，说明算法的重要性以及各章节的内容概要。(2)[Python Algorithms - C2 The basics]() **本节主要介绍了三个内容：算法渐近运行时间的表示方法、六条算法性能评估的经验以及Python中树和图的实现方式。**(3)[Python Algorithms - C3 Counting 101]() 原书主要介绍了一些基础数学，例如排列组合以及递归循环等，但是本节只重点介绍计算算法的运行时间的三种方法(4)[Python Algorithms - C4 Induction and Recursion and Reduction]() **本节主要介绍算法设计的三个核心知识：Induction(推导)、Recursion(递归)和Reduction(规约)，这是原书的重点和难点部分**(5)[Python Algorithms - C5 Traversal]() **本节主要介绍图的遍历算法BFS和DFS，以及对拓扑排序的另一种解法和寻找图的(强)连通分量的算法**(6)[Python Algorithms - C6 Divide and Combine and Conquer]() **本节主要介绍分治法策略，提到了树形问题的平衡性以及基于分治策略的排序算法**(7)[Python Algorithms - C7 Greedy]() **本节主要通过几个例子来介绍贪心策略，主要包括背包问题、哈夫曼编码和最小生成树等等**(8)[Python Algorithms - C8 Dynamic Programming]() **本节主要结合一些经典的动规问题介绍动态规划的备忘录法和迭代法这两种实现方式，并对这两种方式进行对比**(9)[Python Algorithms - C9 Graphs]() **本节主要介绍图算法中的各种最短路径算法，从不同的角度揭示它们的内核以及它们的异同**
可视化的数据结构和算法
有一本Data Structures and Algorithms with Object Oriented Design Patterns in Python，作者Bruno R. Preiss
- python在算法领域的实际应用
Python入门菜鸟，最近在看数据结构公开课，觉得比这c的代码写Python老实说挺享受的
Problem Solving with Algorithms and Data Structures using Python作者: Brad Miller and David Ranum参考:
算法导论3ed
Python Algorithms 挺不错的
Goodrich & Tamassia系列之：Data Structures and Algorithms in Python. 之前最热销的Java版出了好几版，现在开辟Python版了。
已有帐号？
无法登录？
社交帐号登录有哪些用 Python 语言讲算法和数据结构的书_百度知道
有哪些用 Python 语言讲算法和数据结构的书
我有更好的答案
有一本Data Structures and Algorithms with Object Oriented Design Patterns in Python，作者Bruno R. Preiss
其他类似问题
为您推荐：
您可能关注的推广
python的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁