算法与数据结构

# 冒泡排序
# 时间复杂度：O(n^2)
def bubble_sort(li):
    for i in range(len(li) - 1):  # 趟数
        flag = True
        for j in range(len(li) - 1 - i):  # 每一趟内层循环，每一趟确定一个比较次数-i
            if li[j] > li[j + 1]:  # 前面大于后面交换位置
                li[j], li[j + 1] = li[j + 1], li[j]
                flag = False
        if flag:  # 优化：如果一趟循环下来都没有要比较交换的位置说明原本就是顺序的，直接返回
            return

# 选择排序
# 时间复杂度：O(n^2)
def select_sort(li):
    for i in range(len(li)):
        # 将取出的第一个默认是最小的
        minloc = i
        for j in range(i + 1, len(li)):
            # 循环比较后面的所有值与 第一个元素比较
            if li[minloc] > li[j]:
                # 如果比第一个元素小就换位置
                li[minloc], li[j] = li[j], li[minloc]

# 插入排序
# 时间复杂度：O(n^2)
def insert_sort(li):
    # 将第一个元素作为有序区第一个元素
    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 = j - 1
        # 比较完j=-1跳出循环，将取出的值作为第一个
        li[j + 1] = tmp

# 快速排序
# 时间复杂度：O(nlogn)
def quick_sort(li, left, right):
    # 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 = right - 1
        # 如果右边的比第一个小，将该元素赋值给左边
        li[left] = li[right]
        
        # 判断左边的元素是否比取出的元素小，如果小指针移动一位
        while left < right and li[left] <= tem:
            left = left + 1
        # 如果左边的比取出的大，将该元素赋值给刚右边元素的位置
        li[right] = li[left]
    # 当指针重合时，将取出的第一个元素放下在中间
    li[left] = tem
    mid = left  # 或者等于right，两边指针重合时
    return mid

# quick_sort(li, 0, len(li)-1)

def count_sort(li):
    # 先生成比列表多一个的列表全是0
    count = [0 for i in range(len(li)+1)]
    # 将列表循环取出对应的count=1
    print(count)
    for i in li:
        count[i] += 1
    print(count)
    # 将原列表清空后再添加
    li.clear()
    # 枚举出count
    for k, v in enumerate(count):
        print(k, v)
        # 去除0和保证重复的数在里面
        for i in range(v):
            li.append(k)

def bin_search(li, value, low, high):
    if low <= high:
        mid = (low + high) // 2
        if li[mid] == value:
            return mid
        elif li[mid] > value:
            return bin_search(li, value, low, mid-1)
        else:
            return bin_search(li, value, mid+1, high)
    else:
        return

1、申请数组的前提条件是：内存是连续的

2、int a[7] ：代表声明一个数组是a，数组大小是7，数组的元素都是整型

一个数长度是4个字节所以7个是28个字节

3、如何申请内存：在C, C++ 语言中，mallco(28）申请28个字节，用完后要释放: free(28）

4、如果 int a[7] = [1, 2, 3, 4, 5, 6, 7]  那如何知道 a[3] = 4的？

a[3] = 首地址(1000) + 索引(3) * 长度(4）= 1012--1015

5、首地址是保存在数组名中的