数据结构--排序算法总结

def bubbleSort(array):
    flag  = False
    length = len(array)
    for i in range(length):
        for j in range(length-i-1):
            if array[j]>array[j+1]:
                temp = array[j]
                array[j] = array[j+1]
                array[j+1] = temp
                flag = True
        if flag==False:
            break
    return array

冒泡排序算法，稳定的排序算法、原地排序算法（空间复杂度为O(1)）.一个数组的逆序度最大为n*(n-1)/2.

def selectSort(array):
    length = len(array)
    for i in range(length-1):
        little = i
        for j in range(i+1,length):
            if array[j]<array[little]:
                little = j
        if little!=i:
            temp = array[i]
            array[i] = array[little]
            array[little] = temp
    return array
选择排序，最坏、最好、平均时间复杂度均是O（n2）

def insertionSort3(array):
    length = len(array)
    for i in range(1,length):
        temp = array[i]
        j = i-1
        while j>=0:
            if array[j]>temp:
                array[j+1] = array[j]
            else:break
            j-=1
        array[j+1] = temp
    return array

插入排序，最好时间复杂度O（n）,最坏和平均时间复杂度为O（n2）

插入排序、选择排序、冒泡排序空间复杂度为O（1），其中冒泡排序、插入排序是稳定排序。

def binary_search(array,value):
    length = len(array)
    low = 0
    high = length-1
    while low <= high:
        mid = (high-low)//2 + low
        if array[mid] == value:
            return mid
        elif value <array[mid]:
            high = mid-1
        else:
            low = mid+1
print(binary_search([1,3,5,7,8,10,11],11))
#二分查找时间复杂度O（logN），空间复杂度O（1）

#二分查找递归实现
def bsearchInternally(array,low,high,value):
    if low > high:
        return -1
    mid = low + ((high-low)>>1)
    if array[mid] == value:
        return mid
    elif array[mid] < value:
        return bsearchInternally(array,mid+1,high,value)
    else:
        return bsearchInternally(array,low,mid-1,value)
def bsearch(array,n,value):
    return bsearchInternally(array,0,n-1,value)


aa = bsearch([1,3,5,7,8,10,11],7,11)

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def binarySearch(self,array,value):
        length = len(array)
        low = 0
        high = length-1
        while low <= high:
            mid = ((high-low)//2)+low
            if array[mid] == value:
                return mid
            elif array[mid]<value:
                low = mid+1
            else:
                high = mid-1
        return -1
    def Find(self, target, array):
        rows = len(array)
        colunms = len(array[0])
        for row in range(rows):
            #每一行array[row],一个有序数组，二分查找
            temp = self.binarySearch(array[row],target)
            if temp !=-1:
                return True
        return False

def merge(left,right):
    ans = []
    i,j = 0,0
    while i < len(left) and j <len(right):
        if left[i]<right[j] :
            ans.append(left[i])
            i+=1
        else:
            ans.append(right[j])
            j += 1
    if j==len(right):
        ans.extend(left[i:])
    else:
        ans.extend(right[j:])
    return ans


def mergeSort(data):
    if len(data)>=2:
        mid = len(data)//2
        left = mergeSort(data[:mid])
        right = mergeSort(data[mid:])
        return merge(left,right)
    else:
        return data
# print(mergeSort([1, 2, 3, 4, 5, 6, 7, 90, 21, 23, 45]))

#判断链表是否有环，快慢指针法
class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if head == None or head.next == None:
            return False
        slow = fast = head
        while fast and fast.next:
            slow = slow.next #慢指针一次一步
            fast = fast.next.next#快指针一次两步
            if slow == fast:#相遇时，刚好慢的走一圈，快的走两圈
                return True
        return False