数据结构——用python实现排序算法

基础排序算法实践
本文通过Python实现多种基础排序算法,包括插入排序、冒泡排序及其优化版本、希尔排序和选择排序等。每种算法均附带详细代码示例。

用python实现各种数据结构,是不是EXCITING?本文实现了基础排序算法

代码较为简单,按顺序如下:

1.插入排序

#coding=utf8
L=[223, 85, 232, 171, 215, 229, 12, 58, 219, 143, 61, 152, 32, 42, 199, 82, 252, 217, 106, 240, 202, 40, 180, 292, 235, 214, 116, 76, 298, 33, 132, 185, 44, 31, 73, 110, 201, 174, 127, 108, 251, 83, 172, 36, 93, 88, 233, 218, 30, 18, 262, 293, 263, 277, 100, 48, 246, 98, 75, 170, 138, 278, 134, 297, 78, 226, 206, 176, 28, 133, 203, 50, 222, 123, 230, 285, 105, 189, 238]
'''
Created on 2016年10月2日

@author: sx
'''
def charu(L):
    m=0
    g=0
    print(len(L))
    for i in range(1,len(L)):
        m=m+1
        x=L[i]
        j=i
        while j>0 and L[j-1]>x:
            m=m+1
            L[j]=L[j-1]
            j=j-1
            g=g+1
        L[j]=x
    print(L)
    print(m,g,m+g)
 #方法简单直接又暴力,不错不错   

charu(L)

2、冒泡排序

#encoding=UTF-8
'''
Created on 2016年10月2日

@author: sx
'''
L=[223, 85, 232, 171, 215, 229, 12, 58, 219, 143, 61, 152, 32, 42, 199, 82, 252, 217, 106, 240, 202, 40, 180, 292, 235, 214, 116, 76, 298, 33, 132, 185, 44, 31, 73, 110, 201, 174, 127, 108, 251, 83, 172, 36, 93, 88, 233, 218, 30, 18, 262, 293, 263, 277, 100, 48, 246, 98, 75, 170, 138, 278, 134, 297, 78, 226, 206, 176, 28, 133, 203, 50, 222, 123, 230, 285, 105, 189, 238]
# def suiji(i):
def maopao(L):
    m=0
    for i in range(0,len(L)):
        m=m+1
        for j in range(i+1,len(L)):
            m=m+1
            if L[i]>L[j]:
                print(L[i],L[j])
                swap(L,i,j)
                print(L)
                m=m+1
    print(m)
#     冒泡排序好像打擂台
def swap(L,i,j):
    q=L[j]
    L[j]=L[i]
    L[i]=q


maopao(L)

3、冒泡排序优化算法

#encoding=UTF-8
'''
Created on 2016年10月2日

@author: sx
'''
import random
L=[223, 85, 232, 171, 215, 229, 12, 58, 219, 143, 61, 152, 32, 42, 199, 82, 252, 217, 106, 240, 202, 40, 180, 292, 235, 214, 116, 76, 298, 33, 132, 185, 44, 31, 73, 110, 201, 174, 127, 108, 251, 83, 172, 36, 93, 88, 233, 218, 30, 18, 262, 293, 263, 277, 100, 48, 246, 98, 75, 170, 138, 278, 134, 297, 78, 226, 206, 176, 28, 133, 203, 50, 222, 123, 230, 285, 105, 189, 238]
# def suiji(i):
#     s=[]
#     for i in range(0,i):
#         q=random.randint(10,300)
#         if q not in s:
#             s.append(q)
#     print(s)

def maopao(L):
    m=0
    g=0
    for i in range(0,len(L)):
        m=m+1
        for j in range(-len(L)+1,-i):
            m=m+1
            k=-j
#             if L[k]<L[i]:
#                 print(L[i],L[k])
#                 swap(L,i,k)
#                 print(L)
#                 m=m+1
            o=k-1
            if L[k]<L[o]:
                print(L[j],L[o])
                swap(L,j,o)
                print(L)
                g=g+1
    print(m,g)
#     冒泡排序好像打擂台
def swap(L,i,j):
    q=L[j]
    L[j]=L[i]
    L[i]=q

maopao(L)

4、冒泡排序再优化

#encoding=UTF-8
'''
Created on 2016年10月2日

@author: sx
'''
import random
L=[223, 85, 232, 171, 215, 229, 12, 58, 219, 143, 61, 152, 32, 42, 199, 82, 252, 217, 106, 240, 202, 40, 180, 292, 235, 214, 116, 76, 298, 33, 132, 185, 44, 31, 73, 110, 201, 174, 127, 108, 251, 83, 172, 36, 93, 88, 233, 218, 30, 18, 262, 293, 263, 277, 100, 48, 246, 98, 75, 170, 138, 278, 134, 297, 78, 226, 206, 176, 28, 133, 203, 50, 222, 123, 230, 285, 105, 189, 238]
# def suiji(i):
#     s=[]
#     for i in range(0,i):
#         q=random.randint(10,300)
#         if q not in s:
#             s.append(q)
#     print(s)

def maopao(L):
    m=0
    f=1
    g=0
    for i in range(0,len(L)):
        if f==1: 
            m=m+1
            f=0
            for j in range(-len(L)+1,-i):
                m=m+1
                k=-j
                o=k-1
                if L[k]<L[o]:
                    print(L[i],L[o])
                    swap(L,o,k)
                    f=1
                    print(L)
                    g=g+1
                elif L[k]==L[o]:
                    f=1
        else:
            pass
    print(m,g)
#    考虑一种情况 局部调整结束
def swap(L,i,j):
    q=L[j]
    L[j]=L[i]
    L[i]=q

maopao(L)

5、希尔排序

'''
Created on 2016年10月2日

@author: sx
'''
L=[223, 85, 232, 171, 215, 229, 12, 58, 219, 143, 61, 152, 32, 42, 199, 82, 252, 217, 106, 240, 202, 40, 180, 292, 235, 214, 116, 76, 298, 33, 132, 185, 44, 31, 73, 110, 201, 174, 127, 108, 251, 83, 172, 36, 93, 88, 233, 218, 30, 18, 262, 293, 263, 277, 100, 48, 246, 98, 75, 170, 138, 278, 134, 297, 78, 226, 206, 176, 28, 133, 203, 50, 222, 123, 230, 285, 105, 189, 238]
def ShellSort(L):
    t=len(L)
    m=0
    g=0
    while(t>1):
        t=int(t/12+1)
        i=0
        m=m+1
        while i<len(L):
            m=m+1
#                 print(i)
            x=L[i]
            j=i
            while j>0 and L[j-t]>x:
                m=m+1
                g=g+1
                L[j]=L[j-t]
                j=j-t
#             while L[i]<L[i+t]:
#                 L[i]=L[i+t]
#             print(L)
            L[j]=x
            i=i+t
#             print(L)
    print(m,g,m+g)
ShellSort(L)

小慧慧还在睡觉~

6、选择排序

#encoding=UTF-8
'''
Created on 2016年10月2日

@author: sx
'''
L=[223, 85, 232, 171, 215, 229, 12, 58, 219, 143, 61, 152, 32, 42, 199, 82, 252, 217, 106, 240, 202, 40, 180, 292, 235, 214, 116, 76, 298, 33, 132, 185, 44, 31, 73, 110, 201, 174, 127, 108, 251, 83, 172, 36, 93, 88, 233, 218, 30, 18, 262, 293, 263, 277, 100, 48, 246, 98, 75, 170, 138, 278, 134, 297, 78, 226, 206, 176, 28, 133, 203, 50, 222, 123, 230, 285, 105, 189, 238]
# def suiji(i):
L=[2,3,12,34,52,1,45]
def xuanze(L):
    print(len(L))
    m=0
    g=0
    for i in range(0,len(L)):
        min=i
        m=m+1
        for j in range(i+1,len(L)):
            m=m+1
            if L[min]>L[j]:
                min=j
                m=m+1
        if min!=i:
            swap(L,i,min)
            print(L)
            g=g+1
    print(m,g)
#     选择排序和冒泡排序的不同:选择排序只需交换一次,冒泡排序需要比较且交换多次,选择排序比较的较多
def swap(L,i,j):
    q=L[j]
    L[j]=L[i]
    L[i]=q    
xuanze(L)
### 回答1: 在 Python 中,你可以使用内置的 `sorted` 函数来对列表进行排序。例如: ```python numbers = [3, 4, 2, 1] sorted_numbers = sorted(numbers) print(sorted_numbers) # 输出: [1, 2, 3, 4] ``` 你也可以使用列表的 `sort` 方法来对列表进行排序 `sorted` 函数不同的是,`sort` 方法是在原地对列表进行排序,也就是说不会返回一个新的列表,而是直接修改原来的列表。例如: ```python numbers = [3, 4, 2, 1] numbers.sort() print(numbers) # 输出: [1, 2, 3, 4] ``` 你也可以使用 Python 的 heapq 库中的堆排序算法。堆排序是一种速度较快的排序算法,特别适用于海量数据的排序。例如: ```python import heapq numbers = [3, 4, 2, 1] heapq.heapify(numbers) # 将列表转化为堆 sorted_numbers = [] while numbers: sorted_numbers.append(heapq.heappop(numbers)) # 将堆中最小的数取出并放到结果列表中 print(sorted_numbers) # 输出: [1, 2, 3, 4] ``` 此外,Python 还提供了许多其他的排序算法,例如快速排序、归并排序等。你可以使用 Python 的 timeit 库来对不同的排序算法进行测试,以找出最快的排序算法。 ### 回答2: 数据结构是计算机科学中非常重要的一个概念,它是一种组织和存储数据的方式。而实现排序算法数据结构中的一个重要应用。 在Python中,可以使用多种数据结构实现排序算法,比如列表、数组和堆等。下面我将介绍一种常用的排序算法——插入排序Python实现。 插入排序是一种简单且常用的排序算法,它的基本思想是将待排序的元素一个一个地按照大小插入到已经排好序的列表中。具体步骤如下: 1. 创建一个新的空列表,作为存放已排序元素的容器。 2. 遍历待排序的列表,依次取出每个元素。 3. 将取出的元素排序元素的最后一个元素比较,如果取出的元素较小,则将它插入到已排序元素的末尾;如果取出的元素较大,则向前比较,找到合适的位置插入。 4. 重复步骤3,直到待排序列表中的所有元素都被取出并插入到已排序列表中。 5. 返回已排序的列表,即为排序结果。 下面是插入排序Python实现代码: ```python def insertion_sort(arr): for i in range(1, len(arr)): key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key return arr ``` 通过调用`insertion_sort`函数,传入待排序的列表,即可得到排序结果。 这就是数据结构中一种常用排序算法——插入排序Python实现。当然,除了插入排序,还有许多其他排序算法也可以使用Python实现,比如冒泡排序、快速排序等。每种排序算法都有其特点和适用场景,可以根据具体需求选择合适的排序算法来使用。 ### 回答3: 数据结构是计算机存储、组织和管理数据的方式。在Python中,可以使用不同的数据结构实现排序算法。 常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、堆排序和归并排序等。 冒泡排序是一种比较简单的排序算法,它重复地交换相邻的元素,直到整个序列有序为止。可以使用列表作为数据结构实现冒泡排序。 插入排序是一种较为直观的排序算法,它将未排序的元素逐个插入到已排序的部分中,构建有序序列。也可以使用列表实现插入排序。 选择排序是一种简单直观的排序算法,它每次选择未排序部分的最小元素,并将其排序部分的最左边元素交换位置。同样可以使用列表来实现选择排序。 快速排序是一种常用的排序算法,它使用分治的思想,将序列分为两个子序列,递归地排序子序列。同样可以使用列表作为数据结构实现快速排序。 堆排序是一种利用堆的数据结构来进行排序算法,它通过不断地构建和调整堆来达到排序的目的。可以使用列表来实现排序。 归并排序是一种稳定的排序算法,它使用分治的思想,将序列分为两个子序列,递归地排序子序列,然后将两个有序子序列合并为一个有序序列。同样可以使用列表来实现归并排序。 总的来说,Python提供了多种数据结构算法实现排序操作,根据实际需求和性能要求选择适合的算法数据结构
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值