数据结构2（排序）

一、查找

1.查找：在一些数据元素中，通过一定的方法找出与给定关键字相同的数据元素的过程。

2.列表查找（线性表查找）：从列表中查找指定元素

        输入：列表、待查找元素

        输出：元素下标（未找到元素时一般返回none或-1）

3.内置列表查找函数：index（）

4.注意输出顺序

#输出3 2 1
def func3(x):
    if x>0:
        print(x)
        func3(x-1)
print(func3(3))

#输出1 2 3 
def func4(x): 
        if x>0: 
        func4(x-1)
        print(x) 
print(func4(3))

5.递归：汉诺塔问题

def hanoi(n,a,b,c):
    if n>0:
        hanoi(n-1,a,c,b)
        print("moving from %s to %s"%(a,c))
        hanoi(n-1,b,a,c)

hanoi(3,'A','B','C')

二、查找

1.顺序查找：也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止

def linear_search(list,value):
    for index,v in enumerate(list):
        if v == value:
            return index
    else:
        return none

2.二分查找：也叫折半查找，从有序列表的初始候选区 li [0:n] 开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。

def binary_search(list,value):
    left = 0
    right = len(list) - 1
    while left <= right: #候选区有值
        mid = (left + right) // 2
        if list[mid] == value:
            return mid
        elif list[mid] > value:     #待查找的值在mid左侧
            right = mid -1
        else:   #list[mid] < value 待查找的值在mid右侧
            left = mid + 1
    else:
        return none

list = [1,2,3,4,5,6,7,8,9]
print(binary_search(list,3))

三、排序

1.排序：将一组 “ 无序 ” 的记录序列调整为 ” 有序 “ 的记录序列。

2.列表排序：将无序列表变为有序列表

        输入：列表

        输出：列表

        升序与降序

        内置排序函数：sort（）

3.常见排序算法：

相对来说没有很方便：冒泡排序、选择排序、插入排序

        时间复杂度：O（n²）

比较方便的：快速排序、堆排序、归并排序

其他排序：希尔排序、计数排序、基数排序

①冒泡排序：列表相邻的两个数，如果前面比后面大，则交换这两个数。

                一趟排序完成后，则无序区减少一个数，有序区增加一个数。

import random #引入生成随机数表

def bubble_sort(li):
    for i in range(len(li)-1):  #第i趟
        exchange = False
        for j in range(len(li)-i-1):    #箭头所指数
            if li[j] > li[j+1]:
                li[j],li[j+1] = li[j+1],li[j]
                exchange = True
        ##print(li)
        if not exchange:
            return

li = [random.randint(0,1000) for i in range(10)]
print(li)
bubble_sort(li)
print(li)

 

②选择排序：一趟排序记录最小的数，放到第一个位置；再一趟排序记录列表无序区最小的数，放到第二个位置；算法关键点：有序区和无序区、无序区最小数的位置

def select_sort(li):
    for i in range(len(li)-1):  #i是第几趟
        min_loc = i
        for j in range(i+1,len(li)):
            if li[j] < li[min_loc]:
                min_loc = j
        li[i],li[min_loc] = li[min_loc],li[i]
        ##print(li)

li = [3,7,5,8,2,1,4,6,9]
print(li)
select_sort(li)
print(li)

③插入排序：初始时手里（有序区）只有一张牌；每次（从无序区）摸一张牌，插入到手里已有牌的正确位置

def insert_sort(li):
    for i in range(1,len(li)):  #i表示摸到的牌的下标
        tmp = li[i]
        j = i-1   #指的是手里的牌的下标
        while j >= 0 and li[j] > tmp:
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tmp

li = [1,3,5,7,9,2,4,6,8]
insert_sort(li)
print(li)

④快速排序：取一个元素p（第一个元素），是元素p归位；列表被p分为两部分，左边都比p小，右边都比p大；递归完成排序

        时间复杂度：O（nlogn）

        快速排序的问题：达到递归最大深度；最坏情况（可能性很小）

def partition(li,left,right):
    tmp = li[left]
    while left < right:
        while left <right and li[right] >= tmp:     #从右边找出比tmp小的数
            right -= 1      #往左走一步
        li[left] = li[right]    #把右边的值写到左边的空位上
        ##print(li)
        while left < right and li[left] <= tmp:
            left += 1
        li[right] = li[left]    #把左边的值写到右边空位上
        ##print(li)
    li[left] = tmp  #把tmp归位
    return left

def quick_sort(li,left,right):
    if left < right: #至少两个元素
        mid = partition(li,left,right)
        quick_sort(li,left,mid-1)
        quick_sort(li,mid+1,right)

li = [5,7,4,6,3,1,2,9,8]
print(li)
quick_sort(li,0,len(li)-1)
print(li)

⑤堆排序：

        树与二叉树：

                树是一种结构，比如：目录结构；

                树是一种可以递归定义的数据结构；

                树是由n个节点组成的集合：

                        如果n = 0，那这是一棵空树；

                        如果n > 0，那存在一个节点作为树的根节点，其他节点可以分为m个集合，每个集合本身又是一棵树。

                二叉树：度不超过2的树；每个节点最多有两个孩子节点；两个孩子节点被区分为左孩子节点和右孩子节点

                满二叉树：一个二叉树，如果每一个层的节点数都达到最大值，则这个二叉树就是满二叉树。

                完全二叉树：叶节点只能出现在最下层和次下层，并且最下面一层的节点都集中在该层最左边若干位置的二叉树。

                堆：一种特殊的完全二叉树

                大根堆：一棵完全二叉树，满足任意节点都比其孩子节点大

                小根堆：一颗完全二叉树，满足任意节点都比其孩子节点小

                堆的向下调整性质：当根节点的左右子树都是堆时，可以通过一次向下的调整来将其变换成一个堆。

                堆排序过程：1.建立堆；2.得到堆顶元素，为最大元素；3.去掉堆顶，将堆最后一个元素放到堆顶，此时可通过一次调整重新使堆有序；4.堆顶元素为第二大元素；5.重复步骤3，直到堆变空。

                时间复杂度：O（nlogn）

def sift(li,low,high):
    #li:列表  low:堆的根节点位置   high:堆的最后一个元素的位置
    i = low     #i最开始指向根节点
    j = 2 * i + 1   #j开始指向左孩子
    tmp = li[low]   #把堆顶存起来
    while j <= high:    #只要j位置有数
        if j + 1 <= high and li[j+1] > li[j]:   #如果右孩子有而且比较大
            j = j + 1   #j指向右孩子
        if li[j] > tmp:
            li[i] = li[j]
            i = j       #往下看一层
            j = 2 * i + 1
        else:    #把tmp放到i的位置上
            li[i] = tmp    #把tmp放到某一级领导的位置上
            break
    else:
        li[i] = tmp     #把tmp放到叶子节点上
    #else后可写成
        #else:
            #break
    #else:
        #li[i] = tmp

def heap_sort(li):
    n = len(li)
    for i in range((n-2)//2,-1,-1):
        # i表示建堆的时侯调整的部分的下标
        sift(li,i,n-1)
        #建模完成
        for i in range(n-1,-1,-1):
            #i指向当前堆的最后一个元素
            li[0],li[i] = li[i],li[0]
            sift(li,0,i-1)  #i-1是新的high

li = [i for i in range(100)]
import random
random.shuffle(li)
print(li)
heap_sort(li)
print(li)

堆排序——内置模块：

         python内置模块——heapq

         常用函数：heapify(x)、heappush(heap,item)、heappop(heap)

import heapq    #q->queue
import random

li = list(range(100))
random.shuffle(li)

print(li)

heapq.heapify(li)   #建堆

n = len(li)
for i in range(n):
    print(heapq.heappop(li),end = ',')

堆排序——topk问题：

         现在有n个数，设计算法得到前k大的数。（k<n)

         解决思路：

                排序后切片                        O（nlogn）

                冒泡，选择，插入排序      O（kn）

                堆排序思路                        O（klogn）

堆排序解决思路：

                ①取列表前k个元素建立一个小根堆。堆顶就是目前第k大的数。②依次向后遍历原列表，对于列表中的元素苏，如果小于堆顶，则忽略该元素；如果大于堆顶，则将堆顶更换为该元素，并且对堆进行一次调整。③遍历列表所有元素后，倒序弹出堆顶。

def sift1(li,low,high):
    i = low
    j = 2 * i + 1
    tmp = li[low]
    while j <= high:
        if j + 1 <= high and li[j+1] < li[j]:
            j = j + 1
        if li[j] < tmp:
            li[i] = li[j]
            i = j
            j = 2 * i + 1
        else:
            li[i] = tmp
            break
    else:
        li[i] = tmp

def topk(li,k):
    heap = li[0:k]
    #1.建堆
    for i in range((k-2)//2,-1,-1):
        sift1(heap,i,k-1)
    #2.遍历
    for i in range(k,len(li)-1):
        if li[i] > heap[0]:
            heap[0] = li[i]
            sift1(heap,0,k-1)
    #3.出数
    for i in range(k-1,-1,-1):
        heap[0],heap[i] = heap[i],heap[0]
        sift1(heap,0,i-1)
    return heap

import random
li = list(range(100))
random.shuffle(li)
print(topk(li,10))

 ⑥归并排序：

        归并：假设一个列表分两段有序将其合并成为一个有序列表，这样的操作称为一次归并。

        归并排序过程：

                分解：将列表越分越小，直至分成一个元素。

                终止条件：一个元素是有序的。

                合并：将两个有序列表归并，列表越来越大。

        时间复杂度：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])
        #while执行完，一定有一部分没数了
        while i <= mid:
            ltmp.append(li[i])
            i += 1
        while j <= high:
            ltmp.append(li[i])
            j += 1
        li[low:high+1] = ltmp

def merge_sort(li,low,high):
    if low < high:      #至少有两个元素，递归
        mid = (low + high) // 2
        merge_sort(li,low,mid)
        merge_sort(li,mid+1,high)
        merge(li,low,mid,high)
        #print(li[low:high+1])

li = list(range(15))
import random
random.shuffle(li)
print(li)
merge_sort(li,0,len(li)-1)
print(li)

4.快速、堆、归并小结：

①三种排序算法的时间复杂度都是O（nlogn）

②一般情况下，就运行时间而言：快速排序 < 归并排序 < 堆排序

③三种排序算法的缺点：

        快速排序：极端情况下排序效率低

        归并排序：需要额外的内存开销

        堆排序：在快的排序算法中相对较慢

5.希尔排序：

希尔排序的时间复杂度与选择的gap序列相关。

def insert_sort_gap(li,gap):
    for i in range(gap,len(li)):  #i表示摸到的牌的下标
        tmp = li[i]
        j = i - gap   #指的是手里的牌的下标
        while j >= 0 and li[j] > tmp:
            li[j+gap] = li[j]
            j -= gap
        li[j+gap] = tmp

def shell_sort(li):
    d = len(li)//2
    while d >= 1:
        insert_sort_gap(li,d)
        d //=2

li = list(range(1000))
import random
random.shuffle(li)
shell_sort(li)
print(li)

6.计数排序：

对列表进行排序，已知列表中的数范围都在0到100之间。设计时间复杂度为O（n

）的算法。

def count_sort(li,max_count=100):
    count = [0 for _ in range(max_count+1)]
    for val in li:
        count[val] += 1
    li.clear()
    for ind,val in enumerate(count):
        for i in range(val):
            li.append(ind)

import random
li = [random.randint(0,100) for _ in range(1000)]
print(li)
count_sort(li)
print(li)

7.桶排序：将元素分在不同的桶中，在对每个桶中的元素排序。（相当于计数排序的扩展）

        桶排序的表现取决于数据的分布。也就是需要对不同数据排序时采取不同的分桶策略。

        平均情况时间复杂度：O（n+k）

        最坏情况时间复杂度：O（n²k）

def bucket_sort(li,n=100,max_num=10000):
    buckets = [[] for _ in range(n)]    #创建桶
    for var in li:
        i = min(var // (max_num // n),n-1)  #i表示var放到几号桶里
        buckets[i].append(var)    #把var加到桶里
        #保持桶内的顺序
        for j in range(len(buckets[i])-1,0,-1):
            if buckets[i][j] < buckets[i][j-1]:
                buckets[i][j],buckets[i][j-1] = buckets[i][j-1],buckets[i][j]
            else:
                break
    sorted_li = []
    for buc in buckets:
        sorted_li.extend(buc)
    return sorted_li

import random
li = [random.randint(0,10000) for i in range(100)]
print(li)
li = bucket_sort(li)
print(li)

8.基数排序：

时间复杂度：O（kn）

空间复杂度：O（k+n），k表示数字位数（10000的k=5）

def radix_sort(li):
    max_num = max(li)   #最大值9-->1,99-->2,888-->3,10000-->5
    it = 0
    while 10 ** it <= max_num:
        buckets = [[] for _ in range(10)]
        for var in li:
            # 987 it=1 987//10-->98 98%10-->8;  it=2 987//100-->9 9%10-->9
            digit = (var // 10** it) % 10
            buckets[digit].append(var)
            #分桶完成
        li.clear()
        for buc in buckets:
            li.extend(buc)
        #把数重新写回li

        it += 1

li = list(range(1000))
random.shuffle(li)
print(li)
radix_sort(li)
print(li)