常见排序算法python实现

最新推荐文章于 2023-05-13 15:27:21 发布
最新推荐文章于 2023-05-13 15:27:21 发布
阅读量131 收藏
点赞数
分类专栏： 算法学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hpuexplorer/article/details/105107421
版权

文章目录

1. 冒泡排序

冒泡排序法的复杂度是O(n^2)

# buble sort
def buble_sort(inList):
    for i in range(len(inList)):
        for j in range(len(inList)-i-1):
            if inList[j] <= inList[j+1]:
                continue
            else:
                inList[j], inList[j+1] = inList[j+1], inList[j]
    return inList

2插入排序

插入排序，取数组里每一个元素，插入一个新的列表里，插入的时候，保证新的列表按照顺序排列，把最后一个元素插入完成之后，也完成了整个数组的排序。以下为实现方式。

#insertion sort
def insertion_sort(list1):
    temp = []
    for i in range(len(list1)):
    	# 每一个循环，往temp中放入一个数据
        temp.append(list1[i])
        j = len(temp) - 1
        while True and j>0:
        	# 如果数组中有数据，则把数据放入放在第一个大于他的数字前面，从而保证排序
            if temp[j] < temp[j-1]:
                temp[j], temp[j-1] = temp[j-1], temp[j]
            j -= 1
    return temp

实现过程中，temp完全可以不存在。程序编写如下。

 def insertion_sort(list1):
    for i in range(2, len(list1)):
    	# 每一个循环，往temp中放入一个数据\
        j = i
        while True and j>0:
        	# 如果数组中有数据，则把数据放入放在第一个大于他的数字前面，从而保证排序
            if list1[j] < list1[j-1]:
                list1[j], list1[j-1] = list1[j-1], list1[j]
            j -= 1

3归并排序

归并排序是采用分而治之的原则，先将要排序的数组分成两部分，再将剩余部分再分，直至每个数组只剩下一个或者两个元素，进行排序。之后，再进行归并。
算法核心部分是归并的过程，分别从两个数组中取元素，按照顺序排列，当其中一个取尽时，另一个数组剩下的部分就追加到这个元素后面，从而实现排序的目的。

# merge ort
def merge(list1, list2):
    temp = []
    i = j = 0
    while True:
        if i== len(list1):
            temp.extend(list2[j:])
            break
        if j== len(list2):
            temp.extend(list1[i:])
            break

        if list1[i] <= list2[j]:
            temp.append(list1[i])
            i += 1
        else:
            temp.append(list2[j])
            j += 1
    return temp

def merge_sort(list1):
    length = len(list1)
    if length == 1:
        return list1
    elif length == 0:
        return []
    splitIndex = int(length/2)
    left_arr = list1[:splitIndex]
    right_arr = list1[splitIndex:]
    return merge(merge_sort(left_arr), merge_sort(right_arr))

4堆排序

堆排序主要分三个过程

  1. 构建最大堆或者最小堆
    最大堆满足的性质：A[parent[i]] >= A[i]
    最小堆满足的性质：A[parent[i]] <= A[i]
  2. 交换堆顶和本次调整最后一个数据。
  3. 最大节点值减掉1，重复前两步
import random
def reAdjustHeap(dataIn, maxNodeIndex):
    nodeIndex = (maxNodeIndex-1)//2
    while nodeIndex>=0:
        # adjust node
        leftIndex =  nodeIndex*2 + 1
        rightIndex = nodeIndex*2 + 2
        if rightIndex <= maxNodeIndex:
            if dataIn[nodeIndex]<dataIn[rightIndex]:
                dataIn[nodeIndex], dataIn[rightIndex] = dataIn[rightIndex], dataIn[nodeIndex]
        if dataIn[nodeIndex]<dataIn[leftIndex]:
                dataIn[nodeIndex], dataIn[leftIndex] = dataIn[leftIndex], dataIn[nodeIndex]
        nodeIndex -= 1

def heapSort(Arr):
    maxNodeIndex = len(Arr)-1
    while maxNodeIndex>1:
        reAdjustHeap(Arr, maxNodeIndex)
        print("dataIn[0]={} dataIn[maxNodeIndex]={} maxNodeIndex".format(Arr[0], Arr[maxNodeIndex],maxNodeIndex))
        # swap head with tail
        Arr[0], Arr[maxNodeIndex] = Arr[maxNodeIndex], Arr[0] 
        maxNodeIndex -= 1

if __name__ == "__main__":
    length = 1000
    A = [random.randint(0,length) for i in range(length)]
    heapSort(A)
    print(A)

5最大（小）优先队列

堆排序的一个典型应用就是最大（小）优先队列。
最大有限序列支持的方法有

  1. Insert:将一个新元素增加到新新的集合中
  2. max ：返回最大键字的元素
  3. extractMax:返回并去掉最大键字元素。
  4. increaseKey:将一个关键字的值增加到另一个值
class PriorityQueue():
    def __init__(self, arrData=None):
    # 初始化，并排成最大堆
        self.data = []
        if arrData is not None:
            self.data = arrData
        self.reAdjustHeap(self.data, len(self.data)-1)
	
    def heapSort(self):
    	# 实现堆排序，但结果保存在副本，不对原数据造成影响
        Arr = self.data[:]
        maxNodeIndex = len(Arr)-1
        while maxNodeIndex>1:
            self.reAdjustHeap(Arr, maxNodeIndex)
            # swap head with tail
            Arr[0], Arr[maxNodeIndex] = Arr[maxNodeIndex], Arr[0] 
            maxNodeIndex -= 1  
        return Arr 

    @staticmethod
    def reAdjustHeap(dataIn, maxNodeIndex):
    	# 静态方法，完成最大堆调整
        nodeIndex = (maxNodeIndex-1)//2
        while nodeIndex>=0:
            # adjust node
            leftIndex =  nodeIndex*2 + 1
            rightIndex = nodeIndex*2 + 2
            if rightIndex <= maxNodeIndex:
                if dataIn[nodeIndex]<dataIn[rightIndex]:
                    dataIn[nodeIndex], dataIn[rightIndex] = dataIn[rightIndex], dataIn[nodeIndex]
            if dataIn[nodeIndex]<dataIn[leftIndex]:
                    dataIn[nodeIndex], dataIn[leftIndex] = dataIn[leftIndex], dataIn[nodeIndex]
            nodeIndex -= 1

	# 插入操作
    def insert(self, data):
        self.data = list(set(self.data) | {data})
        self.reAdjustHeap(self.data, len(self.data)-1)
        
	# 返回堆顶
    def maxData(self):
        return self.data[0]
        
	# 返回并去除堆顶
    def extractMaxData(self):
        maxNodeIndex = len(self.data)-1
        self.data[0], self.data[maxNodeIndex] = self.data[maxNodeIndex], self.data[0] 
        maxData = self.data[-1]
        del self.data[-1]
        return maxData
    
    # 更改优先级
    def updateKey(self, i, data):
        self.data[i] = data
        if data< self.data[parentNode]:
            return self.data
        reAdjustHeap(dataIn, maxNodeIndex)
        return self.data
        
if __name__ == "__main__":
    obj = PriorityQueue([3,12,5])
    print(obj.data)

快速排序

快速排序的思想是分治，将一个完整数组分解成一个个更小的数组进行排序。
其核心部分是对数组进行分割的过程，即取一个分割数组的元素，然后将数组分成小于等于这个元素和大于这个元素的两部分。
最终实现原址排序的效果

def quickSort(A, p, r):
    if p >= r:
        return
    # 数据分割
    q = partition(A, p, r)
    quickSort(A, p, q-1)
    quickSort(A, q, r)

def partition(A, p, r):
    print("p={} r={}".format(p,r))
    splitElement = A[r]
    i = p
    for j in range(p+1, r):
        if A[j] <= splitElement:
            i += 1
            A[i], A[j] = A[j], A[i]

    A[i+1], A[r] = A[r], A[i+1]
    return i+1

if __name__ == "__main__":
    data = [1, 4, 7, 9, 12, 10, 8,4, 8] 
    quickSort(data, 0, len(data)-1)
    print(data)

以上算法中，分割元素都是采用的是取最后一个元素作为分割元素，这样有可能会影响算法效率，一种改进措施是，采用随机算法选取分割元素（主元素）。将partition函数按照如下方式进行改写。

def quickSort(A, p, r):
    if p >= r:
        return
    q = partition(A, p, r)
    quickSort(A, p, q-1)
    quickSort(A, q, r)

def partition(A, p, r):
    import random
    print("p={} r={}".format(p,r))
    # 随机选取主元素
    splitElement = A[random.randint(p,r)]
    i = p
    for j in range(p+1, r):
        if A[j] <= splitElement:
            i += 1
            A[i], A[j] = A[j], A[i]

    A[i+1], A[r] = A[r], A[i+1]
    return i+1

if __name__ == "__main__":
    data = [1, 4, 7, 9, 12, 10, 8,4, 8] 
    quickSort(data, 0, len(data)-1)
    print(data)

计数排序

计数排序的要求是，输入数据位非负整数序列。
核心思想是，利用数组索引的顺序特性，将数据元素转化为数组的索引，这样实现自动排序的目的。
计数排序再实现速度的同时，也牺牲了空间。如代码中，C数组的使用，浪费的大量空间。

def countSort(A):
    # 初始化C用于计数
    maxIndex = max(A)
    minIndex = min(A)
    C = []
    [C.append(0) for _ in range(maxIndex-minIndex+1)] 

    # 统计每一个元素的，其实就默认实现了数组的排序
    for i in range(len(A)):
        C[A[i]-minIndex] += 1
    
    # 取出结果放到B中
    B = []
    for j in range(len(C)):
        count = C[j]
        # print("count={}".format(count))
        while count > 0:
            B.append(j+minIndex)
            count -= 1

    return B

if __name__ == "__main__":
    A = [10, 3, 5, 7, 9, 4]
    print(countSort(A))
石头会说话20
关注
专栏目录
Python——常见排序算法解析
m0_59485658的博客
12-03 616
非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。
算法基础_数组、链表、选择排序
因热爱而坚持，因坚持而愈发热爱。
02-26 150
摘要：数组、链表的原理、优缺点，算法2：选择排序
数据结构-堆排序
zongx的博客
01-15 130
堆排序： 学习网站：https://www.cs.usfca.edu/~galles/visualization/HeapSort.html //先了解两个概念 // 大顶堆：每个节点的值都大于或者等于它的左右子节点的值。 // 小顶堆：每个节点的值都小于或者等于它的左右子节点的值。 //堆排序的基本思想是： // 1、将带排序的序列构造成一个大顶堆，根据大顶堆的性质，当前堆的根节点（堆顶）...
用Python实现几种常见的排序
L13259431663的博客
08-14 572
冒泡排序 插入排序 选择排序 快速排序 冒泡排序 这是最容易想到的排序方式了，依次遍历第一个元素和每一个元素比较大小，然后循环第二个元素和第二个往后的每个元素比较大小。 def maopao_sort(rlist): for i in range(len(rlist)): for j in range(i+1, len(rlist)): ...
python 排序算法
weixin_41643439的博客
02-12 180
https://www.cnblogs.com/kuqs/p/6579741.html （一）插入排序 每次循环之前，前面i位总是有序的。 1 def insert_sort(list): 2 for i in range(len(list)): 3 key = list[i] 4 for j in range(i-1,-1,-1): 5 ...
漫画排序算法Python实现
犇犇
09-21 282
电子书和源码下载：p3xw 冒泡排序 #冒泡排序的思想，我们要把相邻的元素两两比较，当一个元素大于右侧相邻元素时， #交换它们的位置；当一个元素小于或等于右侧相邻元素时，位置不变。 def bubbleSort(list): #range返回一个序列的数 不指定返回具体值 len值长度 for i in range(len(list) - 1): #Python里true、false赋值首字母大写 isSorted = True for j i
python实现常见的排序算法
缘来如此
05-07 5151
# coding: utf-8 """常见排序算法正序实现""" def bubble_sort(arr): """ 冒泡排序：稳定排序，最差和平均时间复杂度O(n^2)，最优情况是O(n)，即原数组是已排好序的情况，空间复杂度O(1)，即交换操作时使用的临时空间 实现：比较相邻元素，将较小的放在前面，重复执行，直到所有元素满足正序。 """ n = len(arr) for i in range(0, n): # 表示排序的轮次 is.
Python实现排序算法
weixin_74313494的博客
05-13 1668
具体实现时，侏儒排序从序列的第一个元素开始，依次比较相邻的两个元素，如果它们是逆序对（即前面的元素比后面的元素大），则交换这两个元素的位置。在每次循环中，首先比较当前位置和前一个位置的元素，如果它们是逆序对，则交换这两个元素的位置，然后将 i 减一，表示回溯到前一个位置；具体实现时，鸡尾酒排序的排序过程类似于摇晃鸡尾酒的过程，即从左到右扫描序列，然后从右到左扫描序列，然后再从左到右扫描序列，如此往复，直到序列已经排好序为止。在每次扫描过程中，都要注意将最大的元素往右边交换，将最小的元素往左边交换。
Python实现十大排序算法
热门推荐
weixin_44852067的博客
07-17 1万+
python实现十大排序算法
快速排序算法python实现.zip
最新发布
05-22
下面是一个简单的Python实现： ```python def quick_sort(lst): if len(lst) return lst pivot = lst[0] less = [x for x in lst[1:] if x ] greater = [x for x in lst[1:] if x > pivot] return quick_...
python 常见的排序算法实现汇总
09-16
本文将深入探讨几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序和归并排序。这些算法主要分为比较类排序，它们通过元素之间的比较来决定顺序。 1. **冒泡排序**：冒泡...
python实现五种常见排序算法
12-21
以下是用Python实现的五种常见排序算法： 1. 冒泡排序（Bubble Sort）： ```python def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+...
python实现八大常见排序算法
12-21
本篇文章将探讨八大常见排序算法的Python实现，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、计数排序和基数排序。 1. 冒泡排序（Bubble Sort） 冒泡排序是最基础的排序算法之一，它通过重复...
聚类算法的评价指标
石头会说话 的博客
04-14 3822
邓恩（dunn）指标 dunn指标指的是任意一个簇种的点最短距离除以任意两个簇之间的最长距离。DVI越大代表类间距越大、同时类内间距越小。 轮廓系数（Silhouettes） 样本轮廓系数 s=b−amax(a,b) s=\frac {b-a}{max(a,b)} s=max(a,b)b−a​ 总体轮廓系数 sc=1NΣi=1Ns sc=\frac1N\Sigma_{i=1}^Ns sc=N1​Σi=1N​s 其中 a：某个样本与其所在簇内其他样本的平均距离 b：某个样本与其他簇样本的平均距离 所有样本的轮
模型选择标准
石头会说话 的博客
04-14 1085
若干个模型训练成功之后，如何判定模型的优劣呢？通常有AIC、BIC和HQ三个指标，分别解释如下 AIC赤池信息量 中文名字：赤池信息量 akaike information criterion AIC是衡量统计模型拟合优良性的一种标准，由日本统计学家赤池弘次在1974年提出，它建立在熵的概念上，提供了权衡估计模型复杂度和拟合数据优良性的标准。 AIC=−2ln(L)+2k AIC = -2ln(L)+2k AIC=−2ln(L)+2k 一般而言，当模型复杂度提高（k增大）时，似然函数L也会增大，从而使AIC
分治策略求解最大子数组
石头会说话 的博客
04-02 439
分治策略就是把复杂的问题分成更小的问题来求解，求解过程中会涉及到以下三个步骤： 分解：分解步骤将问题划分为一些子问题，子问题的形式与原问题一样，只是规模更小，求解更简单。 解决：解决步骤递归地求解出子问题。如果子问题的规模足够小，则停止递归，直接求解。 合并：合并步骤将子问题的解合成原问题的解。 求解最大子数据过程中的思路是，先将数组分成两部分。那么根据最大子数组出现的位置就会有三种情况。 左侧...
机器学习项目基本流程
石头会说话 的博客
12-26 431
目录说明读取数据 说明 本文内容基于机械工业出版社 **机器学习实战（基于scikit-learn和tensorflow）**而写的。学习过程中，手动对比敲了一些代码，还有一些心得，作为书中内容的补充。 读取数据 # step1 读取数据 filepath = "./CaliforniaHousing/cal_housing.data" columns = ["longitude", "latitude", "housing_median_age", "total_rooms", \
算法导论学习
石头会说话 的博客
10-31 350
2. 算法基础 2.1 算法基础 2.1 .1 插入排序 插入排序的本质是，便利每一位置上的值，每一次遍历时，都把比这个值大的数字往前提，留出的空位，用这次的遍历值补上去。 #!/bin/usr/python3 def insertSort(arr, order=True): for i in range(len(arr)): if i==0 : continue else: key = arr[i] j = i-1 # 值大的往后换，流出的空位，把目标值插入进去 w
Python实现八种常见排序算法详解与示例
本文档介绍了Python实现的八大常见排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、计数排序以及基数排序。这些排序算法是计算机科学中基础且实用的技能，对于理解和优化程序性能至关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值