1、顺序查找

查找算法是程序中经常用到的算法。如果要从n个元素中查找 x 是否存在，最原始的方法是从头到尾挨个查找，这种查找的方法叫顺序查找方法。

优点：不需要内容有序，一个一个查找。

缺点：查找效率低，不适合大数据 ，假设数据的总个数为n，则计算复杂度为n/2

顺序查找有三种情形发生：第一项就是要查找的数据对象，只需一次查找即可完成，也是最理想的情况；最差的情况，需要 n 次比较，全部比较完之后找不到数据。平均情况下，比较次数为 n/2 次。算法的时间复杂度是 O(n) .

def sequest(List,target):
    pose = 0 #初始查找位置
    while pose < len(List):
        if List[pose] == target:#找到数据对象
            return target #返回目标数据 并终止循环 ..return执行后，函数终止
        else:  
            pose = pose + 1
    return False #没找到数据对象
testlist=[1,3,5,6,7,8,9,23,44,]
print(sequest(testlist,11))

如果在列表中查找最大、最小值，就把列表中的第一个元素假设定为最大值，最小值

def Max_data(List):
    pose = 0 #初始位置
    imax = List[0] #假设第一个元素为最大值
    while pose < len(List):#循环条件
        if List[pose]>imax: #若列表中的当前值大于假设最大值
            imax = List[pose]#则把当前值赋予给最大值
        else:
            pose += 1
    return imax #返回最大值
test=[2,4,1,6,7,3,9,10,32,11,67]
Max_data(test)

def Min_data(List):
    pose = 0 #初始位置
    imin = List[0] #假设第一个元素为最小值
    while pose < len(List):#循环条件
        if List[pose]<imin: #若列表中的当前值小于假设最小值
            imin = List[pose]#则把当前值赋予给最小值
        else:
            pose += 1
    return imin #返回最小值
test=[2,4,1,6,7,3,9,10,32,11,67,1]
Min_data(test)

2、折半查找

搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半、

折半查找法是效率较高的一种查找方法。假设有已经按照从小到大的顺序排列好的五个整数A0~A4，要查找的数是X，其基本思想是： 设查找数据的范围下限为l=0，上限为h=4，求中点m=（l+h）/2，用X与中点元素Am比较，若X等于Am，即找到，停止查找；否则，若X大于Am，替换下限l=m+1，到下半段继续查找；若X小于Am，换上限h=m-1，到上半段继续查找；如此重复前面的过程直到找到或者l>h为止。如果l>h，说明没有此数，打印找不到信息，程序结束。

def binary(List,key,left,right):#List目标列表，key目标数据，left列表索引左下标，right列表索引右下标 
    List.sort() #对列表进行升序排序
    if left > right:#查找失败
        return -1
    mid = (left + right)//2
    if List[mid] < key:
        left = mid+1
        return binary(List,key,left,right)#再次调用函数
    elif List[mid] > key:
        right = mid -1
        return binary(List,key,left,right)
    else:
        return mid
value = [3,9,10,12,25,34,45,56,67,76,84,99]
result = binary(value,25,0,len(value)-1)
if result == -1:
    print('查找失败')
else:
    print('查找成功，对应下标为',result)

3、冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

def BubbleSort(las):
    n = len(las) 
    for i in range(n): #遍历所有数组元素
        for j in range(0,n-i-1):
            if las[j] > las[j+1]:#进行元素比较
                las[j],las[j+1] = las[j+1],las[j]
                print(las)#打印每一次排序结果
las = [43,12,56,34,78,98]
BubbleSort(las)
print('排序后的数组：')
for i in range(len(las)):
    print('%d'%las[i])

4、选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

def SelectionSort(lis):          
    count = len(lis)
    for i in range(count):#主要用列表索引来完成排列
        Min_data = i #把列表第一个值假定为最小值
        for j in range(i+1,count):  #开始从列表的第二个元素比较
            if lis[Min_data] > lis[j]:#如果列表的第一个假定的值大于列表的第二个元素的值，就互换位置
                Min_data = j
        lis[i],lis[Min_data] = lis[Min_data],lis[i]
    print(lis)
a = [5,4,9,2,1,0]
SelectionSort(a)