Python 第八阶段 学习记录之---算法

算法(Algorithm): 一个计算过程， 解决问题的方法

一、递归的两个特色
    - 调用自身
    - 结束条件

时间复杂度
    - 时间复杂度是用来估计算法运行时间的一个式子（单位）
    - 通常来讲，时间复杂度高的算法比复杂度低的算法快
空间复杂度
    用来评估算法内存占用大小的一个式子

列表查找： 从列表中查找指定元素
    输入：无序
    输出：有序
顺序查找：
    从列表第一个元素开始，顺序进行搜索，直到找到为止。

二分查找：
    从有序列表的候选区data[0:n]开始，经过对待查找的值与候选区中间值的比较，可使候选区减小一半。
    找任何一个数，次数都不会超过LOG 2 N,  2为底N的对数， 2 ** x <= n
    在10**5内找一个数，那么找到它，须要找的次数 2 **x < 10**5, x = 16

列表排序：

    列表排序： 将无序列表变为有序列表
    应用场景：
        各类榜单、表格、给二分排序用，给其它算法用

    排序lowB三人组：
        冒泡排序
        选择排序
        插入排序
    快速排序
    排序NB二人组：
        - 堆排序
        - 归并排序
    没什么人用的排序：
        基数排序
        希尔排序
        桶排序


1、LOW
    时间复杂度：O(n**2)
    空间复杂度：O(1)

    冒泡排序：
        时间复杂度：O(n**2)
        random.shuffle(data) #
        排序一万个数得10多秒，
        首先，列表每两个相邻的数，若是前边的比后边的大，那么交换这两个数
        若是冒泡排序中执行一趟而没有交换，则列表已是有序状态，能够直接结束算法。
    选择排序
        一趟遍历记录最小的数，放到第一个位置；
        再一趟遍历记录剩余列表中最小的数，继续放置；
        找到最小的数:
            if xx < xxx: xxx=xx, xx,xx=xx,xx, 小于则交换
    插入排序：(打牌同样，来一个数、插入一次)
        列表被分为有序区和无序区两个部份。最初有序区只有一个元素。
        每次从无序区选择一个元素，插入到有序区的位置，直到无序区变空。


2、快排（快速排序）
    快速排序：
        好写的排序算法里最快的
        快的排序里最好写的

    快排思路：
        取一个元素P(第一个元素), 使P归位；
        列表被P分红两部分，左边都比P小，右边都比P大；
        递归完成排序

    效率：
        快排相比冒泡快了多少？
    问题：
        最坏状况
        递归

        最好状况    通常状况    最坏状况
快排    O(nlogn)    O(nlogn)    O(n^2)
冒泡    O(n)        O(n^2)       O(n^2)

    代码实现：


堆
    树是一种数据结构          好比：目录结构
    树是一种能够递归定义的数据结构
    树是由n个节点组成的集合：
    若是n=0，那这是一棵空树；
    若是n>0，那存在1个节点做为树的根节点，其余节点能够分为m个集合，每一个集合自己又是一棵树。
    一些概念
        根节点、叶子节点
        树的深度（高度）
        树的度： 有几个子结点(下一层，)
        孩子节点/父节点
        子树

    二叉树：度不超过2的树（节点最多有两个叉）
        满二叉树
        彻底二叉树

    二叉树的存储方式：
        链式存储方式
        顺序存储方式（列表）

        父节点和左孩子节点的编号下标有什么关系？
            i -> 2*i + 1

        父节点和右孩子节点的编号下标有什么关系？
            i -> 2i+2
        好比，咱们要找根节点左孩子的左孩子
            x = 2*(2*0+1)+1 = 3， list_[3]
        最后一个有子结点的堆
            x = n // 2 - 1 # n = len()

    二叉树是度不超过2的树
    满二叉树与彻底二叉树
    （彻底）二叉树能够用列表来存储，经过规律能够从父亲找到孩子或从孩子找到父亲

堆
    大根堆：一棵彻底二叉树，知足任一节点都比其孩子节点大
    小根堆：一棵彻底二叉树，知足任一节点都比其孩子节点小

    假设：节点的左右子树都是堆，但自身不是堆
        当根节点的左右子树都是堆时，能够经过一次向下的调整来将其变换成一个堆
    堆排序过程：
        创建堆
        获得堆顶元素，为最大元素
        去掉堆顶，将堆最后一个元素放到堆顶，此时可经过一次调整从新使堆有序。
        堆顶元素为第二大元素。
        重复步骤3，直到堆变空。



归并：
    - 假设如今的列表分红两段有序， 如何将其合成为一个有序列表
    - 从两边分别取，取最小的  ===> 这个过程就叫归并
        确定有一边先取完，剩下的就没必要再比较，直接取下来，xx[:] = xxx[:]

    有了归并如何使用？
        分解： 将列表越分越小，直至分红一个元素。
        一个元素是有序的
        合并： 将两个有序列表归并，列表愈来愈大。


    时间复杂度：O(nlogn)
    空间复杂度：O(n)

    * 三种排序算法的时间复杂度是O(nlogn)
        - 通常状况下，就运行时间而言：
            快速排序 < 归并排序 <  堆排序

        - 三种排序算法的缺点：
            - 快速排序： 极端状况下排序效率底
            - 归并排序： 须要额外的内存开销
            - 堆排序： 在快的排序算法中相对较慢

希尔排序：
    希尔排序是一种分组插入排序算法。
    首先取一个整数d1=n/2，将元素分为d1个组，每组相邻量元素之间距离为d1，在各组内进行直接插入排序；
    取第二个整数d2=d1/2，重复上述分组排序过程，直到di=1，即全部元素在同一组内进行直接插入排序。
    希尔排序每趟并不使某些元素有序，而是使总体数据愈来愈接近有序；最后一趟排序使得全部数据有序。

    时间复杂度： O((1+T)n)  # O(1.3n)

排序：
    - 两个排序条件
        姓名、年龄
        排序的稳定性，


冒泡、快排、堆、归并
算法稳定性：
    就是算法的稳定性：假定在待排序的记录序列中，存在多个具备相同的关键字的记录(有相同的元素)，
    若通过排序，这些记录的相对次序保持不变，
    即在原序列中，ri=rj，且ri在rj以前，而在排序后的序列中，ri仍在rj以前，则称这种排序算法是稳定的；不然称为不稳定的。

练习1：
    一、如今有一个列表，列表中的数范围都在0到100之间，列表长度大约为100万，设计算法在O(n)时间复杂度内将列表进行排序。
        - 计数排序，统计每一个数出现的次数。只能是数值型，而后再写回列表
        这时使用快排等会比较慢，有大量重复数据

    二、有N(n>1000000)个数，如何取出最大的前10个数？
        - 取列表前10个元素创建一个小根堆。堆顶就是目前第10大的数
        - 依次向后遍历原列表，对于列表中的元素，若是小于堆顶，则忽略该元素；若是大于堆顶，则将堆顶更换为该元素，而且对堆进行一次调整；
        - 遍历列表全部元素后，倒序弹出堆顶。


    堆----> 优先排列
练习2：
    给定一个升序列表和一个整数，返回该整数在列表中的下标范围。
        例如： 列表[1,2,3,3,3,4,4,5], 若查找3，则返回(2,4)；若查找0，由返回(0，0)


study

#-*- coding: utf-8 -*-
# Wind clear raise
# 2017/7/22 下午4:33


import random
import runtime

@runtime.call_time
def bubble_sort(x):
    print(id(x))
    for i in range(len(x)-1):

        for j in range(len(x) -i - 1):
            # 相邻两个数相比较
            #
            if x[j] > x[j+1]:
                x[j], x[j+1] = x[j+1], x[j]


@runtime.call_time
def bubble_sort_2(x):
    """冒泡排序优化"""
    print(id(x))
    for i in range(len(x)-1):
        exchange = 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]
                exchange = True
        if not exchange:
            print(exchange)
            break


#选择排序
@runtime.call_time
def select_sort(li):
    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
        li[i], li[min_loc] = li[min_loc], li[i]


#插入排序
@runtime.call_time
def insert_sort(li):
    for i in range(1, len(li)):
        tmp = li[i]
        j = i - 1
        while j >=0 and tmp < li[j]:
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tmp

## 快排


def quick_sort(data, left, right):
    if left < right:
        mid = partition(data, left, right)
        quick_sort(data, left, mid-1)
        quick_sort(data, mid + 1, right)

def partition(data, left, right):

    tmp = data[left]
    while left < right:  # left == right 终止
        while left < right and data[right] >= tmp:
            right -= 1
        data[left] = data[right]

        while left < right and data[left] <= tmp:
            left += 1
        data[right] = data[left]

    data[left] = tmp

    return left

@runtime.call_time
def quick_sort_x(data):

    quick_sort(data, 0 , len(data) -1)



#堆
def sift(data, low, high):
    i = low
    j = 2 * i + 1
    tmp = data[i]

    while j <= high:  # 孩子在堆里
        if j < high and data[j] < data[j+1]: # 若是有右孩子且比左孩子大
            j += 1
        if tmp < data[j]:  # 孩子比根大
            data[i] = data[j]
            i = j    # 新的根
            j = 2 * i + 1   # 新的孩子

        else:
            break
    data[i] = tmp
# 降序
def sift_desc(data, low, high):
    i = low
    j = 2 * i + 1
    tmp = data[i]

    while j <= high:  # 孩子在堆里
        if j < high and data[j] > data[j+1]: # 若是有右孩子且比左孩子小
            j += 1
        if tmp > data[j]:  # 孩子比根小
            data[i] = data[j]
            i = j    # 新的根
            j = 2 * i + 1   # 新的孩子

        else:
            break
    data[i] = tmp

@runtime.call_time
def heap_sort(data):

    n = len(data)
    # print(data)
    # 最后一个有子结点的堆 n // 2 -1
    for i in range(n // 2 -1, -1, -1):
        sift(data, i, n -1)
    # 堆建好了。。
    # print(data)

    for i in range(n -1, -1, -1):   # i指向堆的最后
        data[0], data[i] = data[i], data[0]  # 领导退休，下属上位
        sift(data, 0, i - 1)   # 调整新领导
    # print(data)


## 归并
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
def mergesort(li, low, high):
    if low < high:
        mid = (low + high) // 2
        # print(low, high, mid)
        mergesort(li, low, mid)
        mergesort(li, mid+1, high)
        merge(li, low, mid, high)

@runtime.call_time
def mergesort_x(*args):
    mergesort(*args)


# 希尔
@runtime.call_time
def shell_sort(li):
    gap = len(li) // 2
    while gap >0:
        for i in range(gap, len(li)):
            tmp = li[i]
            j = i - gap
            while j >= 0 and tmp < li[j]:
                li[j+gap] = li[j]
                j -= gap
            li[j + gap] = tmp
        gap //= 2



import copy

data = list(range(10000))
#
random.shuffle(data)  # 打乱一个列表
data1 = copy.deepcopy(data)
data2 = copy.deepcopy(data)
data3 = copy.deepcopy(data)
data4 = copy.deepcopy(data)
# data = [1, 5, 3, 7, 8, 9]

# bubble_sort(data)
# random.shuffle(data)
# bubble_sort_2(data)
# print(id(data))

##xxx 1 5 3 7 8 9
## 5 4 8 3 9
# data = [5, 4, 8, 3, 9]

# insert_sort(data2)
# select_sort(data1)
# bubble_sort_2(data4)
# print(data)
print("快排")
quick_sort_x(data3)
# print(data3)
print("堆")
heap_sort(data1)

# 归并
print("归并")
mergesort_x(data4, 0, len(data4)-1)

print("shell sort")
shell_sort(data2)
# print(data2)




def topn(li, n=10):
    heap = li[0:n]
    for i in range(n//2-1, -1, -1):
        sift(heap, i, n-1)

    for i in range(n, len(li)):
        if li[i] > heap[0]:
            heap[0] = li[i]
            sift(heap, 0, n -1 )

    for i in range(n -1, -1, -1):
        heap[0], heap[i] = heap[i], heap[0]
        sift(heap, 0, i-1)

    return heap

study.py