【数据结构】常见面试题之排序篇

1. 二分查找法

def bin_serch(x,val):
    '''
    x:带查找列表
    val:目标元素
    return: 目标元素的索引
    '''
    left=0
    right=len(x)-1
    while left <=right:
        mid = (left + right) // 2
        if x[mid] ==val:
            return mid
        elif x[mid]> val:
            right = mid-1
        else:
            left = mid+1
    return None

2. 冒泡排序

def bubble_search(x):
    '''
    x:带查找列表
    return :从小到大排序好的列表
    '''
    for i in range(len(x)-1):  # 遍历的趟
        flag =False  # 减少不必要的交换
        for j in range(len(x)-i-1):  #遍历的箭头  指针
            if x[j] > x[j+1]:
                x[j],x[j+1] =x[j+1],x[j]
                flag=True
            if not flag:
                return x
    return x

3. 选择排序

def select_search_sample(li):
    '''
    li: 待排序列表
    return 排序好的新列表
    '''
    new_li=[]
    for i in range(len(li)):
        min_val = min(li)
        li.remove(min_val)
        new_li.append(min_val)
    return new_li

def select_search(li):
    '''
    li: 待排序列表
    return 从小到大排序好的列表，未开辟新的内存存放新列表
    '''
    for i in range(len(li)-1): # 表示有多少趟
        min_loc=i
        for j in range(i+1,len(li)):
            if li[j] < li[min_loc]:
                min_loc=j
        if i != min_loc:
          li[i],li[min_loc]=li[min_loc],li[i]
    return li

4. 插入排序

def insert_sort(li):
    '''
    li: 待排序元素
    return 排序好的元素
    '''
    for i in range(1,len(li)): #遍历 当前值后面的所有元素的下标
        tmp = li[i]    # 当前拿到的元素
        j = i-1      # 前一个值的下标
        while j >=0 and li[j] > tmp:
            li[j+1] = li[j]
            j -=1
        li[j+1] = tmp
    return li

5. 快速排序

def quick_sort(li,first,last):
    '''
    li:待排序列表
    first:首元素坐标 0
    last: 末元素坐标 len(li)-1
    return 排序好元素
    '''
    if first>=last:
       return
    left = first
    right = last
    mid = li[first]
    while left < right:
        while left < right and li[right] >= mid:
            right -=1
        li[left] = li[right]
        while left < right and li[left] < mid:
            left +=1
        li[right] = li[left]
    li[left] = mid
    # 递归之前的代码是 找到一个中间值，把小于其值的元素放在左边，大于其值的元素放在右边
    # 递归左右两边的元素使得全部数据不可再分为止
    quick_sort(li, first, left - 1)
    # low 右边元素
    quick_sort(li, left + 1, last)
    #return li

6. 堆排序

'''详细介绍'''
# 满二叉树 就是每个节点有且仅有两个分支
# 完全二叉树 并不一定是满二叉树，即可以在一个满二叉树的最后部分拿掉几个分支，但不能从中间拿掉一些分支
# 父亲和左孩子节点下标对应的关系 2*i+1 和右孩子节点下标对应 的关系2*i+2
# 堆排序 需要再次看
def sift(li,low,high):
    '''
    li:待排序列表
    low:首元素坐标 0
    high:末元素坐标 len(li) -1
    '''
    i = low  # i z最开始指向根节点
    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更大，把tmp放到i的位置上
            li[i] = tmp  # 把tmp 放到某一集领导位置上
            break
    else:
        li[i] = tmp # 把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

# 堆排序实现前k大的数
def topk(li,k):
    heap = li[0:k]
    #建堆
    for i in range((k-2)//2,-1,-1):
        sift(heap,i,k-1)
    # 遍历
    for i in range(k,len(li)-1):
        if li[i] >heap[0]:
            heap[0] = li[i]
            sift(heap,0,k-1)
    # 出数
    for i in range(k-1,-1,-1):
        heap[0],heap[i] = heap[i],heap[0]
        sift(heap,0,i-1)
    return heap

7. 归并排序

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
    return li

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)
    return li

8. 希尔排序

# 希尔排序 分组的插入排序
def insert_sort_gap(li,gap):
    '''
    li:待排序列表
    gap:分组间隔
    '''
    for i in range(gap,len(li)):
        tmp = li[i]
        j = i-gap
        while j >=0 and li[j]>tmp:
            li[j+gap] = li[j]
            j -=gap
        li[j+gap]= tmp
    return li
def shell_sort(li):
    d = len(li)//2
    while d >=1:
        insert_sort_gap(li,d)
        d //=2
    return li

9. 计数排序

def count_sort(li):
    '''
    li:待排序列表
    return 排好序的列表
    '''
    ltmp =(len(li)+1)*[0]
    for i in li:
        ltmp[i] +=1
    li.clear()
    for ind,val in enumerate(ltmp):
        for i in range(val):
            li.append(ind)
    return li

10. 桶排序

def bucket_sort(li,n=10,max_num=100):
    '''
    li:待排序列表
    n:桶的个数
    max_num:待排序列表中的最大数
    return 排序好的新列表
    '''
    buckets=[[]for _ in range(n)]
    num = max_num//n
    for val in li:
        ind = min(val // num,n-1)
        buckets[ind].append(val)
        # 将元素 有序的放入桶内
        for j in range(len(buckets[ind])-1,0,-1):
            if buckets[ind][j] < buckets[ind][j-1]:
                buckets[ind][j],buckets[ind][j-1] = buckets[ind][j-1],buckets[ind][j]
            else:
                break
    sorted_li =[]
    for buc in buckets:
        sorted_li.extend(buc)
    return sorted_li