排序算法

排序算法的理解

现在家里事情不多，就总结了一下排序算法，以后找工作时，也好使用，主要使用python3实现的。大家有兴趣可以自己实现。

1. 冒泡排序

       冒泡排序是简单的排序方式，靠循环遍历来完成，它的时间复杂度是非常高的，为$O(n^2)$，并且只是用了一个额外的数值交换空间——temp变量，因此他的空间复杂度为$O(1)$，是典型的拿时间换取空间的表现，下面是代码以及代码分析。

def Bubble_sort(array):   
    length = len(array)			#计算数组长度
    for i in range(length):
        for j in range(i+1,length):
            if array[i] > array[j]:
                temp = array[i]
                array[i] = array[j]
                array[j] = temp
    return array

排序思想与理解
    首先 array 是待排序序列，先计算出数组的排序长度，进行两层循环，从0下标开始，找到数组中最小的元素，放到0下标处，依次到下标1,2,3…，最终可以实现数组从小到大的序列排序

2. 选择排序

        选择排序是简单的排序方式，靠循环遍历来完成，它的时间复杂度是非常高的，为$O(n^2)$，并且只是用了一个额外的数值交换空间——temp变量，因此他的空间复杂度为$O(1)$，是典型的拿时间换取空间的表现，下面是代码以及代码分析。

def Selection(array) : 
    length = len(array)		#计算数组长度
    for i in range (0,length-1):
        pos_temp = i
        for j in range (i, length):
            if array[pos_temp] > array[j]:
                pos_temp = j
        data_temp = array[pos_temp]
        array[pos_temp] = array[i]
        array[i] = data_temp
    return array

排序思想与理解
    nbsp;   首先 array 是待排序序列，先计算出数组的排序长度，进行两层循环，从0下标开始，找到数组中最小的元素，放到0下标处，依次到下标1,2,3…，最终可以实现数组从小到大的序列排序

3. 插入排序

        插入排序是简单的排序方式，它的时间复杂度是非常高为$O(n^2)$，他的空间复杂度为$O(1)$

def Insert_sort(array):
    length = len(array)
    for i in range(1, length):
        data_temp = array[i]
        j = i - 1
        while j >= 0 and data_temp < array[j]:
            array[j+1] = array[j]
            j = j - 1
        array[j+1] = data_temp
    return array

排序思想与理解**
        从下标为1的数组位置开始循环，默认前面数组已经是有序的了，将数字按照排序方式插入到前面的有序序列当中去。可以循环下去，最终将数组完全排序。

4. 希尔排序

    希尔排序是插入排序的升级版本，它的时间复杂度是非常高为$O(n^{3/2})$，他的空间复杂度为$O(1)$

def Shell_sort(self, array):
    length = len(array)
    gap = length / 2
    while gap > 0:
        for i in range(gap,length):
            data_temp = array[i]
            j = i - gap
            while j >= 0 and data_temp < array[j]:
                array[j+gap] = array[j]
                j = j - gap
            array[j+gap] = data_temp
        print(gap)
        gap = gap /2
    return array

排序思想与理解
        它将插入排序的间隔从1增大为gap，之后gap逐渐减小为1时停止，完成排序。它主要领先的部分gap>1,在gap大于1时，gap使得插入时所进行的位置的移动成本减小，因此，他的效率要高于插入排序。

5. 归并排序

        利用递归的方法进行归并排序，这是一种分而治之的思想,它的时间复杂度是非常高为$O(nlogn)$，他的空间复杂度为$O(n)$

def Merge_sort(array):
    if len(array) <= 1:
        return array
    mid = len(array) // 2
    left  = self.Merge_sort(array[:mid])
    right = self.Merge_sort(array[mid:])

    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i = i +1
        else:
            result.append(right[j])
            j = j +1
    if i == len(left):
        result.extend(right[j:])
    else:
        result.extend(left[i:])
    return result

排序思想与理解
        首先把数组按照物理位置分开成小段，按照小段进行排序，然后在把有序小段之间进行组合排序，这样就能够实现数组的排序。

6. 快速排序

    快速排序是一种平均时间复杂度也是$O(nlogn)$,空间复杂度为$O(logn)$

def Quick_sort(array):
    less = []
    more = []
    tag_list = []

    if len(array)<=1:
        return array
    tag = array[0]
    for i in array:
        if i < tag:
            less.append(i)
        elif i> tag:
            more.append(i)
        else:
            tag_list.append(i)
    less = self.Quick_sort(less)
    more = self.Quick_sort(more)
    return less + tag_list + more

排序思想与理解
        它的主要思路是寻找一个中间的元素，将数组分成比tag大，小的两个部分，然后递归最终实现快速排序。

7. 计数排序

        它的空间复杂度与数组中的最大数值有关，与n无关。

def Count_sort(array):
    count = [0] *1000
    for i in array:
        count[i] = count[i] + 1
    print(count)
    j = 0 
    for i in range (len(count)):
        if count[i] > 0 :
            while count[i] !=0:
                count[i] = count[i] - 1
                array[j] = i
                j = j + 1
    return array

排序思想与理解
    相当于用空间来排序，空间换取时间。

8. 堆排序

        通过二叉树进行排序，它的时间复杂度为$O(nlogn)$

def min_heap(A,i,Heap_size = None):
	if not Heap_size:
    	Heap_size = len(A)

	left = 2 * i + 1
    right = 2 * i + 2

	if left < Heap_size and A[left] < A[i]:
    	least = left
    else:
	    least = i
    if right < Heap_size and A[right] < A[least]:
	    least = right
    if least != i:
	    A[i], A[least] = A[least], A[i]
    	min_heap(A,least,Heap_size)

def build_heap(A, heap_size=None):			#创建堆
    if not heap_size:
	    heap_size = len(A)
    i = int(heap_size / 2) - 1
	while i >= 0:
    	min_heap(A, i, heap_size)
        i -= 1    
def Heap_sort(A,Heap_size = None):
	if not Heap_size:
    	Heap_size = len(A)
	build_heap(A)
	start = Heap_size - 1
	for i in range(start,0,-1):
    	print(i)
    	A[0], A[i] = A[i], A[0]
    	Heap_size = Heap_size- 1
   		min_heap(A, 0,Heap_size)

排序思想与理解
        它的排序是完全通过二叉树实现的。

9. 基数排序

        

def Cardinal_sort(array):
    n = 0
    data_max = max(array)
    while data_max > 10**n :
        n = n + 1
    print(n)
    i = 0
    while i < n:
        bucket = {}
        for x in range(10):
            bucket.setdefault(x,[])
        for x in array:
            remainder = int (x/10**i) %10
            bucket[remainder].append(x)
        j = 0
        for x in range(10):
            if len(bucket[x])!=0 :
                for y in bucket[x]:
                    array[j] = y
                    j = j + 1
        i = i + 1
    return array

排序思想与理解
        利用从低到高位进行排序，这样只能排列整数吧。

10. 桶排序

        

def Bucket_sort(array):
    max_num = max(array)
    bucket = [0]*(max_num+1)
    for i in array:
        bucket[i] = bucket[i] + 1
    index = 0
    for j in range(max_num+1):
        if bucket[j] != 0:
            while bucket[j]:
                bucket[j] = bucket[j] - 1
                array [index] = j
                index = index + 1
    return array

排序思想与理解
        感觉这个和计数排序一模一样的。