Python实现基础算法

基础算法排序

1.冒泡排序

(1)原理：比较相邻两个数字的大小，将两数中比较大的那个数交换到靠后的位置，不断地交换下去就可以将最大的那个数放到队列的尾部。然后重头再次交换，直到数列排成有序数列。
代码实例：

第一步：创建rand.py随机数
import random
list1=[ ]
def gerandomlist(n):
    for i in range(n):
        computer=random.randint(0,1000)
        list1.append(computer)
    return list1
第二步：导入随机数包并实现冒泡排序：
from leecode算法题.rand import gerandomlist
def bubbling(list_):
    for i in range(0,len(list_)):
        for j in range(i+1,len(list_)):
            if list_[i]>list_[j]:
                list_[i],list_[j]=list_[j],list_[i]
            else:
                continue
    print(list_)
if __name__ == '__main__':
    list_=gerandomlist(20)
    print(list_)
    bubbling(list_)

2.选择排序

（1）原理：从数列中选择最大(最小)的那个数，将这个数放到合适的位置，然后删除这个数的子数列中选择最大(最小)的那个数，将这个数放到合适的位置，知道子数列为空。
代码实例：

第一步：创建rand.py随机数
import random
list1=[ ]
def gerandomlist(n):
    for i in range(n):
        computer=random.randint(0,1000)
        list1.append(computer)
    return list1
第二步：导入随机数包并实现选择排序：
from leecode算法题 import rand
def chooice(list_):
    for i in range(len(list_)-1):
        mineIndex=i
        for j in range(i+1,len(list_)):
            if list_[j]<list_[mineIndex]:
                mineIndex=j
        if i!=mineIndex:
            list_[i],list_[mineIndex]=list_[mineIndex],list_[i]
    print(list_)
if __name__ == '__main__':
    list_=rand.gerandomlist(20)
    print(list_)
    chooice(list_)

3.插入排序

(1)原理：首先将数列分成两部分。数列的第一个数为left部分，其他的数为right部分，然后将right部分中的数逐一取出，插入left部分中合适的位置。当right部分为空时，left部分就成为了一个有序数列。
代码实例：

第一步：创建rand.py随机数
import random
list1=[ ]
def gerandomlist(n):
    for i in range(n):
        computer=random.randint(0,1000)
        list1.append(computer)
    return list1
第二步：导入随机数包并实现选择排序：
from leecode算法题.rand import gerandomlist
def insertionsort(list_):
    if len(list_) <= 1:
        return list_
    for right in range(1, len(list_)):
        target = list_[right]
        for left in range(0, right):
            if target <= list_[left]:
                list_[left + 1:right + 1] = list_[left:right]
                list_[left] = target
                break
    return list_
if __name__ == '__main__':
    list_ = gerandomlist(20)
    print(list_)
    print(insertionsort(list_))

4.归并排序

(1)原理：先将数列分成左右两份(最好等分)，然后将左，右子数列排序完毕后再合并到一起就成了一个有序数列，左，右两个子数列变成有序数列的过程是一个递归的过程：再把子数列分成左，右两份，把子子数列排序完毕后合并成子数列。
代码实例：

第一步：创建rand.py随机数
import random
list1=[ ]
def gerandomlist(n):
    for i in range(n):
        computer=random.randint(0,1000)
        list1.append(computer)
    return list1
第二步：导入随机数包并实现选择排序：
from leecode算法题.rand import gerandomlist
def mergesort(list_):
    if len(list_)<=1:
        return list_
    middle=len(list_)//2
    left,right=list_[0:middle],list_[middle:]
    return mergelist(mergesort(left),mergesort(right))
def mergelist(left,right):
    mList=[ ]
    while left and right:
        if left[0]>=right[0]:
            mList.append(right.pop(0))
        else:
            mList.append(left.pop(0))
    while left:
        mList.append(left.pop(0))
    while right:
        mList.append(right.pop(0))
    return mList
if __name__ == '__main__':
    list_=gerandomlist(20)
    print(list_)
    data=mergesort(list_)
    print(data)

5.快速排序

(1)原理：先以列表中的任意一个数为基准（一般从头选到尾部），将列表分为左、右两个子列表：左子列表的数要比基准数小，右子列表的数要比基准数大。然后继续把左子列表和右子列表按同样的方法继续分解、比较，直到分无可分。最后将左子列表（比基准数小）+基准数+右子列表（比基准书大）连接起来得到一个有序数列。
代码实例：

第一步：创建rand.py随机数
import random
list1=[ ]
def gerandomlist(n):
    for i in range(n):
        computer=random.randint(0,1000)
        list1.append(computer)
    return list1
第二步：导入随机数包并实现选择排序：
from leecode算法题.rand import gerandomlist
def quicksort(list_):
    less=[] #小于基准元素的放到这个列表中
    equal=[]#等于基准元素的放到这个列表中
    greater=[]#大于基准元素放到这个列表中
    if len(list_)>1:
        pivot=list_[len(list_)-1]#取数组最后一个元素作为基准元素
        for x in list_:
            if x<pivot:
                less.append(x)
            elif x==pivot:
                equal.append(x)
            elif x>pivot:
                greater.append(x)
        return quicksort(less)+equal+quicksort(greater)
    else:
        return list_
if __name__ == '__main__':
    list_=gerandomlist(20)
    print(list_)
    data=quicksort(list_)
    print(data)

6.计数排序

(1)原理：找出待排序的数组中最大和最小的元素，统计数组中每个值为i的元素出现次数,存入数组C的第i项，对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加），反向填充目标数组，将每个元素ii放在新数组的第C[i]项，每放一个元素就将C[i]减去1。
代码实例：

第一步：创建rand.py随机数
import random
list1=[ ]
def gerandomlist(n):
    for i in range(n):
        computer=random.randint(0,1000)
        list1.append(computer)
    return list1
第二步：导入随机数包并实现选择排序：
from leecode算法题.rand import gerandomlist

def count_sort(list_):
    max_element=int(max(list_))
    min_element=int(min(list_))
    range_element=max_element-min_element+1
    #创建count_arr用于计数，创建output_arr用于保存结果
    count_arr=[0 for _ in range(range_element)]
    output_arr=[0 for _ in range(len(list_))]
    #统计每个数值出现的次数
    for i in range(0,len(list_)):
        count_arr[list_[i]-min_element]+=1
    #对count_arr[i]累计就和，就是排序后的位置
    for i in range(1,len(count_arr)):
        count_arr[i]+=count_arr[i-1]
    #保存数据
    for i in range(len(list_)-1,-1,-1):
        temp=list_[i]-min_element
        temp_=count_arr[temp]
        output_arr[temp_-1]=list_[i]
        count_arr[list_[i]-min_element]-=1
    for i in range(0,len(list_)):
        list_[i]=output_arr[i]
    return list_
if __name__ == '__main__':
    list_=gerandomlist(20)
    print(list_)
    data=count_sort(list_)
    print(data)

7.堆排序

(1)原理：首先利用待排序数列构建最大堆（根节点保存最大值，父节点数据>子节点数据），接下来取出堆结构中的根节点元素，即为最大值，保存到新列表的末尾。更新剩下的数据，组成新的最大堆，并取出根节点元素（最大值），如此不断重复直到堆中的所有数据都被取出，排序完成。
代码实例：

第一步：创建rand.py随机数
import random
list1=[ ]
def gerandomlist(n):
    for i in range(n):
        computer=random.randint(0,1000)
        list1.append(computer)
    return list1
第二步：导入随机数包并实现选择排序：
from leecode算法题.rand import gerandomlist
def quicksort(list_):
    less=[]
    equal=[]
    greater=[]
    if len(list_)>1:
        privot=list_[len(list_)-1]
        for x in list_:
            if x <privot:
                less.append(x)
            elif x==privot:
                equal.append(x)
            elif x>privot:
                greater.append(x)
        return quicksort(less)+equal+quicksort(greater)
    else:
        return list_
if __name__ == '__main__':
    list_=gerandomlist(20)
    print(list_)
    data=quicksort(list_)
    print(data)