算法学习笔记(持续更新中...)

<<算法图解>> 学习笔记

第一章

二分查找

二分查找是一种算法, 其输入是一个有序的元素列表. 如果要查找的元素包含在列表中, 二分查找返回其位置: 否则返回 NULL

一般而言, 对于包含N个元素的列表, 用二分查找最多需要log2^N步, 而简单查找最多需要N步.

# –*– coding: utf-8 –*–
# @Time      : 2019/1/4 21:53
# @Author    : Damon_duan
# @FileName  : binary_search.py
# @BlogsAddr : https://blog.csdn.net/Damon_duanlei
import time
import random


def binary_search(find_list, search_info):
    low = 0
    high = len(find_list) - 1
    while low <= high:
        mid = (low + high) // 2
        if search_info == find_list[mid]:
            return mid
        if search_info > find_list[mid]:
            low = mid + 1
        else:
            high = mid - 1
    return None


def easy_search(find_list, search_info):
    for i in range(len(find_list) - 1):
        if search_info == find_list[i]:
            return i
    return None


if __name__ == '__main__':
    list_a = [i for i in range(10000000)]
    find_num = random.randint(0, 10000000)
    print("find number is : {}".format(find_num))
    t1 = time.time()
    binary_search(list_a, find_num)
    t2 = time.time()
    easy_search(list_a, find_num)
    t3 = time.time()
    cost_1 = t2 - t1
    cost_2 = t3 - t2
    print("二分法查找花费时间:{}".format(cost_1))
    print("简单查询法查找花费时间:{}".format(cost_2))

运行结果:

>>>
find number is : 8645596
二分法查找花费时间:0.0
简单查询法查找花费时间:0.3390543460845947

一些常见的大 O 运行时间

O( log n ) , 也叫对数时间, 这样的算法包括二分查找

O( n ) , 也叫线性时间, 这样的算法包括简单查找

O( n * log n ) , 这样的算法包括快速排序法

O( n^2 ) , 这样的算法包括 冒泡排序 插入排序 选择排序

O( n! ), 旅行家算法

O( log n ) 比 O( n ) 快, n 越大, 前者比后者就快的越多.

选择排序

数组和链表

链表: 链表中的元素可以储存在内存的任何地方. 链表的每个元素都存储了下一个元素的地址, 从而使一系列随机的内存地址串在一起. 只要有足够的内存空间, 就能为链表分配内存.链表的优势在插入元素,删除元素方面.

数组: 数组在内存中都是相连的,添加元素可能需要开辟新的内存空间将所有元素转移,对于数组,我们知道其中每个元素的地址. 数组的优势在查询方面.

**结论:**数组的元素都在一起, 链表的元素是分开的, 其中每个元素都存储下一个元素的地址. 数组的读取速度很快, 链表的插入和删除速度很快.

选择排序

以下代码为冒泡, 插入, 选择 排序示例

# –*– coding: utf-8 –*–
# @Time      : 2019/1/4 20:24
# @Author    : Damon_duanlei
# @FileName  : sort_methord.py
# @BlogsAddr : https://blog.csdn.net/Damon_duanlei
import random
import copy
import time


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


def insert_sort(sort_list):
    for i in range(1, len(sort_list)):
        j = i
        insert_num = sort_list[i]