经典排序算法汇总

1、冒泡排序：

每次遍历数组，把最大的数放在最后一个index再从index-1开始往前遍历。

def maopao(num_list):
    for j in range(1, len(num_list)):
       for i in range(len(num_list) - j):
           if num_list[i] > num_list[len(num_list) - j]:
               temp = num_list[len(num_list) - j]
               num_list[len(num_list) - j] = num_list[i]
               num_list[i] = temp

    print num_list

2、插入排序： 

类似于打扑克的一种方式，前面的牌已经从小到大排好序，对于新插入的一个数，再依次遍历前面的数组找到其位置。

def insert(num_list):
    result_list = []
    result_list.append(num_list[0])
    for i in range(1, len(num_list)):
        flag, temp = -1, []
        for j in range(i):
            if num_list[i] >= result_list[j] and flag == -1:
                continue
            elif num_list[i] < result_list[j] and flag == -1:
                temp = result_list[j:]
                result_list[j] = num_list[i]
                flag = j
                break
        if flag != -1:
            result_list = result_list[:flag + 1] + temp
        elif flag == -1:
            result_list.append(num_list[i])

3、归并排序：

对数组从中间不断拆分，再对最后的数组从分割成2个元素，再从小到大依次合并。

def merge(num_list, left, right):
    mid = (left + right) / 2
    i = left
    j = mid + 1
    temp_list = []
    while i <= mid and j <= right:
        if num_list[i] <= num_list[j]:
            temp_list.append(num_list[i])
            i += 1
        else:
            temp_list.append(num_list[j])
            j += 1

    while i <= mid:
        temp_list.append(num_list[i])
        i += 1

    while j <= right:
        temp_list.append(num_list[j])
        j += 1

    for i in range(len(temp_list)):
        num_list[left + i] = temp_list[i]




def guibing(num_list, left, right):
    if left >= right:
        return
    mid = (left + right) / 2
    guibing(num_list, left, mid)
    guibing(num_list, mid + 1, right)
    merge(num_list, left, right)

def guibin_main():
    num_list = [1, 5, 7, 10, 8, 9]
    l = 0
    r = len(num_list) - 1
    guibing(num_list, l, r)
    print num_list

4、快速排序：

选择序列中一个基准，把大于该基准的数放后面，小于该基准的数放前面，并依次选择基准。

def swap(self, num_list, i, j):
    temp = num_list[i]
    num_list[i] = num_list[j]
    num_list[j] = temp

def partition(self, num_list, left, right):
    pivot = num_list[right]
    tail = left
    for i in range(left, right):
        if num_list[i] < pivot:
            self.swap(num_list, tail, i)
            tail += 1
    self.swap(num_list, tail, right)
    return tail

def quick_sort(self, num_list, left, right):
    if left >= right:
        return
    index = self.partition(num_list, left, right)
    self.quick_sort(num_list, left, index - 1)
    self.quick_sort(num_list, index + 1, right)

def quick_main(self):
    num_list = [1, 5, 6, 2, 7, 3]
    l = 0
    r = len(num_list) - 1
    self.quick_sort(num_list, l, r)
    print num_list

深度优先搜索和广度优先搜索：

深度优先是先访问一个邻节点直到最底部的邻节点，而广度优先算法是访问所有的邻节点。