排序算法使用范围与代码实现

排序算法

1. 当数据规模较小时候，可以使用简单的直接插入排序或者直接选择排序。
2. 当文件的初态已经基本有序，可以用直接插入排序和冒泡排序。
3. 当数据规模较大时，应用速度最快的排序算法，可以考虑使用快速排序。当记录随机分布的时候，快速排序平均时间最短，但是出现最坏的情况，这个时候的时间复杂度是O(n^2)，且递归深度为n,所需的占空间为O(n)。
4. 对排序不会出现快排那样最坏情况，且堆排序所需的辅助空间比快排要少，但是这两种算法都不是稳定的，要求排序时是稳定的，可以考虑用归并排序。
5. 归并排序可以用于内部排序，也可以使用于排不排序。在外部排序时，通常采用多路归并，并且通过解决长顺串的合并，缠上长的初始串，提高主机与外设并行能力等，以减少访问外存额外次数，提高外排的效率。

• 冒泡排序

    #遇见逆序就交换
    class Solution:
        def sortArray(self, nums):
            #冒泡排序
            for i in range(len(nums)):
                for j in range(i,len(nums)):
                    if nums[i]>nums[j]:
                        nums[i],nums[j]=nums[j],nums[i]
            return nums
  

• 插入排序

    #将后面的数依次往前面插
    class Solution:
        def sortArray(self, nums):
            #插入排序
            for i in range(1,len(nums)):
                tmp=nums[i]
                j=i-1
                
                while j>=0 and nums[j]>tmp:
                    nums[j+1]=nums[j]
                    j-=1
                nums[j+1]=tmp          
            return nums
  

• 选择排序

    	#遍历每次找到最小值交换
    	class Solution:
    	    def sortArray(self, nums):
    	        #选择排序
    	        
    	        for i in range(len(nums)):
    	            min_index=i
    	            for j in range(i+1,len(nums)):
    	                if nums[j]<nums[min_index]:
    	                    min_index=j
    	            nums[i],nums[min_index]=nums[min_index],nums[i]
    	        return nums
  

• 快速排序

    	#先找主元，再进行分区
    	class Solution:
    	    def sortArray(self, nums):
    	        #快速排序
    	        if len(nums)<2:
    	            return nums
    	        
    	        mid=nums[len(nums)//2]
    	        nums.remove(mid)
    	        left,right=[],[]
    	        
    	        for i in nums:
    	            if i>=mid:
    	                right.append(i)
    	            else:
    	                left.append(i)
    	        
    	        return self.sortArray(left)+[mid]+self.sortArray(right)
  

• 归并排序

    	#每次都一分为二，最后合并
    	class Solution:
    	    def sortArray(self, nums):
    	        #归并排序
    	        return self.mergesort(nums)
    	    def mergesort(self,nums):
    	        if len(nums)<2:
    	            return nums
    	        mid=len(nums)//2
    	        left=nums[:mid]
    	        right=nums[mid:]
    	        return self.merge(self.mergesort(left),self.mergesort(right))
    	    
    	    def merge(self,nums1,nums2):
    	        result=[]
    	        i=0
    	        j=0
    	        
    	        while i<len(nums1) and j<len(nums2):
    	            if nums1[i]>=nums2[j]:
    	                result.append(nums2[j])
    	                j+=1
    	            else:
    	                result.append(nums1[i])
    	                i+=1
    	        result+=nums1[i:]
    	        result+=nums2[j:] 
    	        return result
  

• 堆排序

    		#不需要手动维护堆，直接调用堆进行。
    		class Solution:
    		    def sortArray(self, nums):
    		        self.heapSort(nums)
    		        return nums
    
    		    def heapify(self,arr, n, i): 
    		        largest = i  
    		        l = 2 * i + 1     # left = 2*i + 1 
    		        r = 2 * i + 2     # right = 2*i + 2 
    		
    		        if l < n and arr[largest] < arr[l]: 
    		            largest = l 
    		
    		        if r < n and arr[largest] < arr[r]: 
    		            largest = r 
    		
    		        if largest != i: 
    		            arr[i],arr[largest] = arr[largest],arr[i]  # 交换
    		            self.heapify(arr, n, largest)
    		            
    		        print(arr)
    		
    		    def heapSort(self,arr): 
    		        n = len(arr) 
    		
    		        # Build a maxheap. 
    		        for i in range(n//2, -1, -1): 
    		            print(n,i)
    		            self.heapify(arr, n, i) 
    		        
    		        print(arr)
    		        print('--------------')
    		
    		        # 一个个交换元素
    		        for i in range(n-1, 0, -1): 
    		            arr[i], arr[0] = arr[0], arr[i]   # 交换
    		            self.heapify(arr, i, 0)