算法_常用排序算法
目录
一、冒泡排序
1、思路：首先，列表每两个相邻的数比较大小，如果前边的比后边的大，那么这两个数就互换位置。就像是冒泡一样
2、代码关键点：
- 趟数：n-1趟
- 无序区
3、图示说明：依次类推就会得到排序结果。冒泡排序的效率还是很低的
4、代码示例
# 思路：列表中两个相邻的数比较大小，如果前边的比后边的大，那么这两个就互换位置 def bubblr_sort(li): for i in range(1,len(li)-1):#表示趟数 change = False for j in range(len(li)-i): #表示无序区，无序区的范围为0,len(li)-i if li[j] > li[j+1]: li[j],li[j+1] = li[j+1],li[j] change = True if not change: return li = list(range(10)) import random random.shuffle(li) print(li) bubblr_sort(li) print(li) def bubblr_sort(li,reverse=False): for i in range(1,len(li)-1):#表示趟数 change = False for j in range(len(li)-i): #表示无序区，无序区的范围为0,len(li)-i if not reverse: # 从小到大排序 if li[j] > li[j+1]: li[j],li[j+1] = li[j+1],li[j] change = True else: # 从大到小排序 if li[j] < li[j+1]: li[j],li[j+1] = li[j+1],li[j] change = True if not change: return li = list(range(10)) import random random.shuffle(li) print(li) bubblr_sort(li,True) print(li)
5、时间复杂度：O(n**2)
二、选择排序
1、思路：一趟遍历完记录最小的数，放到第一个位置；在一趟遍历记录剩余列表中的最小的数，继续放置
2、代码关键点：
- 无序区
- 最小数的位置
3、问题：怎么选出最小的数？
import random def select_sort(li): for i in range(len(li)-1): #i 表示躺数，也表示无序区开始的位置 min_loc = i #最小数的位置 for j in range(i+1,len(li)): #i ,i+1，就是后一个位置的范围 # [9, 2, 1, 6, 5, 8, 3, 0, 7, 4] # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] if li[j] <li[min_loc]: #两个位置进行比较，如果后面的一个比最小的那个位置还小，说明就找到最小的了 min_loc = j #找到最小的位置 li[i],li[min_loc] = li[min_loc],li[i] #吧找到的两个值进行互换位置 li = list(range(10)) random.shuffle(li) print(li) select_sort(li) print(li)
4、时间复杂度：O(n**2)
三、插入排序
1、思路：元素被分为有序区和无序区两部分。最初有序区只有一个元素。每次从无序区中选择一个元素，插入到有序区的位置，直到无序区变空。
2、代码关键点：
- 摸到的牌
- 手里的牌
3、图示说明
插入后：
4、代码示例
import random def insert_sort(li): for i in range(1,len(li)): #i 表示无序区的第一个数 tmp = li[i] #摸到的牌 j = i-1 #指向有序区最后一个位置 while li[j] >tmp and j>=0: #循环终止条件 li[j]<=tmp and j==-1 li[j+1] = li[j] #向后移动 j-=1 li[j+1] = tmp li = list(range(10)) random.shuffle(li) print(li) insert_sort(li) print(li)
四、快速排序
1、思路：1、取一个元素p(第一个元素)，是元素p归位（去它该去的地方）；
2、列表被p分成两部分，左边的都比p小，右边的都比p大；
3、递归完成排序
2、算法关键点
- 归位
- 递归
3、图示说明
4、怎么归并呢？先把5取出来，这时候就会有一个空位，从右边找比5小的数填充过来，现在右边有一个空位了，从左边找比5大的放到右边的空位上。依次类推，
只要left和right碰在一起，这样就找打5的位置了
如图示：
图一
图二
图三
图四
这样在把找到的5的位置放进去去ok了
5、代码示例
import time def wrapper(func): def inner(*args,**kwargs): start = time.time() ret = func(*args,**kwargs) end = time.time() print('%s running time :%s'%(func.__name__,start-end)) return ret return inner def partition(li,left,right): '''归位函数''' tmp = li[left] #先把5取出来 while left < right: while left < right and li[right] >= tmp: #如果降序排列修改li[right] <= tmp right -= 1 #从右边找比5小的数，填充到5的位置 li[left] = li[right] while left < right and li[left] <= tmp: #如果降序排列修改li[right] >= tmp left += 1# 从左边找比5大的数字放在右边的空位 li[right] = li[left] li[left] = tmp #当跳出循环条件的时候说明找到了，并且把拿出来的5在放进去 return left def _quick_sort(li,left,right): '''快速排序的两个关键点：归位，递归''' if left < right: #至少有两个元素，才能进行递归 mid = partition(li,left,right) #找到归位的位置 _quick_sort(li,left,mid-1) #递归，右边的-1 _quick_sort(li,mid+1,right) #递归，左边的+1 @wrapper def quick_sort(li): return _quick_sort(li, 0, len(li)-1) @wrapper def sys_sort(li): '''系统排序''' li.sort() import random li = list(range(100000)) random.shuffle(li) # print(li) quick_sort(li) # print(li) sys_sort(li) #结论：系统的排序要比快排的时间快的多 # quick_sort running time :-0.6240355968475342 # sys_sort running time :-0.002000093460083008
6、快速排序的时间复杂度O(nlogn)
五、堆排序
1、堆排序过程：
- 1、建立堆
- 2、得到堆顶元素，为最大元素
- 3、去掉堆顶，将堆最后一个元素放在堆顶，此时可通过一次调整重新使堆有序
- 4、堆顶元素为第二大元素
- 5、重复步骤3，直到堆变空
2、代码示例
import random def _sift(li, low, high): """ :param li: :param low: 堆根节点的位置 :param high: 堆最有一个节点的位置 :return: """ i = low # 父亲的位置 j = 2 * i + 1 # 孩子的位置 tmp = li[low] # 原省长 while j <= high: if j + 1 <= high and li[j + 1] > li[j]: # 如果右孩子存在并且右孩子更大 j += 1 if tmp < li[j]: # 如果原省长比孩子小 li[i] = li[j] # 把孩子向上移动一层 i = j j = 2 * i + 1 else: li[i] = tmp # 省长放到对应的位置上(干部) break else: li[i] = tmp # 省长放到对应的位置上(村民/叶子节点) def sift(li, low, high): """ :param li: :param low: 堆根节点的位置 :param high: 堆最有一个节点的位置 :return: """ i = low # 父亲的位置 j = 2 * i + 1 # 孩子的位置 tmp = li[low] # 原省长 while j <= high: if j + 1 <= high and li[j+1] > li[j]: # 如果右孩子存在并且右孩子更大 j += 1 if tmp < li[j]: # 如果原省长比孩子小 li[i] = li[j] # 把孩子向上移动一层 i = j j = 2 * i + 1 else: break li[i] = tmp def heap_sort(li): n = len(li) # 1. 建堆 for i in range(n//2-1, -1, -1): sift(li, i, n-1) # 2. 挨个出数 for j in range(n-1, -1, -1): # j表示堆最后一个元素的位置 li[0], li[j] = li[j], li[0] # 堆的大小少了一个元素 （j-1） sift(li, 0, j-1) li = list(range(10)) random.shuffle(li) print(li) heap_sort(li) print(li) # li=[2,9,7,8,5,0,1,6,4,3] # sift(li, 0, len(li)-1) # print(li)
待看http://www.cnblogs.com/haiyan123/p/8400537.html
六、归并排序
假设现在的列表分两段有序，如何将其合成为一个有序列表。这种操作称为一次归并
1、思路：
2、归并关键字
- 分解：将列表越分越小，直至分成一个元素
- 终止条件：一个元素是有序的
- 合并：将两个有序列表归并，列表越来越大
3、图实示例：https://www.cnblogs.com/chengxiao/p/6194356.html
4、代码示例：
import random def merge(li, low, mid, high): # 一次归并 ''' :param li: 列表 :param low: 起始位置 :param mid: 按照那个位置分 :param high: 最后位置 :return: ''' i = low j = mid + 1 ltmp = [] while i <= mid and j <= high: if li[i] < li[j]: ltmp.append(li[i]) i += 1 else: ltmp.append(li[j]) j += 1 while i <= mid: ltmp.append(li[i]) i += 1 while j <= high: ltmp.append(li[j]) j += 1 li[low:high+1] = ltmp def _merge_sort(li, low, high): if low < high: # 至少两个元素 mid = (low + high) // 2 _merge_sort(li, low, mid) _merge_sort(li, mid+1, high) merge(li, low, mid, high) print(li[low:high+1]) def merge_sort(li): return _merge_sort(li, 0, len(li)-1) li = list(range(16)) random.shuffle(li) print(li) merge_sort(li) print(li)
5、归并排序的时间复杂度：O(nlogn)，空间复杂度是：O(n)
七、基数排序
八、希尔排序
1、思路：
- 希尔排序是一种分组插入排序算法。
- 首先取一个整数d1=n/2，将元素分为d1个组，每组相邻量元素之间距离为d1，在各组内进行直接插入排序；
- 取第二个整数d2=d1/2，重复上述分组排序过程，直到di=1，即所有元素在同一组
- 希尔排序每趟并不使某些元素有序，而是使整体数据越来越接近有序；最后一趟排序使得所有数据有序。
2、代码实现
def insert_sort(li):#插入排序 for i in range(1, len(li)): # i 表示无序区第一个数 tmp = li[i] # 摸到的牌 j = i - 1 # j 指向有序区最后位置 while li[j] > tmp and j >= 0: #循环终止条件： 1. li[j] <= tmp; 2. j == -1 li[j+1] = li[j] j -= 1 li[j+1] = tmp def shell_sort(li):#希尔排序 与插入排序区别就是把1变成d d = len(li) // 2 while d > 0: for i in range(d, len(li)): tmp = li[i] j = i - d while li[j] > tmp and j >= 0: li[j+d] = li[j] j -= d li[j+d] = tmp d = d >> 1 li=[5,2,1,4,5,69,20,11] shell_sort(li) print(li)
希尔排序的复杂度特别复杂，取决于d，分组的长度二、位移运算符
九、桶排序
在计数排序中，如果元素的范围比较大(比如在1到1亿之间)，如何改造算法？
桶排序，首先将将元素分在不同的桶中，在对每个桶中的元素排序。
多关键字排序
先对十位进行排序，再根据 十位进行排序
要用两个函数，一个用来装桶，一个用来出桶
默认10个桶，找到个位，十位，分别放在对应的桶里的位置
桶排序的表现取决于数据的分布。也就是需要对不同数据排序时采取不同的分桶策略。
平均情况时间复杂度：O(n+k)
最坏情况时间复杂度：O(n+k)
空间复杂度：O(nk)
先分成若干个桶，桶内用插入排序。
例子
1：给两个字符串S和T，判断T是否为S的重新排列后组成的单词：
s="anagram",t="nagaram",return true
s='cat',t='car',return false
代码如下：
s = "anagram" t = "nagaram" def ss(s,t): return sorted(list(s))==sorted(list(t)) y=ss(s,t) print(y)
2、给定一个m*n的而为列表，查找一个数是否存在。[[1,3,5,7],[10,11,16,20],[23,30,34,50]]，列表有下列特性：每一行的列表从左到右已经排序好；每一行第一个数比上一行最后一个数大。
def searchMatrix(matrix, target): m = len(matrix) # print('m', m) if m == 0: return False n = len(matrix[0]) if n == 0: return False low = 0 high = m * n - 1 # print('high',high) while low <= high: mid = (low + high) // 2 x, y = divmod(mid, n) if matrix[x][y] > target: high = mid - 1 elif matrix[x][y] < target: low = mid + 1 else: return True else: return False s = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] # print(searchMatrix(s, 1)) # print(searchMatrix(s, 2)) # print(searchMatrix(s, 3)) # print(searchMatrix(s, 4)) # print(searchMatrix(s, 5)) # print(searchMatrix(s, 6)) print(searchMatrix(s, 7)) # print(searchMatrix(s, 8)) # print(searchMatrix(s, 9))
3.给定一个列表和一个整数，设计算法找两个数的小标，使得两个数之和为给定的整数。保证肯定仅有一个结果。
例如：列表[1,2,5,4]与目标整数3，1+2=3，结果为(0,1)
方式一：
方式二：
方式三
方式四和三一样
def twoSum(num, target): dict = {} for i in range(len(num)): print(dict) x = num[i] if target - x in dict: return dict[target - x], i dict[x] = i l = [1, 2, 5, 4] print(twoSum(l, 7))
十、总结
LOw B 三人组
- 冒泡排序，选择排序，直接插入排序他们的时间复杂度都是O(n^2),空间复杂度是O(1)
NB 三人组
- 快速排序，归并排序，堆排序他们的时间复杂度都是O(nlogn)
- 三种排序算法的缺点
- 快速排序：极端情况下排序效率低
- 归并排序：需要额外的内存开销
- 堆排序：在快的排序算法中相对较慢
挨着换的稳定，不挨着换的不稳定
