二分查找
class Solution(object):
def search(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
low = 0
height = len(nums)-1
while low <=height:
mid = (low+height)//2
if nums[mid] < target:
low = mid + 1
elif nums[mid] > target:
height = mid - 1
else:
return mid
return -1
s=Solution()
List=[1,2,3,4,5,6,7,8,9]
k=6
print(s.search(List,k))
初始条件:left = 0, right = length-1
终止:left > right
向左查找:right = mid-1
向右查找:left = mid+1
确定分半:mid=(right+left)//2(python中,向下取整)
快速排序
"""
一、介绍
通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,
然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
二、步骤
递归实现
"""
def quick_sort(nums, start, end):
if start >= end:
return
pivot = nums[start] # 基准值
low = start # 左指针
high = end # 右指针
while low < high:
while low < high and nums[high] >= pivot:
high -= 1
nums[low] = nums[high]
while low < high and nums[low] < pivot:
low += 1
nums[high] = nums[low]
nums[low] = pivot
quick_sort(nums, start, low - 1)
quick_sort(nums, low + 1, end)
if __name__ == '__main__':
nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
quick_sort(nums, 0, len(nums) - 1)
print(nums)
归并排序
"""
一、介绍
基本思想:
将数组array[0,...,n-1]中的元素分成两个子数组:array1[0,...,n/2]
和array2[n/2+1,...,n-1]。分别对这两个数组单独排序,然后将已排序的
两个子数组归并成一个含有n个元素的有序数组
二、步骤
递归实现
三、时间复杂度:O(N*logN)
四、归并排序的两点改进
* 在数组长度比较短的情况下,不进行递归,而是选择其他排序方案,如插入排序
* 归并过程中,可以用记录数组下标的方式代替申请新内存空间;从而避免array和
辅助数组间的频繁数据移动
"""
def merge(left, right): # 合并两个有序数组
l, r = 0, 0
result = []
while l < len(left) and r < len(right):#
if left[l] <= right[r]:
result.append(left[l])
l += 1
else:
result.append(right[r])
r += 1
result += left[l:]
result += right[r:]
return result
def merge_sort(nums):
if len(nums) <= 1:
return nums
num = len(nums) >> 1
left = merge_sort(nums[:num])
right = merge_sort(nums[num:])
return merge(left, right)
# ------------------- 按第二个改进的修改----------------------------
temp = [0] * 100
def Merge(nums, low, mid, high):
i = low
j = mid + 1
size = 0
while i <= mid and j <= high:
if nums[i] < nums[j]:
temp[size] = nums[i]
i += 1
else:
temp[size] = nums[j]
j += 1
size += 1
while i <= mid:
temp[size] = nums[i]
size += 1
i += 1
while j <= high:
temp[size] = nums[j]
size += 1
j += 1
for i in range(size):
nums[low + i] = temp[i]
def Merge_sort(nums, low, high):
if low >= high:
return
mid = (low + high) >> 1
Merge_sort(nums, low, mid)
Merge_sort(nums, mid + 1, high)
Merge(nums, low, mid, high)
if __name__ == '__main__':
nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
Merge_sort(nums, 0, len(nums) - 1)
print(nums)
计数排序
'''
计数排序
一、介绍
计数排序是一种线性排序算法,不用比较元素的大小。
待排序序列中元素都是整数,且在0~k之间,k为整数。
稳定性强,
二、时间复杂度为O(n+k),n为输入元素个数,k为待排序列中最大的数。
局限性大,只限于对整数进行排序。
通过消耗空间复杂度来获取快捷的排序,空间复杂度为O(k)。
'''
def CountSort(nums):
tmp=[0]*(max(nums)+1)
sortednums=[]
for i in range(len(nums)):
tmp[nums[i]]+=1
for i in range(len(tmp)):
if tmp[i]!=0:
sortednums.append(i)
tmp[i]-=1
else:
continue
return sortednums
nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
CountSort(nums)
冒泡排序
"""
------------------------------- 冒泡排序 --------------------------------------
一、介绍
冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,
如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数
列已经排序完成。
二、步骤
比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个。
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
针对所有的元素重复以上的步骤,除了最后一个。
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
"""
def bubble_sort(nums):
for j in range(len(nums) - 1, 0, -1): # j的取值是[len(alist)-1,len(alist)-2,.....,1]
# j 表示每次遍历需要比较的次数,是逐渐减小的
for i in range(j):
if nums[i] > nums[i + 1]:
nums[i], nums[i + 1] = nums[i + 1], nums[i]
if __name__ == '__main__':
nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
bubble_sort(nums)
print(nums)
堆排序
"""
------------------------------- 堆排序 --------------------------------------
一、介绍
堆排序是一种树形选择排序,是对直接选择排序的有效改进。
二、思想:初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储序,使之成为一个 堆,
这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。
依此类推,直到只有两个节点的堆,并对 它们作交换,最后得到有n个节点的有序序列。从算法描述来看,
堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。
一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。
三、堆的知识点:
堆的定义下:具有n个元素的序列 (h1,h2,...,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1) (i=1,2,...,n/2)时称之为堆。
在这里只讨论满足前者条件的堆。由堆的定义可以看出,堆顶元素(即第一个元素)必为最大项(大顶堆)。
完全二叉树可以很直观地表示堆的结构。堆顶为根,其它为左子树、右子树。
"""
# 调整堆,把最大值调整到堆顶
def adjust_heap(nums, i, size):
lchild = 2 * i + 1
rchild = 2 * i + 2
max = i
if i < size / 2:
if lchild < size and nums[lchild] > nums[max]:
max = lchild
if rchild < size and nums[rchild] > nums[max]:
max = rchild
if max != i:
nums[max], nums[i] = nums[i], nums[max]
adjust_heap(nums, max, size)
# 创建堆
def build_heap(lists, size):
for i in range(0, (size >> 1))[::-1]:
adjust_heap(lists, i, size)
# 堆排序
def heap_sort(lists):
size = len(lists)
build_heap(lists, size)
for i in range(0, size)[::-1]:
lists[0], lists[i] = lists[i], lists[0]
adjust_heap(lists, 0, i)
return lists
if __name__ == '__main__':
nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
result = heap_sort(nums)
print(result)
选择排序
"""
------------------------------- 选择排序 --------------------------------------
一、介绍
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,
存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
以此类推,直到所有元素均排序完毕。
二、步骤
选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上,则它不会被移动。选择排序每次交换一对元素,
它们当中至少有一个将被移到其最终位置上,因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换
去移动元素的排序方法中,选择排序属于非常好的一种。
"""
def selection_sort1(nums):
# 思路是将最小值逐一选择到前面
n = len(nums)
for i in range(n - 1):
min_index = i # 记录最小值的位置
for j in range(i + 1, n):
if nums[j] < nums[min_index]:
min_index = j
if min_index != i:
nums[i], nums[min_index] = nums[min_index], nums[i]
def selection_sort2(nums):
# 思路是将最大值逐一选择到后面
n = len(nums)
for i in range(n - 1, 0, -1):
max_index = i # 记录最大值的位置
for j in range(i):
if nums[j] > nums[max_index]:
max_index = j
if max_index != i:
nums[i], nums[max_index] = nums[max_index], nums[i]
if __name__ == '__main__':
nums = list(range(31,0,-1))
selection_sort2(nums)
print(nums)
插入排序
"""
------------------------------- 插入排序 --------------------------------------
一、介绍
插入排序(英语:Insertion Sort)是一种简单直观的排序算法。
二、步骤
通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
插入排序在实现上,在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。
"""
def insert_sort(nums):
for i in range(1, len(nums)):
for j in range(i, 0, -1):
if nums[j] < nums[j - 1]:
nums[j], nums[j - 1] = nums[j - 1], nums[j]
if __name__ == '__main__':
nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
insert_sort(alist)
print(alist)
希尔排序
"""
------------------------------- 希尔排序 --------------------------------------
一、介绍
希尔排序(Shell Sort)也是插入排序的一种。也称为缩小增量排序,是直接插入排序算法的一种更高效的改进版本。
希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。
二、步骤
将待排序列划分为若干组,在每一组内进行插入排序,以使整个序列基本有序,然后再对整个序列进行插入排。
"""
def shell_sort(nums):
size = len(nums)
gap = size >> 1
while gap > 0:
for i in range(gap, size):
j = i
while j >= gap and nums[j - gap] > nums[j]:
nums[j - gap], nums[j] = nums[j], nums[j - gap]
j -= gap
gap = gap >> 1
if __name__ == '__main__':
nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
shell_sort(nums)
print(nums)