标签：位置 想法 构建 pre 构造 代码重复 交换 数组 表示
给定一个数组arr， 和一个数num， 请把小于等于num的数放在数组的左边， 大于num的数放在数组的右边。要求额外空间复杂度O(1)， 时间复杂度O(N)
想法是这样的，维持一个index，表示在index以及以前的数字都是小于等于num的。
def split_array(arr, num): """维持一个小于等于区域的index， 如果一个数小于等于num，则和index位置交换 如果一个数大于num，则直接跳下一个 """ i = -1 for j in range(len(arr)): if arr[j] > num: pass else: i += 1 arr[j], arr[i] = arr[i], arr[j] return arr
给定一个数组arr， 和一个数num， 请把小于num的数放在数组的左边， 等于num的数放在数组的中间， 大于num的数放在数组的右边。 要求额外空间复杂度O(1)， 时间复杂度O(N)
思路是这样的，维持两个index，一个less，一个more
def split_array(arr, num): """总体的策略是，遇到小的数字，那么把它往前面移动，遇到大的数字，把它让后面移动，遇到相等的数字，不动 维持两个三个变量来进行交换 less , more , current 其中more的值应该为len(arr),这样在判断的时候多判断一次，并且j-=1写在后面 more要等于len(arr),并且运算的时候先要减一，否则会出现这种情况： [7,6,4,1,2,5,4] 变为[2, 4, 4, 1, 5, 6, 7]，因为这种情况下面并没有对中间的1进行排序，少了一次排序的次数 """ current = 0 less = -1 more = len(arr) while(current < more): if arr[current] < num: # 如果小于，那么less和current要进行交换，并且都推进一位 less += 1 arr[less], arr[current] = arr[current], arr[less] current += 1 elif arr[current] == num: # 如果等于，那么直接向下进行 current += 1 else: more -= 1 arr[current], arr[more] = arr[more], arr[current] return arr
由划分问题引出来的快排算法，用一个数将数组划分为两部分，然后剩下的两部分继续划分
import random def quick_sort(arr): """快排散发 时间复杂度：随机快排是一种随机算法，使用期望来求解，时间复杂度为O(NlogN) 空间复杂度： O(logN) 稳定性： 非稳定的，由于是随机选择， 比如有两个相等的数，可能选择左边的，然后右边的会放到它的左边 """ sort_range(arr, 0, len(arr)-1) def sort_range(arr, left, right): if left < right: position = split_array(arr, left, right) sort_range(arr, left, position[0]-1) sort_range(arr, position[1]+1, right) def split_array(arr, left, right): """遇到小与num的数，那么把它往前面移动，遇到大的数字，把它让后面移动，遇到相等的数字，继续向后走。 less = left-1 与 more = right +1 在less下标左边的数字（包含less）都是比num要小的， 在more右边的数字（包含more）都是比more要大的 随机快排的时间复杂度： O(nlogn) 空间复杂度： O(logn) 使用随机算法，这个复杂度是求随机的期望得到的 Args: left 表示需要排序的左区间，包含left right 需要排序的由区间 包含right Returns: [less+1, more-1] 一个含有两个数的里列表，表示划分的num的坐下标和右下标 如排序后的[2,1,4,4,5,6,7]返回[2,3] """ num = arr[random.randint(left, right)] current = left less = left -1 more = right + 1 while(current < more): if arr[current] < num: # 如果小于，那么less和current要进行交换，并且都推进一位 less += 1 arr[less], arr[current] = arr[current], arr[less] current += 1 elif arr[current] == num: # 如果等于，那么直接向下进行 current += 1 else: more -= 1 arr[current], arr[more] = arr[more], arr[current] return [less+1 , more-1]
一个数组可以看做是一颗完全二叉树。 节点标号是从0开始的，其中父节点和子节点的关系：如果父节点为i，那么左子节点为 2*i+1, 右子节点为2*i+2。 若果子节点为i,那么父节点为(i-1)/2,对于0也使用，前提是除法是向0舍入。
大根堆和小根堆：大根堆是一个节点的值总是比它下面节点所有的值都大，这样根节点的值为最大值。小根堆则刚好相反。
思路是这样的，对于数组节点都做一次调整，如果它比父节点大，那么和父节点交换，直到交换到根节点。
def heap_insert(arr, current_index): father_index = int((current_index - 1) / 2) while(arr[father_index] < arr[current_index]): arr[father_index], arr[current_index] = arr[current_index], arr[father_index] current_index = father_index father_index = int((current_index - 1) / 2) x = [2, 1, 3, 6, 0, 4] for i in range(len(x)): heap_insert(x, i)
假如有一个节点的值变小了，那么如何调整这个数组，使得它依然是一个堆，这个过程叫做下沉。思路是这样的：如果是左子树不存在，那么它是叶子节点，不做调整。判断右子树存在吗？然后找出左子树和右子树的最大值，如果当前值比最大值大，那么退出，否则进行交换，然后重复这样的操作。
def heapipy(arr, current_index, heap_size): """在大根堆的情况下，如果一个节点变小情况下的 向下调整过程 Args: arr: 要调整的数组 current_index: 要替换的下标 heap_size: 数组的长度(堆的大小) """ left_index = 2 * current_index + 1 while(left_index < heap_size): right_index = left_index + 1 if right_index < heap_size: largest = left_index if arr[left_index] >= arr[right_index] else right_index else: largest = left_index largest = largest if arr[largest] > arr[current_index] else current_index if largest == current_index: break else: arr[largest], arr[current_index] = arr[current_index], arr[largest] current_index = largest left_index = 2*current_index + 1
利用上面两个特性，首先来构造根，然后是将末尾的数和第一个数交换，然后第一个数下沉一下。
def heapipy(arr, current_index, heap_size): """在大根堆的情况下，如果一个节点变小情况下的 向下调整过程 Args: arr: 要调整的数组 current_index: 要替换的下标 heap_size: 数组的长度(堆的大小) """ left_index = 2 * current_index + 1 while(left_index < heap_size): right_index = left_index + 1 if right_index < heap_size: largest = left_index if arr[left_index] >= arr[right_index] else right_index else: largest = left_index largest = largest if arr[largest] > arr[current_index] else current_index if largest == current_index: break else: arr[largest], arr[current_index] = arr[current_index], arr[largest] current_index = largest left_index = 2*current_index + 1 def heap_insert(arr, current_index): """在数组指定的位置插入值，一般是末尾值，这样能够不断的构建大堆""" father_index = int((current_index - 1) / 2) while(arr[father_index] < arr[current_index]): arr[father_index], arr[current_index] = arr[current_index], arr[father_index] current_index = father_index father_index = int((current_index - 1) / 2) def heap_sort(arr): """堆排序 时间复杂度：建堆的时间复杂度为O(n), 调整过程的时间复杂度为O(nlogn)，所以总体复杂度为O(nlogn) 空间复杂度： O(1) 只是交换的时候用了一下额外空间 稳定性： 不稳定， 比如[4a,4b,4c,5]建堆的时候发生错误，变为【5,4a,4c,4b],排序后变为【5，4b,4c,4a】 [9,5A,7,5B]在放入堆的时候会发生错误 """ # 建立堆栈的过程 for i in range(len(arr)): heap_insert(arr, i) arr_length = len(arr) arr[0], arr[-1] = arr[-1], arr[0] arr_length -= 1 while(arr_length > 0): heapipy(arr, 0, arr_length) arr[0], arr[arr_length-1] = arr[arr_length-1], arr[0] arr_length -= 1
由一个数组产生器不断的产生一组数，在产生的过程当中求这些数的中位数。
暴力解法：每求一个数，然后将数组进行一些排序，求中位数，时间复杂度为O(NlogN)
使用堆结构：使用一个大根堆和一个小根堆，两个堆存放的数量相差不会超过1，这样大根堆所有的数小于小根堆所有的数，中位数在大根堆的堆顶或者小根堆的堆顶。
【关于如何弹出一个堆的最大值，或者最小值】，有一个很好的方法是，【1：第一个数和最后一个数交换，2弹出最后一个数，3：向下调整第一个数】
代码如下：
import random def heapipy(arr, current_index, heap_size): """在大根堆的情况下，如果一个节点变小情况下的 向下调整过程 Args: arr: 要调整的数组 current_index: 要替换的下标 heap_size: 数组的长度(堆的大小) """ left_index = 2 * current_index + 1 while(left_index < heap_size): right_index = left_index + 1 if right_index < heap_size: largest = left_index if arr[left_index] >= arr[right_index] else right_index else: largest = left_index largest = largest if arr[largest] > arr[current_index] else current_index if largest == current_index: break else: arr[largest], arr[current_index] = arr[current_index], arr[largest] current_index = largest left_index = 2*current_index + 1 def small_heapipy(arr, current_index, heap_size): """在大根堆的情况下，如果一个节点变小情况下的 向下调整过程 Args: arr: 要调整的数组 current_index: 要替换的下标 heap_size: 数组的长度(堆的大小) """ left_index = 2 * current_index + 1 while(left_index < heap_size): right_index = left_index + 1 if right_index < heap_size: small = left_index if arr[left_index] <= arr[right_index] else right_index else: small = left_index small = small if arr[small] < arr[current_index] else current_index if small == current_index: break else: arr[small], arr[current_index] = arr[current_index], arr[small] current_index = small left_index = 2*current_index + 1 def big_heap_insert(arr, current_index): father_index = int((current_index - 1) / 2) while(arr[father_index] < arr[current_index]): arr[father_index], arr[current_index] = arr[current_index], arr[father_index] current_index = father_index father_index = int((current_index - 1) / 2) def small_heap_insert(arr, current_index): father_index = int((current_index - 1) / 2) while(arr[father_index] > arr[current_index]): arr[father_index], arr[current_index] = arr[current_index], arr[father_index] current_index = father_index father_index = int((current_index - 1) / 2) small_heap = [] big_heap = [] for i in range(100): x = random.randint(1,100) if not big_heap: big_heap.append(x) else: if x <= big_heap[0]: big_heap.append(x) big_heap_insert(big_heap,len(big_heap)-1) else: small_heap.append(x) small_heap_insert(small_heap, len(small_heap)-1) if len(big_heap) - len(small_heap) == 2: big_heap[0], big_heap[-1] = big_heap[-1], big_heap[0] tmp = big_heap.pop() heapipy(big_heap, 0, len(big_heap)) small_heap.append(tmp) # 有代码重复的意思在里面 small_heap_insert(small_heap, len(small_heap)-1) elif len(small_heap) - len(big_heap) == 2: small_heap[0], small_heap[-1] = small_heap[-1], small_heap[0] tmp = small_heap.pop() small_heapipy(small_heap,0, len(small_heap)) big_heap.append(tmp) big_heap_insert(big_heap,len(big_heap)-1)
def counting_sort(arr, arr_size): """计数排序 它是非比较的排序算法 N=len(arr) K = arr_size 时间复杂度： O(N+K) 空间复杂度： O(N+K) 稳定性： 稳定性排序 """ buck_count = [0] * arr_size for i in arr: buck_count[i-1] += 1 result = [] for i in range(arr_size): result += [i+1] * buck_count[i] return result
def radix_sort(arr, digit): """基数排序 时间复杂度： O(N) 其实是O(digit*n)一般digit很小，所以为O(N) 空间复杂度: O(N) 用了两个数组，bucket和result（下面程序当中arr=[]，直接将值赋给了arr，而不是result) 稳定性：稳定性算法 """ for i in range(digit): bucket = [[] for i in range(10)] for x in arr: number_of_digit = (x % (10**(i+1))) // (10 ** i) # 得到第i位的数字 bucket[number_of_digit].append(x) arr = [] for i in range(10): arr += bucket[i] return arr
给定一个数组， 求如果排序之后， 相邻两数的最大差值， 要求时间复杂度O(N)， 且要求不能用非基于比较的排序
思路是利用桶的思想来进行解决，将相差范围内的数字放入一个桶当中
def get_index_by_num(num, arr_length, max_value, min_value): """将一个数划分到桶中 将arr_length 切分成 （max_value - min_value)份 然后在 min_value开始，分配这些份 """ return int( arr_length / (max_value - min_value) * (num-min_value) ) def get_max_sub_min(arr): max_value = float(‘-inf‘) min_value = float(‘inf‘) for i in arr: max_value = i if i > max_value else max_value min_value = i if i < min_value else min_value if max_value == min_value: return 0 arr_length = len(arr) max = [float(‘-inf‘)] * (arr_length + 1) min = [float(‘inf‘)] * (arr_length + 1) has_num = [False] * (arr_length + 1) for i in arr: index = get_index_by_num(i, arr_length, max_value, min_value) has_num[index] = True min[index] = i if i < min[index] else min[index] max[index] = i if i > max[index] else max[index] print(min) print(max) print(has_num) #最大值不会出现在一个桶的内部，只会出现在两个桶之间，但并不一定是空桶之间 res = 0 last_max = max[0] for index in range(1,arr_length + 1): if has_num[index]: res = min[index] - last_max if (min[index] - last_max) > res else res last_max = max[index] return res
nowcoder basic algorithm chapter 2
标签：位置 想法 构建 pre 构造 代码重复 交换 数组 表示
原文地址：https://www.cnblogs.com/jiaxin359/p/9241090.html
