基础算法(python)

分治法-最大子数组问题

def FindMaxCrossingSubarray(A,low,mid,high):
    leftsum=-float('INF')
    su=0
    for i in range(mid,low-1,-1):
        su+=A[i]
        if leftsum<su:
            leftsum=su
            maxleft=i
    rightsum=-float('INF')
    su=0
    for i in range(mid+1,high+1):
        su+=A[i]
        if rightsum<su:
            rightsum=su
            maxright=i
    return (maxleft,maxright,leftsum+rightsum)

def FindMaximumSubarray(A,low,high):
    if low==high:
        return (low,high,A[low])
    else:
        mid=(low+high)/2
        (leftlow,lefthigh,leftsum)=FindMaximumSubarray(A,low,mid)
        (rightlow,righthigh,rightsum)=FindMaximumSubarray(A,mid+1,high)
        (crosslow,crosshigh,crosssum)=FindMaxCrossingSubarray(A,low,mid,high)
    if leftsum>=rightsum and leftsum>=crosssum:
        return (leftlow,lefthigh,leftsum)
    elif rightsum>=leftsum and rightsum>=crosssum:
        return (rightlow,righthigh,rightsum)
    else:
        return (crosslow,crosshigh,crosssum)

归并排序

def MergeSort(A,p,r):
    if p<r:
        q=(p+r)/2
        MergeSort(A,p,q)
        MergeSort(A,q+1,r)
        Merge(A,p,q,r)

def Merge(A,p,q,r):
    L=[];R=[]
    for i in range(q-p+1):
        L.append(A[p+i])
    for i in range(r-q):
        R.append(A[q+1+i])
    i=0;j=0
    L.append(float('INF'));R.append(float('INF'))
    res=[]
    for k in range(p,r+1):
        if L[i]<=R[j]:
            A[k]=L[i]
            i+=1
        else:
            A[k]=R[j]
            j+=1

堆排序

def MaxHeapify(A,i,heapsize):
    left=2*i+1;right=2*i+2
    if left<heapsize and A[left]>A[i]:
        largest=left
    else:
        largest=i
    if right<heapsize and A[right]>A[largest]:
        largest=right
    if largest!=i:
        A[i],A[largest]=A[largest],A[i]
        MaxHeapify(A,largest,heapsize)

def BuildMaxHeap(A,heapsize):
    for i in range((len(A)-1)/2,-1,-1):
        MaxHeapify(A,i,heapsize)

def HeapSort(A):
    heapsize=len(A)
    BuildMaxHeap(A,heapsize)
    for i in range(len(A)-1,0,-1):
        A[0],A[heapsize-1]=A[heapsize-1],A[0]
        heapsize-=1
        MaxHeapify(A,0,heapsize)

快速排序

def Partition(A,p,r):
    x=A[r]
    i=p-1
    for j in range(p,r):
        if A[j]<=x:
            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)

快速排序的Hoare划分

def HoarePartition(A,p,r):
    x=A[r]
    i=p;j=r
    while 1:
        while i<r and A[i]<x:
            i+=1
        while j>p and A[j]>=x:
            j-=1
        if i<j:
            A[i],A[j]=A[j],A[i]
        else:
            A[r],A[i]=A[i],A[r]
            return j

def QuickSort(A,p,r):
    if p<r:
        q=HoarePartition(A,p,r)
        QuickSort(A,p,q)
        QuickSort(A,q+1,r)

快速排序的随机化版本

import random

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

def RandomizedPartition(A,p,r):
    i=random.randint(p,r)
    A[i],A[r]=A[r],A[i]
    return Partition(A,p,r)

def RandomizedQuickSort(A,p,r):
    if p<r:
        q=RandomizedPartition(A,p,r)
        RandomizedQuickSort(A,p,q-1)
        RandomizedQuickSort(A,q+1,r)

计数排序

def CountingSort(A,B,k):
    C=[0 for i in range(k+1)]
    for i in range(len(A)):
        C[A[i]]+=1
    for i in range(1,k+1):
        C[i]+=C[i-1]
    for i in range(len(A)-1,-1,-1):
        B[C[A[i]]-1]=A[i]
        C[A[i]]-=1

选择算法(找第k小的数)

import random

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

def RandomizedPatition(A,p,r):
    i=random.randint(p,r)
    A[r],A[i]=A[i],A[r]
    return Patition(A,p,r)

def RandomizedSelect(A,p,r,i):
    if p==r:
        return A[p]
    q=RandomizedPatition(A,p,r)
    k=q-p
    if i==k:
        return A[q]
    elif i<k:
        return RandomizedSelect(A,p,q-1,i)
    else:
        return RandomizedSelect(A,q+1,r,i-k-1)