Python 排序和堆的操作

自己自学了点排序和堆的操作，现学现卖，有不好的地方欢迎各路大神指点！
1.二分法

def twojudge(search_list,target):
    left=0
    right=len(search_list)-1
    while left<=right:
        mid=(left+right)//2
        if search_list[mid]<target:
            left=mid+1
            continue
        if search_list[mid]==target:
            return mid
        if search_list[mid]>target:
            right=mid-1
    return None
search_list=[1,3,4,6,8,9]
print(twojudge(search_list,5))
print(twojudge(search_list,1))
print(twojudge(search_list,3))
print(twojudge(search_list,8))

2.插入排序

def insert_sort(origin_list):#原始列表
    sorted_list=[]#重新排序后的列表
    for i in range(0,len(origin_list)):
        if len(sorted_list)==0:
            sorted_list.append(origin_list[i])
            continue
        for j in range(len(sorted_list)-1,-1,-1):
            if sorted_list[j]<=origin_list[i]:
               sorted_list.insert(j+1,origin_list[i])
               break
            if j==0:
                sorted_list.insert(0,origin_list[i])
    origin_list[:]=sorted_list[:]
origin_list=[5,3,1,7,9,8]
insert_sort(origin_list)
print(origin_list)

3.冒泡排序

def bbb_sort(origin_list):
    for i in range(len(origin_list),0,-1):
        for j in range(0,i-1):
            if origin_list[j]>origin_list[j+1]:
                origin_list[j],origin_list[j+1]=origin_list[j+1],origin_list[j]

origin_list=[5,3,1,7,9,8]
bbb_sort(origin_list)
print(origin_list)

4.快速排序

def quick_sort(origin_list,start,end):
    if start>=end:
        return
    left=start
    right=end
    flag_index=left
    while left<right:
        while right>left:
            if origin_list[right]<origin_list[flag_index]:
                origin_list[right],origin_list[flag_index]=origin_list[flag_index],origin_list[right]
                flag_index=right
                break
            right-=1
        while left<right:
            if origin_list[left]>origin_list[flag_index]:
                origin_list[left],origin_list[flag_index]=origin_list[flag_index],origin_list[left]
                flag_index=left
                break
            left+=1
        quick_sort(origin_list,start,flag_index)
        quick_sort(origin_list,flag_index+1,end)
origin_list=[5,3,1,3,7,9,8]
quick_sort(origin_list,0,len(origin_list)-1)
print(origin_list)

5.归并排序

def merge_sort(origin_list,start,end):
    if end<=start:
        return
    mid=(start+end)//2
    merge_sort(origin_list,start,mid)
    merge_sort(origin_list,mid+1,end)
    left_head=start
    right_head=mid+1
    temp_list=[]
    while left_head<=mid and right_head<=end:
        if origin_list[left_head]<origin_list[right_head]:
            temp_list.append(origin_list[left_head])
            left_head+=1
        if origin_list[left_head]>=origin_list[right_head]:
            temp_list.append(origin_list[right_head])
            right_head+=1
    if left_head<=mid:
        temp_list+=origin_list[left_head:mid+1]
    if right_head<=end:
        temp_list+=origin_list[right_head:end+1]
    for i in range(0,len(temp_list)):
        origin_list[i+start]=temp_list[i]

origin_list=[5,3,1,3,7,9,8]
merge_sort(origin_list,0,len(origin_list)-1)
print(origin_list)

6.堆的操作

class Heap(object):
    def __init__(self):
        self.data_list=[1]

    def size(self):
        return len(self.data_list)-1

    def left_child(self,root):
        return root*2

    def right_child(self,root):
        return root*2+1

    def father(self,node):
        return node//2

    def heapify(self,root):#维护堆
        if root>self.size():#如果当前节点的下标大于列表的大小
            return
        left_node=self.left_child(root)
        right_node=self.right_child(root)
        largest=root
        if left_node<=self.size():
            if self.data_list[left_node]>self.data_list[largest]:
                largest=left_node
        if right_node<=self.size():
            if self.data_list[right_node]>self.data_list[largest]:
                largest=right_node
        if largest!=root:
            self.data_list[root],self.data_list[largest]=self.data_list[largest],self.data_list[root]
            self.heapify(largest)

    def build_heap(self):#建堆
        for i in range(self.size()//2,0,-1):
            self.heapify(i)

    def get_max(self):#取堆顶
        if self.size()==0:
            return None
        ret=self.data_list[1]
        self.data_list[1]=self.data_list[-1]
        del self.data_list[-1]
        self.heapify(1)
        return ret

    def insert(self,data):#新增数据
        self.data_list.append(data)
        now_index=self.size()
        pre=self.father(now_index)
        while self.data_list[pre]<data and now_index!=1:
            self.data_list[pre],self.data_list[now_index]=self.data_list[now_index],self.data_list[pre]
            now_index=pre
            pre=now_index//2
heap=Heap()
heap.insert(9)
heap.insert(10)
heap.insert(7)
heap.insert(12)
heap.insert(3)
heap.insert(4)
print(heap.get_max())
print(heap.get_max())
print(heap.get_max())
print(heap.get_max())
print(heap.get_max())
print(heap.get_max())
print(heap.get_max())
heap.insert(10)
heap.insert(9)
heap.insert(8)
heap.insert(7)
heap.insert(7)
heap.insert(12)
print(heap.get_max())
heap.data_list=[None,1,2,3,4,5,6,7,8,9]
heap.build_heap()
print(heap.get_max())