python笔记-算法及数据结构5

1 排序算法的稳定性

    稳定的排序算法会让原本具有相等键值的记录维持相对次序

2 冒泡排序

    一种简单的排序算法，名字的由来是因为越小的元素会经由交换慢慢浮到数列的顶端，重复遍历要排序的数列，一次比较两个元素，如果两者的顺序错误就把他们交换过来。

def maopao(alist):

    if len(alist)<=1:

        return

    else:

        for i in range(len(alist)-1,1,-1):

            count=0

            for j in range(i):

                if (alist[j]>alist[j+1]):

                    alist[j],alist[j+1]=alist[j+1],alist[j]

                    count+=1

            if count==0:

                return

 

3 选择排序

    从第一个元素开始遍历，选出从当前元素到数组末尾的最小值，并将这个最小值与当前元素交换，得到一个有序数列。

def xuanze(alist):

    n=len(alist)

    for i in range(n):

        min=i

        for j in range(i+1,n):

            if(alist[j]<alist[min]):

                min=j

        alist[i],alist[min]=alist[min],alist[i]

 

4 插入排序

    也是将数组看做两个部分，左边是有序部分，右边是无序部分，将右边部分第1个插入到左边有序部分的合适位置，直至整个数组是有序序列。

def charu(alist):

    n=len(alist)

    print(n)

    for i in range(1,n):

        m=i

        print(m)

        for j in range(i):

            if alist[i-1-j]>alist[m]:

                alist[i-1-j],alist[m]=alist[m],alist[i-1-j]

                m=i-1-j

                print('m的值:{}'.format(m))

            else:

                break

 

5 希尔排序

    将数组列在一个表中并对列分别进行插入排序，重复这过程，但是每次用更长的列来进行，直到整个表只有一列。

这个程序里面有一个妙处：并没有专门针对某一个具体数列排序，而是将其放在整个数列中实施，但是也达到了同样的目的，简化了程序。

def hill(alist):

    n=len(alist)

    gap=n//4

    while(gap>=1):

        for i in range(gap,n):

            m=i

            while m>0:

                if(alist[m]<alist[m-gap]):

                    alist[m],alist[m-gap]=alist[m-gap],alist[m]

                m-=gap

        gap//=2

 

6 快速排序

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

    在这个程序的处理过程中，递归的处理参数很重要，要注意是对目标队列排序！

def speed(alist,first,last):

    if (first>=last):

        return

    curl=first

    curr=last

    pir=alist[curl]

    while curr>curl:

        while curr>curl and (alist[curr]>=pir):

            curr-=1

        alist[curl]=alist[curr]

        while curr>curl and (alist[curl]<=pir):

            curl+=1

        alist[curr]=alist[curl]

    alist[curl]=pir

    speed(alist,first,curl-1)

　　speed(alist,curl+1,last)

 

7 归并排序

    将数据分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小先取谁，取后指针后移一位。然后继续比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

def guibing(alist):

    n=len(alist)

    if n<=1:

        return alist

    mid=n//2

    left_li=guibing(alist[:mid])

    right_li=guibing(alist[mid:])

 

    left_p=0

    right_p=0

    result=[]

 

    while left_p<len(left_li) and right_p<(len(right_li)):

        if(left_li[left_p]<=right_li[right_p]):

            result.append(left_li[left_p])

            left_p+=1

        else:

            result.append(right_li[right_p])

            right_p+=1

    result+=left_li[left_p:]

    result+=right_li[right_p:]

　　return result

 

8 排序算法比较

排序算法	最好情况	最坏情况	稳定性
冒泡排序	O(n)	O(n2)	稳定
选择排序	O(n2)	O(n2)	不稳定
插入排序	O(n)	O(n2)	稳定
希尔排序	O(n1.3)	O(n2)	不稳定
快速排序	O(nlogn)	O(nlogn)	不稳定
归并排序	O(nlogn)	O(nlogn)	稳定

8 二分查找

    二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。

def binary_ser(alist,item):

    n=len(alist)

    if (n>0):

        mid=n//2

        if(alist[mid]==item):

            return True

        elif(alist[mid]<item):

            return binary_ser(alist[mid+1:],item)

        else:

            return binary_ser(alist[:mid],item)

    return False