python3实现常见的算法

1 排序算法

1.1 选择排序

选择排序是比较慢的排序算法，时间复杂度：O(n^2)
python3实现选择排序：

def find_smallest(arr):
    min_eme = arr[0]
    min_index = 0
    for i in range(0, len(arr)):
        if arr[i] < min_eme:
            min_eme = arr[i]
            min_index = i
    return min_index


def select_sort(arr):
    new_arr = []
    for i in range(len(arr)):
        min = find_smallest(arr)
        new_arr.append(arr.pop(min))
    return new_arr


my_arr = [3, 1, 2, 5, 4]
result = select_sort(my_arr)
print(result)

1.2 快速排序

快速排序是比较快的排序算法，时间复杂度:O(nlogn)
python3 实现快速排序：

import random


def quick(my_list):
    if len(my_list) <= 1:
        return my_list
    else:
        pivot_index = random.randint(0, len(my_list) - 1)
        pivot = my_list[pivot_index]
        little = [i for i in my_list[:pivot_index] + my_list[pivot_index + 1:] if i <= pivot]
        big = [i for i in my_list[:pivot_index] + my_list[pivot_index + 1:] if i > pivot]
        return quick(little) + [pivot] + quick(big)


print(quick([5, 3, 2, 1, 6, 7]))

1.3 冒泡排序

def sortArray(nums):
        n = len(nums)
        # 遍历所有数组元素
        for i in range(n):
    
            # Last i elements are already in place
            for j in range(0, n-i-1):
    
                if nums[j] > nums[j+1] :
                    nums[j], nums[j+1] = nums[j+1], nums[j]
        return nums

2 二分查找

二分查找要比线性查找快的多，时间复杂度：O(logn)
用python3实现二分查找方法：

def binary_search(my_list, element):
    """
    :param my_list:
    :param element:
    :return:
    """
    low = 0
    high = len(my_list) - 1
    while low <= high:
        mid = (high + low) // 2
        guess = my_list[mid]
        if guess == element:
            return mid
        elif guess > element:
            high = mid - 1
        else:
            low = mid + 1
    return None


my_list = [3, 5, 7, 9, 10]

result = binary_search(my_list, 4)
print(result)

3 广度优先算法

广度优先可以求最短距离问题（图的结构），时间复杂度：O(节点+变数)，通常用O(V+E)
用python3实现：

from collections import deque


def search(name):
    search_queue = deque()
    search_queue += graph[name]
    checked = []
    while search_queue:
        person = search_queue.popleft()
        if person not in checked:
            if is_ok(person):
                return True
        else:
            search_queue += graph[person]
            checked.append(person)
    return True


def is_ok(name):
    if name == "tom":
        return True
    return False

4 链表反转

python3

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        p, rev = head, None
        while p:
            rev, rev.next, p = p, rev, p.next
        return rev

golang

func reverseList(head *ListNode) *ListNode {
    var prev *ListNode
    curr := head
    for curr != nil {
        next := curr.Next
        curr.Next = prev
        prev = curr
        curr = next
    }
    return prev
}

5 两个栈实现队列，入栈和出栈方法

5.1 python实现

class CQueue:

    def __init__(self):
        self.stack_in = []
        self.stack_out = []

    def appendTail(self, value: int) -> None:
        self.stack_in.append(value)

    def deleteHead(self) -> int:
        if not self.stack_out:
            if not self.stack_in:  # 都为空
                return -1
            else:  # 把in栈中的东西全部倒入out栈中
                while self.stack_in:
                    self.stack_out.append(self.stack_in.pop())

        return self.stack_out.pop()

5.2 golang实现

type CQueue struct {
    inStack, outStack []int
}

func Constructor() CQueue {
    return CQueue{}
}

func (this *CQueue) AppendTail(value int)  {
    this.inStack = append(this.inStack, value)
}

func (this *CQueue) DeleteHead() int {
    if len(this.outStack) == 0 {
        if len(this.inStack) == 0 {
            return -1
        }
        this.in2out()
    }
    value := this.outStack[len(this.outStack)-1]
    this.outStack = this.outStack[:len(this.outStack)-1]
    return value
}

func (this *CQueue) in2out() {
    for len(this.inStack) > 0 {
        this.outStack = append(this.outStack, this.inStack[len(this.inStack)-1])
        this.inStack = this.inStack[:len(this.inStack)-1]
    }
}