python游走代码_数据结构与算法

第一部分 算法简单概念

算法概念

复习：递归

时间复杂度

空间复杂度

什么是算法？

算法(Algrithm):一个计算过程，解决问题的方法

复习：递归

递归的两个特点：

(1)、调用自身

(2)、结束条件

简单的几个函数：

deffunc1(x):print(x)

func1(x-1)deffunc2(x):if x>0:print(x)print(x+1)deffunc3(x):if x>0:print(x)

func3(x-1)deffunc4(x):if x>0:

func4(x-1)print(x)

时间复杂度

如下代码：判断其时间复杂度

print("hello World")for i inrange(n):print("hello world")for i inrange(n):for j inrange(n):print("hello world")for i inrange(n):for j inrnage(n):for k inrange(n):print("Hello World")

以上四组代码，那组运行时间最短？

用什么方式来体现代码(算法)运行的快慢？

时间复杂度：用来评估算法运行效率的一个介质。

上述的时间复杂度分别如下：一般肉眼观察，循环了几次，print了几次。

再看以下代码例子：

类比生活中的一些时间例子，估计时间：不是一个确切的数而是个约数

继续推算时间复杂度的其他表示方法？

综上，总结一下时间复杂度

"""时间复杂度是用来估计算法运行时间的一个式子(单位)。

一般来说，时间复杂度高的算法比复杂度低的算法慢。

常见的时间复杂度(按效率排序)

O(1)

不常见的时间复杂度(看看就好)

O(n!) O(2n) O(nn) …

如何一眼判断时间复杂度？

循环减半的过程O(logn)

几次循环就是n的几次方的复杂度"""

补充：为什么python中的b+树，二叉树查询速度灰快些？

从时间复杂度的角度理解，因为它的时间复杂度仅次于O(1)

数据库添加B-树索引，查询就快。那么为啥添加索引就快？

B-树索引的内部结构如下：

理解下图就明白了

B-树索引有两种类型的块： 用于查找的分支块(Branch Blocks)和用于存储值的叶块(Leaf Blocks)。

B-树索引的上层分支块包含指向下层索引块的索引数据。从结构上来说就像树一样，分支块就是树干树枝，而叶子就是叶块。

但是和树有区别的是B-树索引是平衡的，所有叶块都自动处于相同的深度。

因此，在索引中从任意位置检索任意记录需要的时间基本上是相同的。可以理解为，如果走索引从中查询一条数据，那么我查找1W条数据和查询100w条数据的速度是一样的。

最底层的叶块包含每个被索引的数据值，和一个相应的用来定位实际行的rowid。根据分支块，找到被索引的数据值，再找到对应的rowid，再从rowid取出对应的数据，就起到了快速查找数据的目的。

空间复杂度

空间复杂度：用来评估算法内存占用大小的一个式子。

“空间换时间”，更多的是涉及硬件性能有关，如内存，硬盘，cpu等。

常见的算法

排序算法是《数据结构与算法》中最基本的算法之一。

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：

#1.0 十大经典排序算法#1.1 冒泡排序#1.2 选择排序#1.3 插入排序#1.4 希尔排序#1.5 归并排序#1.6 快速排序#1.7 堆排序#1.8 计数排序#1.9 桶排序#1.10 基数排序

关于时间复杂度

平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。

线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；

O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序

线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

名词解释：

n：数据规模

k："桶"的个数

In-place：占用常数内存，不占用额外内存

Out-place：占用额外内存

稳定性：排序后2 个相等键值的顺序和排序之前它们的顺序相同

1、列表查找

列表查找：从列表中查找指定元素

输入：列表、待查找元素

输出：元素下标或未查找到元素

顺序查找

从列表第一个元素开始，顺序进行搜索，直到找到为止。

二分查找

从有序列表的候选区data[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。

列表查找

递归版的二分法查找

2、冒泡排序思路

首先，列表每两个相邻的数，如果前边的比后边的大，那么交换这两个数……

会发生什么？

1. 算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2. 动图演示

python代码实现

#### 冒泡排序 (************************)### 时间复杂度：O(n^2)

defBubble_sort(li):for i in range(len(li)-1): # 第一趟是循环遍历for j in range(len(li)-1-i): # 内层循环是两两之间进行比较，取出较大的数if li[j] > li[j+1]:

li[j], li[j+1] = li[j+1], li[j]

li=[1,2,3,5,8,4,9,10,12]

Bubble_sort(li)

print(li)

3、选择排序思路

一趟遍历记录最小的数，放到第一个位置；

再一趟遍历记录剩余列表中最小的数，继续放置；

……

问题是：怎么选出最小的数？

代码关键点：

无序区

最小数的位置

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。

唯一的好处可能就是不占用额外的内存空间了吧。

1. 算法步骤

首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

2. 动图演示

代码实现：

#### 选择排序#### 时间复杂度：O(n^2)

defselect_sort(li):for i inrange(len(li)):

minLoc= i ###i = 0

for j in range(i+1, len(li)):if li[j]

li[j], li[minLoc]= li[minLoc], li[j],10li=[2,5,4,6,8,9,14,7]

select_sort(li)print(li)

4、插入排序思路

列表被分为有序区和无序区两个部分。最初有序区只有一个元素。

每次从无序区选择一个元素，插入到有序区的位置，直到无序区变空。

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。

插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

1. 算法步骤

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。)

2. 动图演示

代码实现：

##### 插入排序#### 时间复杂度： O(n^2)

definsert_sort(li):for i in range(1, len(li)):

tmp=li[i]

j= i - 1

while j >=0 and li[j] >tmp:

li[j+1] =li[j]

j= j - 1li[j+1] =tmpli= [1,2,5,7,12,23,15,56,21,45]

insert_sort(li)print(li)

5、 快速排序思路

快速排序：快

好写的排序算法里最快的

快的排序算法里最好写的

1. 算法步骤

1、从数列中挑出一个元素，称为 "基准"(pivot);2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区(partition)操作；3、递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序；

2. 动图演示

代码实现

defpartition(li, left, right):

tmp=li[left]while left =tmp:

right= right - 1li[left]=li[right]while left < right and li[left] <=tmp:

left= left + 1li[right]=li[left]

li[left]=tmpreturnleft#### 快速排序#### 时间复杂度：O(nlogn)

defquick_sort(li, left, right):if left

mid=partition(li, left, right)

quick_sort(li, left, mid-1)

quick_sort(li, mid+1, right)

6、计数排序

算法的步骤如下：

(1)找出待排序的数组中最大和最小的元素

(2)统计数组中每个值为i的元素出现的次数，存入数组C的第i项

(3)对所有的计数累加(从C中的第一个元素开始，每一项和前一项相加)

(4)反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

2. 动图演示

代码的实现：

#创建一个列表，用来统计每个数出现的次数

#现在有一个列表，列表中的数范围都在0到100之间，#列表长度大约为100万。设计算法在O(n)时间复杂度内将列表进行排序。

defcount_sort(li,max_num):

count= [0 for i in range(max_num+1)]for num inli:

count[num]+= 1i=0for num,m inenumerate(count):for j inrange(m):

li[i]=num

i+= 1li= [1,2,5,2,0,1,11,54,212,154,1,24,12,5,6,5,2,8,9,20,12,23,45,16]

count_sort(li,1000)print(li)

线性结构

把所有的节点用一根线串起来

数组和链表的区别

数组需要一块连续的内存空间来存储，对内存的要求比较高。如果我们申请一个 100MB 大小的数组，当内存中没有连续的、足够大的存储空间时，即便内存的剩余总可用空间大于 100MB，仍然会申请失败。 而链表恰恰相反，它并不需要一块连续的内存空间,它通过“指针”将一组零散的内存块串联起来使用，所以如果我们申请的是 100MB 大小的链表，根本不会有问题。

离散存储(链表)

推荐的学习书籍