【转】算法详细总结

1.冒泡排序

def bubble_sort(data_list):
    """
    冒泡排序：
    首先拿到第一个元素，和它第二个作比较，把较大的数放在右边
    第二个再和第三个比较。。。。一轮下来，最后一个就是最大的数
    再一轮，倒数第二个也变成有序的......最终都变成有序的
    :param data_list:
    :return:
    """
    # [6,3,2,7,8,9,5,1,4]
    # []
    for i in range(len(data_list)):
        flag = True  # 做一个标记，看是否在冒泡的过程中发生数据交换
        for j in range(len(data_list) - i - 1):
            # [6,3]做对比，换成[3,6] ，然后 [6,2] 做对比......
            if data_list[j] > data_list[j + 1]:
                data_list[j], data_list[j + 1] = data_list[j + 1], data_list[j]
                flag = False
        if flag:
            # 如果没有发生数据交互，那么数据本身就是排好序的
            break

2.选择排序

def select_sort(data_list):
    """
    选择排序：
    不断找到最小的（找最大的也是可以的）
    首先拿到第一个，然后发现比它小的，记住下标。循环一轮，找到最小的数的位置 和 最左边的数交换位置
    然后从第二个开始....和第二个交换位置，
　　 .....开始变得越来越有序
    :param data_list:
    :return:
    """
    # [6,3,2,7,8,9,5,1,4]
    for i in range(len(data_list)):
        # 做一个标记
        flag = True
        # 当前元素无序区的第一个元素是最小的
        min_loc = i
        for j in range(i + 1, len(data_list)):
            # 循环遍历无序区
            if data_list[j] < data_list[min_loc]:
                # 如果无序区的元素比假定的小，那将该元素标记为最小的
                min_loc = j
                flag = False
        # 循环遍历结束，将无序区的最小元素和第一个元素的位置做一下交换
        if flag:
            continue
        data_list[i], data_list[min_loc] = data_list[min_loc], data_list[i]def select_sort(data_list):
    """
    选择排序：
    不断找到最小的（找最大的也是可以的）
    首先拿到第一个，然后发现比它小的，记住下标。循环一轮，找到最小的数的位置 和 最左边的数交换位置
    然后从第二个开始....和第二个交换位置，
　　 .....开始变得越来越有序
    :param data_list:
    :return:
    """
    # [6,3,2,7,8,9,5,1,4]
    for i in range(len(data_list)):
        # 做一个标记
        flag = True
        # 当前元素无序区的第一个元素是最小的
        min_loc = i
        for j in range(i + 1, len(data_list)):
            # 循环遍历无序区
            if data_list[j] < data_list[min_loc]:
                # 如果无序区的元素比假定的小，那将该元素标记为最小的
                min_loc = j
                flag = False
        # 循环遍历结束，将无序区的最小元素和第一个元素的位置做一下交换
        if flag:
            continue
        data_list[i], data_list[min_loc] = data_list[min_loc], data_list[i]

3.插入排序

def insert_sort(data_list):
    """
    插入排序：有点像抓牌，插牌
　　 手中刚开始有一张牌，一张牌当然是有序的
　　 再把第二张牌拿到手里 和 第一张比较是否需要交换位置，然后手中的两张牌变得有序了
　　 再拿第三张牌，和手中的牌 从右边开始比较 ，如有需要交换位置
　　 ......
　　 所有的牌都到手里，手里的牌都变成有序的

    :param data_list: 将数据传递过来
    :return: 返回有序的list
    """
    for i in range(1, len(data_list)):
        # 从第二数据开始
        for j in range(0, i):
            # 它左边的数字都是有序的
            if data_list[i] < data_list[j]:
                # 如果这数字比左边的某个数字小，则交换这两个数字的位置
                data_list[i], data_list[j] = data_list[j], data_list[i]

4.快速排序

def qsort(seq):
    if seq==[]:
        return []
    else:
        pivot=seq[0]
        lesser=qsort([x for x in seq[1:] if x<pivot])
        greater=qsort([x for x in seq[1:] if x>=pivot])
        return lesser+[pivot]+greater

5.广度遍历和深度遍历二叉树

## 14 二叉树节点
class Node(object):
    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right
 
tree = Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))
 
## 15 层次遍历
def lookup(root):
    stack = [root]
    while stack:
        current = stack.pop(0)
        print current.data
        if current.left:
            stack.append(current.left)
        if current.right:
            stack.append(current.right)
## 16 深度遍历
def deep(root):
    if not root:
        return
    print root.data
    deep(root.left)
    deep(root.right)
 
if __name__ == '__main__':
    lookup(tree)
    deep(tree)

6.求最大树深

def maxDepth(root):
        if not root:
            return 0
        return max(maxDepth(root.left), maxDepth(root.right)) + 1

7.求两颗树是否相等

def isSameTree(p, q):
    if p == None and q == None:
        return True
    elif p and q :
        return p.val == q.val and isSameTree(p.left,q.left) and isSameTree(p.right,q.right)
    else :
        return False

8.单链表逆置

class Node(object):
    def __init__(self, data=None, next=None):
        self.data = data
        self.next = next
 
link = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))
 
def rev(link):
    pre = link
    cur = link.next
    pre.next = None
    while cur:
        tmp = cur.next
        cur.next = pre
        pre = cur
        cur = tmp
    return pre
 
root = rev(link)
while root:
    print root.data
    root = root.next

9.二分查找

def binarySearch(l, t):
    low, high = 0, len(l) - 1
    while low < high:
        print low, high
        mid = (low + high) / 2
        if l[mid] > t:
            high = mid
        elif l[mid] < t:
            low = mid + 1
        else:
            return mid
    return low if l[low] == t else False
 
if __name__ == '__main__':
    l = [1, 4, 12, 45, 66, 99, 120, 444]
    print binarySearch(l, 12)
    print binarySearch(l, 1)
    print binarySearch(l, 13)
    print binarySearch(l, 444)

10.交叉链表求交点

    def __init__(self, x):
        self.val = x
        self.next = None
def node(l1, l2):
    length1, lenth2 = 0, 0
    # 求两个链表长度
    while l1.next:
        l1 = l1.next
        length1 += 1
    while l2.next:
        l2 = l2.next
        length2 += 1
    # 长的链表先走
    if length1 > lenth2:
        for _ in range(length1 - length2):
            l1 = l1.next
    else:
        for _ in range(length2 - length1):
            l2 = l2.next
    while l1 and l2:
        if l1.next == l2.next:
            return l1.next
        else:
            l1 = l1.next
            l2 = l2.next