算法

冒泡算法

a=[1, 2, 6, 22, 44, 12, 4]
for j in range(len(a)):
    for i in range(1, len(a)-j):
        if a[i-1]>a[i]:
            a[i-1], a[i]=a[i], a[i-1]

 快速排序`

items=[10, 33, 34, 3, 1, 2, 4, 5, 77, 29]

def quick_sort(i, j):
    if i>j:
        return
    temp=items[i]
    left=i
    right=j
    while i!=j:
        while items[j]>temp and i<j:
            j-=1                         #有可能大于j?
        while items[i]<=temp and i<j:
            i+=1                      #i, j都是1   #j=0 ,i=1
        items[j], items[i]=items[i], items[j]
    items[left], items[j]=items[j], items[left]

    print(items)
    quick_sort(i=left, j=j-1)            #i=0  j=0   ; i=0, j=-1
    quick_sort(i=j+1, j=right)

quick_sort(i=0, j=len(items)-1)

虽然可以通过归纳法总结出 quick_sort(i=left, j=j-1)的i和j的值以及quick_sort(i=j+1, j=right)中的i和j的值,但是仍存在的问题是我依然不知道是怎么想出来的,递归的方法是怎么相处来的




归并排序

def mergesort(seq):
    if len(seq)<=1:
        return seq
    mid=len(seq)/2
    left=mergesort(seq[:mid])
    right=mergesort(seq[mid:])
    return merge(left, right)

def merge(left, right):
    i=0
    j=0
    result=[]
    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

#seq = [4, 8, 6, 9, 7, 5, 1, 0, 7, -2, 3, -99, 6]
seq = ['d', 'a', 'h', 'g', 'a']
print (mergesort(seq))

堆排序

#二叉堆
#最大堆 (父结点的键值总是大于或等于任何(这里的任何一个节点指的是父节点下的子节点)一个子节点的键值)
#最小堆 (父结点的键值总是小于或等于任何(这里的任何一个节点指的是父节点下的子节点)一个子节点的键值)
class BinHeap:
    def __init__(self):
        self.heapList = [0]
        self.currentSize = 0

    def percUp(self, i):
        #从第一层开始
        while i//2>0:
            if self.heapList[i//2]>self.heapList[i]:
                self.heapList[i//2], self.heapList[i]=self.heapList[i], self.heapList[i//2]
            i //= 2

    def percDown(self, i):
        while (i * 2) <= self.currentSize:
            print(u"i的值是{0}".format(i))
            mc = self.minChild(i)
            print (u'mc的值是{0}'.format(mc))
            if self.heapList[i] > self.heapList[mc]:
                tmp = self.heapList[i]
                self.heapList[i] = self.heapList[mc]
                self.heapList[mc] = tmp
            i = mc
            print (u'二叉堆的值是{0}'.format(Btree.heapList))#这一步是怎么来的


    # def percDown(self, i):
    #     """
    #     自上而下
    #     """
    #     while self.currentSize >= (2*i):
    #         mc=self.minChild(i)
    #         if self.heapList[i]>self.heapList[mc]:
    #             self.heapList[i], self.heapList[mc] = self.heapList[mc], self.heapList[i]
    #         i=mc


    def minChild(self, i):
        if self.currentSize<(2*i+1):
            return 2*i
        else:
            if self.heapList[2*i] > self.heapList[2*i+1]:
                return 2*i+1
            else:
                return 2*i

    def insert(self, x):
        self.heapList.append(x)
        self.currentSize+=1
        self.percUp(self.currentSize)

    def delMin(self):
        del_element=self.heapList[1]
        self.heapList[1]=self.heapList[self.currentSize]
        self.currentSize=self.currentSize-1
        self.heapList.pop()
        self.percDown(1)
        return del_element

    def buildHeap(self, alist):
        i = len(alist) // 2
        self.currentSize = len(alist)
        self.heapList = [0] + alist[:]
        while i > 0:
            self.percDown(i)
            i -=1


Btree=BinHeap()
Btree.insert(4)
Btree.insert(6)
Btree.insert(7)
Btree.insert(9)      #这里存在疑问
Btree.insert(10)
Btree.insert(15)     #这里可以改成11,15
Btree.insert(12)
Btree.insert(13)
Btree.insert(14)

print ("原来的数值{0}".format(Btree.heapList))
print (Btree.delMin())
print ('后来的数值{0}'.format(Btree.heapList))

Btree.buildHeap([2, 32, 4, 23, 3, 56, 11])
print ('新建数值{0}'.format(Btree.heapList))