快速排序法
一 、实例分析算法思路:
假设有一个数组 alist = [54,26,17,77,31,44,55,20], 按照升序排列
- 找到基准数: 一般取待排序序列的第一个,作为基准数
- 目标: 交换后, 基准数左边的数要全部小于基准数, 其右边的数要全部大于基准数
步骤如下:
1.序列第一个数作为排序基准数:54
2.从后往前找到比基准数小的数进行对换,循环找到20小于54,则20和54对换位置,否则右边下标前移,继续循环判断 <-----
alist = [20,26,17,77,31,44,55,54]
3.从前往后找到比基准数大的进行对换,23小于54,左边下标后移,继续循环找到17小于54,左边下标后移,继续循环找到77大于54,则,77和54对换位置,否则左边下标后移,继续循环判断 ----->
alist = [20,26,17,54,31,44,55,77]
4.从后往前找到比基准数小的数进行对换 <-----
alist = [20,26,17,44,31,54,55,77]
至此,以基准数分为3部分,左边的都比其小,右边的都比其大,第一次以45为基准数的排序完成
{20,26,17,44,31} {54} {55,77}
5.对于这两部分{20,26,17,44,31}, {55,77}再通过递归快速排序。
二 、算法实现
def quick_sort(alist,start,end):
if start > end:
return alist
reference = alist[start]
low = start
high = end
while start < end:
while start < end and alist[high] >= reference:
high -= 1
alist[low] = alist[high]
while start < end and alist[low] < reference:
low += 1
alist[high] = alist[low]
alist[low] = reference
quict_sort(alist,0,low-1)
quick_sort(alist,low+1,end)
return alist
if __name__ =="__main__":
alist = [54,26,17,77,31,44,55,20]
result = quick_sort(alist,0,len(alist)-1)
print(result)
注: 快速排序的最好的情况(每次数据划分得很均匀)时间复杂度为O(nlogn),最坏的情况(需排序的数据为正序或逆序排列时)复杂度为O(n^2)。
冒泡排序法
一、实例排序步骤分析
假设有一个数组 alist = [5,8,6,3,9,2,1,7], 按照升序排列
我们需要 拿第一个和第二个 对比,如果第一个比第二个大那么就换位置,如果小就不换。接下来拿第二个和第三个…这样依次下去比到最后 我们把这些数中最大的一个放在了右边, 然后再重复以上的方式,就把这些数中第二个大的放在了倒数第二位,依次下去…
二、算法实现
def Bubble_sort(alist):
n = len(alist)
for i in range(n-1):
count = 0
for j in range(n-1-i):
if alist[j] > alist[j+1]:
alist[j],alist[j+1] = alist[j+1],alist[j]
count += 1
if count == 0:
break
return alist
if __name__ == "__main__":
alist = [5,8,6,3,9,2,1,7]
result = Bubble_sort(alist)
print(result)
注:冒泡算法的时间复杂度O(n^2)
选择排序法
一、实例分析算法思路
假设有一个数组 alist = [54,26,93,17,77,31,44,55],按照升序排序
第一轮依次比较相邻两个元素,将最小的一个元素的索引和值记录下来,然后和第一个元素进行交换。
如上面的数组中,首先比较的是54和26,记录比较小是26,它的索引是1;接着比较26和93,记录比较小的索引还是1;直到最后得到最小值是17,它的索引是3;然后索引3和0互相交换, alist = [17,26,93,54,77,31,44,55]
第二轮比较的时候,由于第一轮已经找出了一个最小的数17,所以,就不用再管它了,它已经处于“有序区”,接下来,才是第二轮的正式工作的开始,即按照第一轮的方法,找出“无序区”中最小的一个元素,让它和索引1位置的数进行交换,即像上文中“原理”中提到的那样——每一轮比较得出最小的那个值,然后依次和每轮“无序区”中参与比较的第一个值进行交换。同理类推~
二、算法实现
def select_sort(alist):
for i in range(len(alist)-1):
min_index = i
for j in range(i+1,len(alist)):
if alist[min_index] > alist[j]:
min_index = j
if min_index != i:
alist[min_index],alist[i] = alist[i],alist[min_index]
return alist
if __name__ == "__main__":
alist = [54,26,93,17,77,31,44,55]
result = select_sort(alist)
print(result)
插入排序法
一、实例分析算法思路
假设有一个数组 alist = [5,2,4,6,1,3],按照升序排序
对于一个数组,我们从第二个数字开始,将其认为是新增加的数字,这样第二个数字只需与其左边的第一个数字比较后排好序;在第三个数字,认为前两个已经排好序的数字为手里整理好的牌,那么只需将第三个数字与前两个数字比较即可;以此类推,直到最后一个数字与前面的所有数字比较结束,插入排序完成。
二、算法实现
def insert_sort(alist):
for j in range(1,len(alist)):
i = j
while i > 0:
if alist[i] > alist[i-1]:
alist[i],alist[i-1] = alist[i-1],alist[i]
else:
break
i -= 1
return alist
if __name__ == "__main__":
alist = [5,2,4,6,1,3]
result = insert_sort(alist)
print(result)
归并排序法
一、实例分析算法思路
假设有一个数组 alist = [54,26,93,17,77,31,44,55],按照升序排序
归并排序法,首先是分解
[54,26,93,17,77,31,44,55]
[54,26,93,17] [77,31,44,55]
[54,26] [93,17] [77,31] [44,55]
[54] [26] [93] [17] [77] [31] [44] [55]
再比较列表数字大小进行合并
[26,54] [17,93] [31,77] [44,55]
[17,26,54,93] [31,44,55,77]
[17,26,31,44,54,55,77,93]
二、算法实现
def merge_sort(nums):
n = len(nums)
if n <= 1:
return nums
mid = n // 2
left_li = merge_sort(nums[0:mid])
right_li = merge_sort(nums[mid:])
result = []
left_point,right_point = 0,0
while left_point < len(left_li) and right_point < len(right_li):
if left_li[left_point] < right_li[right_point]:
result.append(left_li[left_point])
left_point += 1
else:
result.append(right_li[right_point])
right_point += 1
result += left_li[left_point:]
result += right_li[right_point:]
return result
if __name__ == "__main__":
alist = [54,26,93,17,77,31,44,55]
result = merge_sort(alist)
print(result)