python集合排序_排序算法集合

#### 冒泡排序

### 时间复杂度是： O(n^2)

### 空间复杂度是： O(1)

def BubbleSort(li):

for i in range(len(li)): # i = 0

flag = True

for j in range(len(li) - i - 1): ### j = 0, j = 1, j =2

if li[j] > li[j+1]: ### li[0]=1 > li[1]=2 | li[1]=2 > li[2]=3 | li[2] > li[3]

li[j], li[j+1] = li[j+1], li[j]

flag = False

if flag:

return None

#### 选择排序

### 时间复杂度是：O(n^2)

### 空间复杂度是：O(1)

def SelectSort(li):

for i in range(len(li)):

minLoc = i

for j in range(i + 1, len(li)):

if li[j] < li[minLoc]:

li[j], li[minLoc] = li[minLoc], li[j]

#### 插入排序

#### 时间复杂度：O(n^2)

#### 空间复杂度；O(1)

def InsertSort(li):

for i in range(1, len(li)):

tmp = li[i] ## i=2, tmp = 4

j = i - 1 ### j = 1

while j >= 0 and li[j] > tmp: ### li[1] = 7 > tmp = 4 | li[0]=5 > tmp=4

li[j+1] = li[j] ### j = 1

j = j - 1 ### j = 0 | j = -1

li[j + 1] = tmp ### li[0] = tmp = 4

#### 快速排序

#### 时间复杂度：O(nlogn)

def partition(li, left, right):

tmp = li[left]

while left < right:

while left < right and li[right] >= tmp:

right = right - 1

li[left] = li[right]

while left < right and li[left] <= tmp:

left = left + 1

li[right] = li[left]

li[left] = tmp

return left

def Quick_Sort(li, left, right):

if left < right:

mid = partition(li, left, right) ### O(n)

Quick_Sort(li, left, mid-1) #### O(logn)

Quick_Sort(li, mid+1,right)

### 归并排序

### 时间复杂度：O(nlogn)

### 空间复杂度：O(n)

#### python 底层 sorted()函数，采用的排序算法是 TimSorted 包含了归并排序和插入排序

#### TimSorted 的时间复杂度是：O(nlogn)

def merge(li, low, mid, high):

i = low

j = mid + 1

ltmp = []

while i <= mid and j <= high:

if li[i] <= li[j]:

ltmp.append(li[i])

i += 1

else:

ltmp.append(li[j])

j += 1

while i <= mid:

ltmp.append(li[i])

i += 1

while j <= high:

ltmp.append(li[j])

j += 1

li[low:high+1] = ltmp

def mergeSort(li, low, high):

if low < high:

mid = (low+high) // 2

### 分解

mergeSort(li, low, mid) ### O(logn)

mergeSort(li, mid+1, high)

print('分解后：',li[low:high + 1])

### 合并

merge(li, low, mid, high)

print('合并后：', li[low:high + 1])

###

### 计数排序

def countSort(li):

count = [0 for x in range(11)]

for i in li:

count[i] += 1

print(count)

li.clear()

for n, num in enumerate(count):

### n : 索引对应的是li中的值 n = 2

### num: 索引出现的次数对应的是li中的值出现的次数 num = 1

for x in range(num):

li.append(n)

li = [10,4,6,3,8,2,5,7]

countSort(li)

# mergeSort(li, 0, len(li)-1)

exit()

# li = [5,7,4,6,3,1,2,9,8]

# Quick_Sort(li, 0, len(li)-1)

# print(li)

# exit()

import time

import random

li = [random.randint(0, 10000) for i in range(100000)]

start_time = time.time()

Quick_Sort(li, 0, len(li)-1)

print("快速排序时间：%s" % (time.time() - start_time))

li = [random.randint(0, 10000) for i in range(100000)]

start_time = time.time()

BubbleSort(li)

print("冒泡排序时间：%s" % (time.time() - start_time))

li = [random.randint(0, 10000) for i in range(100000)]

start_time = time.time()

SelectSort(li)

print("选择排序时间：%s" % (time.time() - start_time))

li = [random.randint(0, 10000) for i in range(100000)]

start_time = time.time()

InsertSort(li)

print("插入排序时间：%s" % (time.time() - start_time))

本文地址：https://blog.csdn.net/qq_37156624/article/details/109645732

希望与广大网友互动？？

点此进行留言吧！

python集合排序_排序算法集合相关推荐

希尔排序python 简书_排序：希尔排序（算法）
文 | 莫若吻 (注:如果想更好的理解希尔排序,请先看看我的上一篇博客插入排序,希望会对你有帮助.) 一.简介希尔排序(Shell Sort)是插入排序的一种算法,是对直接插入排序的一个优化,也称缩 ...
Java冒泡，快速，插入，选择排序^_^+二分算法查找
这段时间在学Java,期间学到了一些排序和查找方法.特此写来和大家交流,也方便自己的日后查看与复习. 1.下边是Java的主类: public class Get {public static voi ...
c++ 二维数组排序_【算法】排序算法之计数排序
前几回,我们已经对[算法]排序算法之冒泡排序.[算法]排序算法之插入排序.[算法]排序算法之希尔排序.[算法]排序算法之选择排序.[算法]排序算法之快速排序.[算法]排序算法之归并排序.[算法]排序算 ...
java通过比较大小排序_排序算法的比较与java实现
冒泡排序基本思想: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重复以上 ...
降序排序_排序简单，应用不易，使用Excel排序的几点建议
对数据排序,是数据分析中最基本.最常用也是最重要的分析方法.Excel提供了丰富.简单.灵活的排序方法和排序方式,包括单个排序.组合排序等.对于学习者短时间内掌握Excel的排序,难度不大.问题可能更 ...
倒序排序_排序算法(六)：Counting Sort 计数排序
之前文章介绍的一些排序算法都是基于比较来进行排序的,故它们在平均情况下的时间复杂度最好也不过是线性对数级别.这里我们来介绍一种简单的基于非比较的排序算法--Counting Sort 计数排序,其时间 ...
java sorted排序_【算法】排序算法之计数排序
前几回,我们已经对冒泡排序.直接插入排序.希尔排序.选择排序.快速排序.归并排序.堆排序做了说明分析.本回,将对计数排序进行相关说明分析. 一.排序算法系列目录说明冒泡排序(Bubble Sort) ...
程序填充(指针):3数排序_排序算法之快速排序，它为什么这么快？
本文将介绍排序算法中最常用,以及最重要的快速排序. 1 快速排序实例快速排序由C. A. R. Hoare在1960年提出,是冒泡排序的一种改进.快速排序就跟它的名字一样,效率很快.跟冒泡排序,选择 ...
ds排序--希尔排序_排序算法 - 希尔排序分析及优化
希尔排序 1 算法思想希尔排序,也被称为递减增量排序,是简单插入排序的一种改进版本. 在插入排序中,如果待排序列中的某个元素,距离有序数列中待插入位置非常远,就需要比较很多次才可以到达插入位置,这是 ...

python集合排序_排序算法集合

python集合排序_排序算法集合相关推荐

最新文章

热门文章