数据结构与算法——打卡第五天

排序与搜索

一、排序算法的稳定性

稳定性：稳定排序算法会让原本有相等键值的记录维持相对次序、也就是如果一个排序算法是稳定的。当有两个相等键值的记录R和S。且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。

二、排序算法

1、冒泡排序

冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

def bubble_sort(alist):
    n=len(alist)
    for i in range(0,n-1):
        count=0
        for j in range(0,n-1-i):
            if alist[j]>alist[j+1]:
                alist[j],alist[j+1]=alist[j+1],alist[j]
                count+=1
        if count==0:
            break
    return alist

li=[54,26,93,17,31,44,55,20]
bubble_sort(li)
print(li)

2、选择排序

选择排序是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

def selection_sort(alist):
    n=len(alist)
    for i in range(0,n-1):
        min=alist[i]
        for j in range(i+1,n):
            if alist[j]<min:
                min,alist[j]=alist[j],min
        alist[i]=min
    return alist

alist=[54,226,93,17,77,31,44,55,20]
selection_sort(alist)
print(alist)

3、插入排序

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

def insert_sort(alist):
    n=len(alist)
    for i in range(1,n):
        for j in range(i,0,-1):
            if alist[j]<alist[j-1]:
                alist[j],alist[j-1]=alist[j-1],alist[j]
            else:
                 break
    return alist

alist=[54,26,93,17,77,31,44,55,20]
insert_sort(alist)
print(alist)

4、快速排序

快速排序，又称划分交换排序，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

def quick_sort(alist,start,end):
    if start > end:
        return
        
    mid=alist[start]
    low=start
    high=end
    while low<high:
        while low<high and alist[high]>=mid:
            high-=1
        alist[low]=alist[high]

        while low<high and alist[low]<mid:
            low+=1
        alist[high]=alist[low]

    alist[low]=mid
    quick_sort(alist,start,low-1)
    quick_sort(alist,high+1,end)

alist=[54,26,93,17,77,31,44,55,20]
quick_sort(alist,0,len(alist)-1)
print(alist)

5、希尔排序

希尔排序是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

def shell_sort(alist):
    n=len(alist)
    gap=n//2
    while gap>=1:
        for i in range(gap,n):
            j=i
            while j>=gap and alist[j]<alist[j-gap]:
                alist[j],alist[j-gap]=alist[j-gap],alist[j]
                j-=gap
        gap=gap//2

    return alist

alist=[54,26,93,17,77,31,44,55,20]
shell_sort(alist)
print(alist)

6、归并排序

归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。
将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁i，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

def merge_sort(alist):
    if len(alist)<=1:
        return alist
    num=len(alist)//2
    left=merge_sort(alist[:num])
    right=merge_sort(alist[num:])
    return merge(left,right)

def merge(left,right):
    l,r=0,0
    result=[]
    while l <len(left)and r<len(right):
        if left[l]<right[r]:
            result.append(left[l])
            l+=1
        else:
            result.append(right[r])
            r+=1
    result+=left[l:]
    result+=right[r:]
    return result

alist=[54,26,93,17,77,31,44,55,20]
sorted_alist=merge_sort(alist)
print(sorted_alist)

三、搜索

二分查找法

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

#非递归实现
def binary_search(alist,item):
    first=0
    last=len(alist)-1
    while first<=last:
        midpoint=(first+last)//2
        if alist[midpoint]==item:
            return True
        elif alist[midpoint]>item:
            last=midpoint-1
        elif alist[midpoint]<item:
            first=midpoint+1
        midpoint=(first+last)//2
    return False

testlist=[0,1,2,8,13,17,19,32,42]
print(binary_search(testlist,3))
print(binary_search(testlist,13))

def binary_search(alist,item):
    if len(alist)==0:
        return False
    else:
        midpoint=len(alist)//2
        if alist[midpoint]==item:
            return True
        elif alist[midpoint]>item:
            return binary_search(alist[:midpoint],item)
        elif alist[midpoint]<item:
            return binary_search(alist[midpoint+1:], item)

testlist=[0,1,2,8,13,17,19,32,42]
print(binary_search(testlist,3))
print(binary_search(testlist,13))