基础算法(栈、队列、排序)

栈（先进后出 、后出先进）

# 定义一个栈（FILO）
class Stack(object):
    def __init__(self):
        self.stack = []
    def pop(self):
        if self.is_empty():
            return None
        else:
            return self.stack.pop()
    def push(self,val):
        return self.stack.append(val)
    def peak(self):
        if self.is_empty():
            return None
        else:
            return self.stack[-1]
    def size(self):
        return len(self.stack)
    def is_empty(self):
        return self.size() == 0

s = Stack()
s.push(1)
s.peak()
s.is_empty()
s.pop()

队列（先进先出、后进后出）

# 定义一个队列（FIFO）
class Queue(object):
    def __init__(self):
        self.queue = []
    def enqueue(self,val):
        self.queue.insert(0,val)
    def dequeue(self):
        if self.is_empty():
            return None
        else:
            return self.queue.pop()
    def size(self):
        return len(self.queue)
    def is_empty(self):
        return self.size() == 0

q = Queue()
q.enqueue(1)
q.is_empty()
q.dequeue()

使用队列模拟栈

class StackByQueue(object):
    def __init__(self):
        self.stack = Queue()
    def push(self, val):
        self.stack.enqueue(val)
    def pop(self):
        for i in range(self.stack.size() - 1):
            value = self.stack.dequeue()
            self.stack.enqueue(value)
        return self.stack.dequeue()

使用栈模拟队列

classclass  QueueByStackQueueBy (object):
    def __init__(self):
        self.queue1 = Stack()
        self.queue2 = Stack()
    def enqueue(self, val):
        self.queue1.push(val)
    def dequeue(self):
        for i in range(self.queue1.size() - 1):
            value = self.queue1.pop()
            self.queue2.push(value)
        res = self.queue1.pop()
        for i in range(self.queue2.size()):
            value = self.queue2.pop()
            self.queue1.push(value)
        return res

插入排序

def insertSort(A):
    for j in range(1, len(A)):
        key = A[j]
        i = j - 1
        while i >= 0 and A[i] > key:
            A[i + 1] = A[i]
            i = i - 1
        A[i + 1] = key
    return A

A = [5, 2, 4, 6, 1, 3]

print(insertSort(A))

# 复杂度O(n**2)

快速排序

def partition(A, p, r):
    x = A[r]
    i = p - 1
    for j in range(p, r):
        if A[j] <= x:
            i = i + 1
            A[i], A[j] = A[j], A[i]
    A[i + 1], A[r] = A[r], A[i + 1]
    return i + 1

def quickSort(A, p, r):
    if p < r:
        q = partition(A, p, r)
        quickSort(A, p, q - 1)
        quickSort(A, q + 1, r)

A = [2, 8, 7, 1, 3, 5, 6, 4]

quickSort(A, 0, 7)
print(A)

# 时间复杂度O(nlogn)
# 假设快速排序的时间复杂度为f(N)
# f(N) = 2 * f(N / 2) + O(N)
# f(N) = 2 * (2 * f(N / 4) + O(N/2)) + # O(N)
# ...
# f(1) = O(1)
所以f(N) = O(NlogN)

在数组元素数量为n的数组里面寻找第k大的数

def partition(A, p, r):
    x = A[r]
    i = p - 1
    for j in range(p, r):
        if A[j] >= x:
            i = i + 1
            A[i], A[j] = A[j], A[i]
    A[i + 1], A[r] = A[r], A[i + 1]
    return i + 1
    
def findKthLargest(A, p, r, k):
    if p <= r:
        q = partition(A, p, r)
        if k - 1 == q:
            return A[q]
        elif k - 1 < q:
            return findKthLargest(A, p, q - 1, k)
        else:
            return findKthLargest(A, q + 1, r, k)

A = [2, 8, 7, 1, 3, 5, 6, 4]

ret = findKthLargest(A, 0, 7, 8)

print('ret: ', ret)