数据结构&& 算法

数据结构

二叉树

1. 树（节点）， 子节点（孩子） 左节点，右节点

2. 满二叉树 全都是满的

3. 完全二叉树 最后一层可以不满 但集中在左侧

4. 堆 小顶（根）堆 大顶（根）堆

• 在二叉树中，第i层的节点总数不超过2^(i-1)
• 对于任意一棵二叉树，如果其叶子节点数为n0，而度数为2的节点总数为n2， 则n0=n2+1
• 具有n个节点的完全二叉树的深度为int(log2n) +1

# 从小到大 排序 那么就把树调整为大根堆
# 从大到小 排序 那么就把树调整为小根堆
import time


def adjustHeap(li, i, length):
    # 定义左孩子 下标
    j = 2 * i + 1  # 左孩子节点位置
    # 把i位置保存下来
    temp = li[i]
    # 列表的长度

    while j < length:
        # 判断右孩子 是否存在 并且右孩子是否比左孩子大
        if j + 1 < length and li[j + 1] > li[j]:
            j = j + 1
        if li[j] > temp:
        	# 交换位置
            li[i] = li[j]
            # 把i的位置移动到j   对i进行大根堆调整
            i = j
            j = 2 * i + 1  # 重新计算左孩子的位置

        else:  # temp 更大 比较结束
            break

    li[i] = temp


def heap_sort(li):
    length = len(li)
    # range(4,-1,-1)
    # 从最后一个非叶节点开始 循环构造大根堆
    for i in range(length - 1, -1, -1):
        adjustHeap(li, i, length)

    for i in range(length - 1, -1, -1):
        li[0], li[i] = li[i], li[0]

        adjustHeap(li, 0, i)


if __name__ == '__main__':
    lista = [22, 15, 18, 17, 14, 2, 12, 1, 23, 10, 33]

    a = int(time.time() * 1000)
    heap_sort(lista)
    b = int(time.time() * 1000)
    print(b - a)
    print("--------------")
    print(lista)

二分查找

每次能够排除掉一半的数据，查找的效率非常高，但是局限性比较大。
必须是有序序列才可以使用二分查找。

def binary_search(lis,right, left,item):
	# lis 有序列表
	# left 左指针 0
	# right 右指针 len(lis)-1
	# item  查找元素 
    while left <=right :  
        mid = (right + left) //2    # 获取中间位置，数字的索引
        if item < lis[mid]:			#如果查询的数字比中间值小，就去二分之后的左边找
            right = mid -1			# 来到左边之后 右边边界 mid -1

        elif item > lis[mid]:		#如果查询的数字比中间值大，就去二分之后的右边找
            left = mid +1			# 来到右边之后 右边边界 mid +1
        else:
            return mid # 返回中间值的下标
	return -1 # 如果 循环结束，左边大于右边 没有找到元素  
lis = [11, 32, 51, 21, 42, 9, 5, 6, 7, 8]
    print(lis)
    lis.sort()
    print(lis)    

while 1:
    num = int(input('输入要查找的数：'))
    res = binary_search(lis, len(lis)-1,0,num)
    print(res)
    if res == -1:
        print('未找到！')
    else:
        print('找到！')  
        
        
# 2 ，递归算法
def binary_search(lis, right, left, item):
    # 结束条件
    if left > right:
        return -1  # 结束递归
    mid = (left + right) // 2
    if item < lis[mid]:
        right = mid - 1
    elif item > lis[mid]:
        left = mid + 1

    else:
        return mid
    return binary_search(lis, right, left, item)


lis = [11, 32, 51, 21, 42, 9, 5, 6, 7, 8]
print(lis)
lis.sort()
print(lis)

while 1:
    num = int(input('输入要查找的数：'))
    res = binary_search(lis, len(lis) - 1, 0, num)
    print(res)
    if res == -1:
        print('未找到！')
    else:
        print('找到！')

归并排序

def merge_list(list01):
	# list01  一个列表
	n = len(list01)
	# 递归结束条件
	if n < 2:
		return list01 

	# 取个中间值
	mid = n //2
	# 分成左右两个列表 
	# left 采用归并排序后形成新的有序的列表
	left_li = merge_list(list01[:mid])
	# right 采用归并排序后形成新的有序的列表
	right_li = merge_list(list01[mid:])
	left_pointer, right_pointer =0,0
	ret=[]
	while left_pointer < len(left_li) and right_pointer < len(right_li):
		if left_li[left_pointer] <= right_li[right_pointer]:
			ret.append(left_li[left_pointer])
			left_pointer +=1
		else:
			ret.append(right_li[right_pointer])
			right_pointer +=1
	ret += left_li[left_pointer:]
	ret += right_li[right_pointer:]
    return ret

if __name__ == "__mian__":
    ret = merge_list([12, 32321, 3211, 212, 3343, 222, 112, 121])
    print(ret)

插入排序

def insert_sort(mylist):
    for i in range(1,len(mylist)):
        pre = i - 1
        current = mylist[i]

        while pre >= 0 and mylist[pre] > current:
            mylist[pre + 1] = mylist[pre]
            pre -= 1
        mylist[pre + 1] = current
    return mylist


if __name__ == '__main__':
    ret = insert_sort([12, 2323, 123, 2123, 321, 23, 3232, 1123, 11233])
    print(ret)

快排排序

def kuaipai(lis,left,right):
    # 递归结束条件
    if left> right:
        return 
    i,j = left,right
    # 定义基准数
    base = lis[left]
    while j >i:
        while lis[j] >= base and j >i:
            j -=1
        while lis[i] <= base and j >i:
            i +=1
        lis[i].lis[j] = lis[j],lis[i]
    lis[left] = lis[i]
    lis[i] = base