排序算法与搜索

冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

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


list = [1,2,6,5,8,3,4,9,3,4]
list = bubbling_sort(list)
print(list)

运行结果：[1, 2, 3, 3, 4, 4, 5, 6, 8, 9]

选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

def chose_sort(li):
    for i in range(len(li)-1):
        min_loc = i
        for j in range(1+i,len(li)):
            if li[min_loc]>li[j]:
                min_loc=j
        if min_loc!=i:
            li[i],li[min_loc] = li[min_loc],li[i]

list = [1,2,6,5,8,3,4,9,3,4]

print(chose_sort(list)）

插入排序：插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

def insert_sort(li):
    for i in range(1,len(li)):
        tem =li[i]
        j=i-1
        while j >=0 and tem < li[j]:
            li[j+1]=li[j]
            j=j-1
        li[j+1]=tem
list = [1,2,6,5,8,3,4,9,3,4]

print(insert_sort(list))

快速排序 :取一个元素p(第一个元素),使p归位,,,列表被分为两部分,左边都比p小,右边都比p大,.递归完成排序

def quick_Sort(li):
    if len(li) < 2:    #如果数组就一个值
        return li
    else:
        pivot = li[0]    #拿到第一个值,
        less = []
        greater =[]
        for i in li[1:]:
            if i < pivot:
                less.append(i)
            if i >=pivot:
                greater.append(i)
        return quick_Sort(less) + [pivot] + quick_Sort(greater) #返回这个数组
list = [1,2,6,5,8,3,4,9,3,4]
print(quick_Sort(list))

希尔排序，实质上是一种分组插入方法，原理：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量

  =1( <  …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止

def shell_sort(alist):
    length = len(alist)
    inc = 0
    while inc <= length / 3:
        inc = inc * 3 + 1
    print(inc)
    while inc >= 1:
        for i in range(inc, length):
            tmp = alist[i]
            for j in range(i, 0, -inc):
                if tmp < alist[j - inc]:
                    alist[j] = alist[j - inc]
                else:
                    j += inc
                    break
            alist[j - inc] = tmp
        inc //= 3
        print(alist)


a = [1, 15, 12, 3, 56, 42, 1, 44, 32, 25, 6, 7, 32]
shell_sort(a)

归并排序，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序

#python归并排序算法
def mergeSort(seq):  
    if len(seq)<=1:  
        return seq  
    mid=int(len(seq)/2)  
    left=mergesort(seq[:mid])  
    right=mergesort(seq[mid:])  
    return merge(left,right)  
  
def merge(left,right):  
    result=[]  
    i,j=0,0  
    while i<len(left) and j<len(right):  
        if left[i]<=right[j]:  
            result.append(left[i])  
            i+=1  
        else:  
            result.append(right[j])  
            j+=1  
    result+=left[i:]  
    result+=right[j:]  
    return result  
  
 a =[1,2,6,5,8,3,4,9,3,4]

 a = mergeSort(a)
 print(a)

算法是时间复杂度：

二分查找：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列

def search(list,value):
    low = 0
    high =len(list)-1
    while low <= high:
        mid =(low+high)//2
        if list[mid] == value:
            return mid
        if list[mid] < value:
            low =mid+1
        if list[mid]> value:
            high = mid-1
    return None

st = search([1,2,3,4,5,6,7,8,9,14,18,34,87,100],7)

python 实现二叉树遍历

class Node:  
     def __init__(self,value=None,left=None,right=None):  
         self.value=value  
         self.left=left   #左子树 
         self.right=right #右子树


def preTraverse(root):  
    '''
    前序遍历：先访问根节点，再遍历左子树，最后遍历右子树；并且在遍历左右子树时，仍需先访问根节点，然后遍历左子树，最后遍历右子树。
    '''
    if root==None:  
        return  
    print(root.value)  
    preTraverse(root.left)  
    preTraverse(root.right)  

def midTraverse(root): 
    '''
    中序遍历：先遍历左子树、然后访问根节点，最后遍历右子树；并且在遍历左右子树的时候。仍然是先遍历左子树，然后访问根节点，最后遍历右子树
    '''
    if root==None:  
        return  
    midTraverse(root.left)  
    print(root.value)  
    midTraverse(root.right)  
  
def afterTraverse(root):  
    '''
    后序遍历：先遍历左子树，然后遍历右子树，最后访问根节点；同样，在遍历左右子树的时候同样要先遍历左子树，然后遍历右子树，最后访问根节点
    '''
    if root==None:  
        return  
    afterTraverse(root.left)  
    afterTraverse(root.right)  
    print(root.value)

 深度优先：

def depth_tree(tree_node):
    if tree_node is not None:
        print(tree_node.data)
        if tree_node._left is not None:
            return depth_tree(tree_node._left)
        if tree_node._right is not None:
            return depth_tree(tree_node._right)

广度优先：

def level_queue(root):
    if root is None:
        return
    my_queue=[]
    node =root
    my_queue.append(node)
    while my_queue:
        node=my_queue.pop(0)
        print(node.elem)
        if node.lchild is not None:
            my_queue.append(node.lchild)
        if node.rchild is not None:
            my_queue.append(node.rchild)