排序一_把堆的尺寸缩小1-CSDN博客

文章目录

1.插入排序

算法

首先将序列的第一个元素看作有序序列，把第二个元素到最后一个元素当作未排序序列
从头到尾依次扫描未排序的序列
- 将扫描到的元素和有序序列依次从后向前比较，如果有序序列的数值较大，移动到有序序列的后一个位置
- 直到有序序列的元素小于等于扫描到的元素，将扫描到的元素插入有序序列

例如图中元素2待排序，与前面已排序的序列相比，比2大的元素[5,15,26,27,36,38,44,47]全部向后移一位，将2插入到排序序列中。

def insertSort(arr):
	for i in range(len(arr)):
		preIndex = i-1
		current = arr[i]
		while preIndex >0 and arr[preIndex] > current:
			current[preIndex+1] = current[preIndex]
			preIndex -= 1
		arr[preIndex+1] = current
	return arr

2. 堆排序

刷题的时候遇见很多前k项、第k项之类的，用的都是最大堆、最小堆，所以还是先写一下最大堆、最小堆的部分实现

最小堆

class MinHeap(object):
    def __init__(self, size):
        self.heap = []
        self.size = size

	#插入元素
    def add_min_heap(self, item):
        if self.get_size() == self.size:
            print("当前堆已满")
       
        #首先在顶端插入当前值，再进行调整
        self.heap.insert(0, item)
        heap_len = self.get_size()
        #如果这是唯一一个元素，直接返回
        if heap_len == 1:
            return
		#否则调整当前堆
        current_index = 0
		heapify(current_index )
		
	#调整堆
	def heapify(current_index ):
		min_index = current_index
		#左子节点
        left_index = current_index*2 + 1
        #右子节点
        right_index = (current_index+1) * 2
         heap_len = self.get_size()
        if right_index < heap_len and self.heap[left_index ] < self.heap[current_index]:
        	min_index = left_index 
        if right_index  < heap_len and self.heap[right_index ] < self.heap[min_index]:
        	min_index = right_index 
        if min_index != current_index:
        	self.swap(current_index, min_index)
        	heapify(min_index)
    
	#两个元素互换位置
    def swap(self, target_index, current_index):
        self.heap[target_index],self.heap[current_index] = self.heap[current_index],self.heap[target_index]

	#父元素
    def get_father_index(self, current_index):
        if current_index % 2 != 0:
            father_index = current_index // 2
        else:
            father_index = (current_index - 1)//2
        return father_index

    def get_size(self):
        return len(self.heap)
        
	#最小值
    def peek(self):
        return self.heap[0]

最大堆

class MaxHeap():
	    def __init__(self, size):
	        self.heap = []
	        self.size = size
        
        #由列表创建最大堆
        def buildMaxHeap(arr):
        	self.heap = arr
        	self.size = len(arr)
        	#从倒数第一个有子节点的子堆开始，从右底端调整堆
        	for i in range(len(arr)//2,-1,-1):
        		heapify(i)
        	
        #调整堆
        def heapify(current_index ):
			max_index = current_index
	        left_index = current_index*2 + 1
	        right_index = (current_index+1) * 2
	        heap_len = self.get_size()
	        if left_index  <heap_len and self.heap[left_index  ] > self.heap[current_index]:
	        	max_index = left_index  
	        if right_index  < heap_len and self.heap[right_index ] > self.heap[min_index]:
	        	max_index = right_index 
	        if max_index != current_index:
	        	self.swap(current_index, max_index )
	        	heapify(max_index )
	    
		#两个元素互换位置
    	def swap(self, target_index, current_index):
        	self.heap[target_index],self.heap[current_index] = self.heap[current_index],self.heap[target_index]
        	
        def get_size(self):
        	return len(self.heap)

堆排序

算法：

用已有列表创建一个大顶堆
把堆顶和堆尾的元素互换
把堆的尺寸缩小1，调整当前堆顶元素的位置，使之称为新的大顶堆
重复，直至堆的尺寸为1
优点：当待排序的数组占用内存非常大时，不用多占用内存。O(nlogn)

#换位置
def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]
#调整最大值位置
def heapify(arr, i):
    left = 2*i+1
    right = 2*i+2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
        largest = right

    if largest != i:
        swap(arr, i, largest)
        heapify(arr, largest)

#利用原始数组，创建堆
def buildMaxHeap(arr):
    import math
    #在《树 三》有关最大堆创建中涉及，先调整最底层最右侧的堆，
    #逐渐向左上调整，最后就变成了最大堆结构
    for i in range(math.floor(len(arr)/2),-1,-1):
        heapify(arr,i)
#排序
def heapSort(arr):
    global arrLen
    #堆的当前尺寸
    arrLen = len(arr)
    #创建堆
    buildMaxHeap(arr)
    for i in range(len(arr)-1,0,-1):
    	#把堆顶和堆尾交换位置
        swap(arr,0,i)
        #并且堆的尺寸减少1
        arrLen -=1
        #重新调整堆
        heapify(arr, 0)
    return arr

3. 计数排序

如果列表是n个0-k之间的整数，运行时间是O(n+k)；只适合数据范围[0,100]之间的小范围列表，因为他需要开辟数据范围长度的内存。
算法“：

找出待排序数组中的最大值、最小值
统计数组中每个元素出现的次数，存入数组中
反向填充目标数组

def countingSort(arr, maxValue):
    bucketLen = maxValue+1
    bucket = [0]*bucketLen
    sortedIndex =0
    arrLen = len(arr)
    for i in range(arrLen):
        if not bucket[arr[i]]:
            bucket[arr[i]]=0
        bucket[arr[i]]+=1
    for j in range(bucketLen):
        while bucket[j]>0:
            arr[sortedIndex] = j
            sortedIndex+=1
            bucket[j]-=1
    return arr

4. 桶排序

利用函数的映射关系，把元素放到不同的桶中，在桶中进行排序，然后取出

#桶排序
def bucketsort(arr, bucketsize=5):
    if len(arr) == 0:
        return arr
    minvalue = min(arr)
    maxvalue = max(arr)
    
    #初始化桶
    bucketcount = (maxvalue - minvalue)//bucketsize + 1
    buckets = [None]*bucketcount
    for i in range(bucketcount):
        buckets[i] = []

    #将数据映射到桶中
    for i in arr:
        buckets[(i-minvalue)//bucketsize].append(i)
    
    arrReturn = []
    #对每个桶进行排序
    for i in buckets:
    	#调用了插入排序
        insertsort(i)
        arrReturn.extend(i)
    return arrReturn