yingzi的技术博客

public class sort { public static void main(String[] args) { int[] test0 = {10, 1, 35, 61, 89, 36, 55}; int[] test1 = bubble_sort(test0); int[] test2 = select_sort(test0); int[] test3 = insert_sort(test0); int.

from stack import Stack def brace_match(s): match = {'}':'{',']':'[',')':'('} stack = Stack() for ch in s: if ch in {'(','[','{'}: stack.push(ch) else: #ch in {'}',']',')'} if stack.is_empty(): .

class Stack: def __init__(self): self.stack = [] def push(self,element): self.stack.append(element) def pop(self): return self.stack.pop() def get_top(self): if len(self.stack) &g.

先找十个桶：0~9 第一轮按照元素的个位数排序 第二轮按照元素的十位数排序 第三轮按照元素的百位数排序 … 依次类推 按照从左向右，从上到下的顺序依次取出元素，组成新的数组。 def radix_sort(li): max_num = max(li) it = 0 while 10 ** it <= max_num: buckets = [[] for _ in range(10)] for var in li: #98

有这样一道排序题：数组里有20个随机数，取值范围为从0到10，要求用最快的速度把这20个整数从小到大进行排序。 第一时间你可能会想使用快速排序，因为快排的时间复杂度只有O(nlogn)。但是这种方法还是不够快，有没有比O(nlogn)更快的排序方法呢？你可能会有疑问：O(nlogn)已经是最快的排序算法了，怎么可能还有更快的排序方法？ 让我们先来回顾一下经典的排序算法，无论是归并排序，冒泡排序还是快速排序等等，都是基于元素之间的比较来进行排序的。但是有一种特殊的排序算法叫计数排序，这种排序算法不是基于元素比

思想： 划分多个范围相同的区间，每个子区间自排序，最后合并。 桶排序是计数排序的扩展版本，计数排序可以看成每个桶只存储相同元素，而桶排序每个桶存储一定范围的元素，通过映射函数，将待排序数组中的元素映射到各个对应的桶中，对每个桶中的元素进行排序，最后将非空桶中的元素逐个放入原序列中。 桶排序需要尽量保证元素分散均匀，否则当所有数据集中在同一个桶中时，桶排序失效 def bucket_sort(li,n=100,max_num=10000): buckets = [[] for _ in range(

希尔排序是由简单插入排序经过改进之后的一个高效的版本，也成为缩小增量排序，该算法是冲破O(n^2)的第一批算法之一。 1.基本思想 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。 我们来看下希尔排序的基本步骤，在此我们选择增量 gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序

归并排序 利用归并的思想实现的排序方法，该算法采用经典的分治策略 分：将问题分成一些小的问题，然后递归求解 治：将分的阶段得到的各答案“修补”在一起，即分而治之 时间复杂度（最好、最差、平均）：O（nlog n） 空间复杂度：O（n） 可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。 再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,

问题：现在有n个数，设计算法得到前k大的数。（k<n） 解决思路： 1. 排序后切片 O（nlog n） 2. 排序LowB三人组 O（kn） 3. 堆排序思路 O（nlog k） 堆排序解决： 1. 取列表前k个元素建立一个小根堆，堆顶就是目前第k大的数 2. 依次向后遍历原列表，对于列表中的元素，如果小于堆顶，则忽略该元素； 如果大于 堆顶，则将堆顶更换为该元素，并且对堆顶进行一次堆调整； 3. 遍历列表所有元素后，倒序弹出堆顶 def small_sift(li,low,hi

堆排序： 引入完全二叉树，首先进行大根堆（小跟堆）的构建，在进行挨个出数 时间复杂度：O（nlog n） def sift(li,low,high): ''' Parameters ---------- li : 列表 low : 堆的根节点位置 high : 堆的最后一个元素的位置 Returns: 大根堆 times: O(log n) ------- ''' i = low # i最开始指向指向根节点

快速排序： 时间复杂度： 最优时：O（nlog n） 最差时：O（n^2） 空间复杂度： 最好、一般时：O（log n） 最差时：O（n） def partition(li,left,right): tmp = li[left] while left < right: while left < right and li[right] >= tmp: #从右边找比tmp小的数 right -= 1 #往左走一步 l

插入排序 每次从无序区中依次抽出一个数， 由其值将其放到有序区的位置 def insert_sort(li): for i in range(1,len(li)): # i:表示抽出来的下标 tmp = li[i] # 记录下抽出来的值 j = i-1 while j >= 0 and li[j] > tmp: #当抽出来的值小于顺序次序的值时，将前面有序区域往后挪 li[j+1] = li[j]

选择排序 每次从列表中选择一个最小的元素放到无序区的最前面 时间复杂度：O（n^2） def select_sort(li): for i in range(len(li)-1): min_loc = i for j in range(i+1, len(li)): if li[j] < li[min_loc]: min_loc = j li[i],li[min_loc] = li[min_

冒泡排序（默认升序）： 列表每两个相邻的数，如果前面比后面大，则交换这两个数 一趟排序完成后，则无序区减少一个数，有序区增加一个数 def bubble_sort(li): for i in range(len(li)-1): # 第i趟 for j in range(len(li)-i-1): if li[j] > li[j+1]: li[j],li[j+1] = li[j+1],li[j] print

二分查找，列表按从小到大的顺序排放，每次寻找中间位置元素的大小进行比较， def binary_search(li,val): left =0 right = len(li) - 1 while left <= right: mid = (left + right) // 2 if li[mid] == val: # 待查找的值等于中间值 return mid elif li[mid] > val:

顺序查找，也叫线性查找，从列表第一个元素开始，顺序进行搜索， 直到找到元素或搜索到列表最后一个元素为。 def linear_search(li,value): for i,v in enumerate(li): if v == value: return i return None if __name__ == '__main__': li = [1,3,5,7,9] value = 9 print(linear_searc

目标：将A上的圆盘全部移动到C上 分析：对于这样一个问题，任何人都不可能直接写出移动盘子的每一步，但我们可以利用下面的方法来解决。设移动盘子数为n，为了将这n个盘子从A杆移动到C杆，可以做以下三步： 1.把n-1个圆盘从A经过C移动到B 2.把第n个圆盘从A移动到C 3.把n-1个圆盘从B经过A移动到C 代码如下： def hanoi(n,a,b,c): if n>0: hanoi(n-1,a,c,b) print("moving from %s to %.