几种排序的python实现

冒泡排序

def bubble_sort(li):
    num = len(li)
    for i in range(num - 1):
        for j in range(num - i - 1):
            if li[j] > li[j+1]:
                li[j],li[j+1] = li[j+1],li[j]

            
            

注意循环的范围

 

选择排序

一趟遍历找到最小值，放到第一个位置；再继续

def select_sort(li):
    num = len(li)
    for i in range(num - 1):
        min_pos = i
        for j in range(i, num):
            if li[j] < li[min_pos]:
                min_pos = j
        li[i],li[min_pos] = li[min_pos],li[i]            

注意循环的范围

 

插入排序

摸牌，插牌；再摸，再插

def insert_sort(li):
    num = men(li)
    for i in range(1, num):
        tem = li[i]
        j = i -1
        while j>=0 and li[j]>li[tem]:
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tem     

注意循环终止条件

 

快排

取一个元素，使它归位；再左右递归

归位：左右互换之术

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)


def partition(li, left, right):
    tem = li[left]
    while left < right:
        while left < right and li[right] >= tem:
            right -= 1
        li[left] = li[right]
        while left < right and li[left] <= tem:
            left += 1
        li[right] = li[left]
    li[left] = tem
    return left

注意小循环的条件

切片法

def quick_sort2(li):
    if len(li) > 1:
        left = []
        right = []
        tem = li[0]
        for i in range(1, len(li)):
            if li[i] <= tem:
                left.append(li[i])
            else:
                right.append(li[i])
         return quick_sort2(left) + tem + quick_sort2(right)
    else:
        return li    

 

堆排序

完全二叉树可以用列表存储

父节点找左子节点：2×i + 1，子节点找父节点：(i -1)//2

先定义一次向下调整操作

def sift_down(li, low, high):
    tem = li[left] 
    i = left
    j = 2 * i + 1
    while j<= high: 
        if j + 1 <= high and li[j+1] > li[j]:
            j = j+1
        if li[j] > tem:
            li[i] = li[j]
            i = j
            j = i * 2 + 1
        else:
            break
    li[i] = tem

第一个 if 你细品

然后构造堆,最后挨个出数

def heap_sort(li):
    num = len(li)
    for i in range((num-2)//2, -1, -1):
        sift_down(li, i, num-1) # 构造堆

    for j in range(num-1, 0, -1):
        li[j],li[0] = li[0],li[j]
        sift_down(li, 0, j-1)
    

 

归并排序

先定义一次归并操作

def merge(li, left, mid, right):
    i = left
    j = mid + 1
    tem =[]
    while i <=mid and j <= right:
        if li[i] <= li[j]:
            tem.append(li[i])
            i += i
        else:
            tem.append(li[j])
            j += 1
    while i <= mid:    
        tmp.append(li[i])
        i +=1
    while j <= right:
        tem.append(li[j])
        j +=1

    for i in range(letf, right+1):
        li[i] = tem[i-left]


             

 

再递归排序

def merge_sort(li, left, right):
    mid = (left+right)//2
    if right <= left:
        pass
    else: 
        merge_sort(li, left, mid)
        merge_sort(li, mid+1, right)
        merge(li,left, mid, right)    

优先队列就是堆，最大优先，最小优先出

什么是散列表

面哪一方法可以判断出一个有向图是否有环(回路)：dfs、bfs、拓扑排序；

Dijkstra求最短路径是不可以的

Blending

用不相交的数据训练不同的 Base Model，将它们的输出取（加权）平均。实现简单，但对训练数据利用少了。blending和stacking类似，主要是对已学好的基学习器的结果的融合不同，Blending是线性融合，而Stacking是非线性融合。

 

 

经验风险是指所有样本的损失函数之和;

要加上一个惩罚项，约束模型复杂度，即得到结构化风险

 

哈弗曼树及编码

 

二叉树的度是指树中所以结点的度数的最大值。二叉树的度小于等于2,因为二叉树的定义要求二叉树中任意结点的度数(结点的分支数)小于等于2 

假设一个二叉树有bai a个度为2的节du点， b个度为1的节点，zhi c个叶节点， 则这个二叉树的边数是 2a + b 。
　　另dao一方面，由于共有a+b+c个节点，
　　所以
　　边数= a+b+c-1 。
　　所以
　　2a+b = a+b+c-1
　　所以
　　a = c-1
 

 

 

平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树

红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 [2] 

它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。 [2]

生成模型和判别模型

 

函数的递归调用：一个函数在它的函数体内，直接或者间接地调用了他本身

 

K-Means（三）核k-均值算法

ｋ均值适合样本分布是凸形的