查找与排序练习

经典排序算法详解

最新推荐文章于 2024-06-09 21:33:55 发布

原创最新推荐文章于 2024-06-09 21:33:55 发布 · 176 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

10 篇文章

订阅专栏

二分查找

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        low = 0
        height = len(nums)-1
        while low <=height:
            mid = (low+height)//2
            if nums[mid] < target:
                low = mid + 1
    
            elif nums[mid] > target:
                height = mid - 1
    
            else:
                return mid
        return -1
s=Solution()
List=[1,2,3,4,5,6,7,8,9]
k=6
print(s.search(List,k))

初始条件：left = 0, right = length-1
终止：left > right
向左查找：right = mid-1
向右查找：left = mid+1
确定分半：mid=(right+left)//2(python中，向下取整）

快速排序

"""
一、介绍
    通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
    然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
二、步骤
    递归实现
"""


def quick_sort(nums, start, end):
    if start >= end:
        return
    pivot = nums[start]  # 基准值
    low = start  # 左指针
    high = end  # 右指针
    while low < high:
        while low < high and nums[high] >= pivot:
            high -= 1
        nums[low] = nums[high]

        while low < high and nums[low] < pivot:
            low += 1
        nums[high] = nums[low]
    nums[low] = pivot
    quick_sort(nums, start, low - 1)
    quick_sort(nums, low + 1, end)


if __name__ == '__main__':
    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    quick_sort(nums, 0, len(nums) - 1)
    print(nums)

归并排序

"""
一、介绍
   基本思想：
   将数组array[0,...,n-1]中的元素分成两个子数组：array1[0,...,n/2]
   和array2[n/2+1,...,n-1]。分别对这两个数组单独排序，然后将已排序的
   两个子数组归并成一个含有n个元素的有序数组
二、步骤
    递归实现
三、时间复杂度：O(N*logN)
四、归并排序的两点改进
    * 在数组长度比较短的情况下，不进行递归，而是选择其他排序方案，如插入排序
    * 归并过程中，可以用记录数组下标的方式代替申请新内存空间；从而避免array和
      辅助数组间的频繁数据移动
"""


def merge(left, right):  # 合并两个有序数组
    l, r = 0, 0
    result = []
    while l < len(left) and r < len(right):#
        if left[l] <= right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result


def merge_sort(nums):
    if len(nums) <= 1:
        return nums
    num = len(nums) >> 1
    left = merge_sort(nums[:num])
    right = merge_sort(nums[num:])
    return merge(left, right)


# ------------------- 按第二个改进的修改----------------------------

temp = [0] * 100


def Merge(nums, low, mid, high):
    i = low
    j = mid + 1
    size = 0
    while i <= mid and j <= high:
        if nums[i] < nums[j]:
            temp[size] = nums[i]
            i += 1
        else:
            temp[size] = nums[j]
            j += 1
        size += 1
    while i <= mid:
        temp[size] = nums[i]
        size += 1
        i += 1
    while j <= high:
        temp[size] = nums[j]
        size += 1
        j += 1
    for i in range(size):
        nums[low + i] = temp[i]


def Merge_sort(nums, low, high):
    if low >= high:
        return
    mid = (low + high) >> 1
    Merge_sort(nums, low, mid)
    Merge_sort(nums, mid + 1, high)
    Merge(nums, low, mid, high)


if __name__ == '__main__':
    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    Merge_sort(nums, 0, len(nums) - 1)
    print(nums)

计数排序

'''
计数排序
一、介绍
计数排序是一种线性排序算法，不用比较元素的大小。
待排序序列中元素都是整数，且在0~k之间，k为整数。
稳定性强，
二、时间复杂度为O(n+k)，n为输入元素个数，k为待排序列中最大的数。
局限性大，只限于对整数进行排序。
通过消耗空间复杂度来获取快捷的排序，空间复杂度为O(k)。
'''
def CountSort(nums):
    tmp=[0]*(max(nums)+1)
    sortednums=[]
    for i in range(len(nums)):
        tmp[nums[i]]+=1
    for i in range(len(tmp)):
        if tmp[i]!=0:
            sortednums.append(i)
            tmp[i]-=1
        else:
            continue
    return sortednums
nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]            
CountSort(nums)

冒泡排序

"""
------------------------------- 冒泡排序 --------------------------------------
一、介绍
    冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，
    如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数
    列已经排序完成。
二、步骤
    比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
    对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
    针对所有的元素重复以上的步骤，除了最后一个。
    持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
"""


def bubble_sort(nums):
    for j in range(len(nums) - 1, 0, -1):  # j的取值是[len(alist)-1,len(alist)-2,.....,1]
        # j 表示每次遍历需要比较的次数，是逐渐减小的
        for i in range(j):
            if nums[i] > nums[i + 1]:
                nums[i], nums[i + 1] = nums[i + 1], nums[i]


if __name__ == '__main__':
    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    bubble_sort(nums)
    print(nums)

堆排序

"""
------------------------------- 堆排序 --------------------------------------
一、介绍
    堆排序是一种树形选择排序，是对直接选择排序的有效改进。
二、思想：初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个 堆，
    这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。
    依此类推，直到只有两个节点的堆，并对 它们作交换，最后得到有n个节点的有序序列。从算法描述来看，
    堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。
    一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
三、堆的知识点：
     堆的定义下：具有n个元素的序列 （h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1） (i=1,2,...,n/2)时称之为堆。
     在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。
     完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
"""


#  调整堆,把最大值调整到堆顶
def adjust_heap(nums, i, size):
    lchild = 2 * i + 1
    rchild = 2 * i + 2
    max = i
    if i < size / 2:
        if lchild < size and nums[lchild] > nums[max]:
            max = lchild
        if rchild < size and nums[rchild] > nums[max]:
            max = rchild
        if max != i:
            nums[max], nums[i] = nums[i], nums[max]
            adjust_heap(nums, max, size)


# 创建堆
def build_heap(lists, size):
    for i in range(0, (size >> 1))[::-1]:
        adjust_heap(lists, i, size)


# 堆排序
def heap_sort(lists):
    size = len(lists)
    build_heap(lists, size)
    for i in range(0, size)[::-1]:
        lists[0], lists[i] = lists[i], lists[0]
        adjust_heap(lists, 0, i)
    return lists


if __name__ == '__main__':
    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    result = heap_sort(nums)
    print(result)

选择排序

"""
------------------------------- 选择排序 --------------------------------------
一、介绍
    选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，
    存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
    以此类推，直到所有元素均排序完毕。
二、步骤
    选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，
    它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换
    去移动元素的排序方法中，选择排序属于非常好的一种。
"""


def selection_sort1(nums):
    # 思路是将最小值逐一选择到前面
    n = len(nums)
    for i in range(n - 1):
        min_index = i  # 记录最小值的位置
        for j in range(i + 1, n):
            if nums[j] < nums[min_index]:
                min_index = j
        if min_index != i:
            nums[i], nums[min_index] = nums[min_index], nums[i]


def selection_sort2(nums):
    # 思路是将最大值逐一选择到后面
    n = len(nums)
    for i in range(n - 1, 0, -1):
        max_index = i  # 记录最大值的位置
        for j in range(i):
            if nums[j] > nums[max_index]:
                max_index = j

        if max_index != i:
            nums[i], nums[max_index] = nums[max_index], nums[i]


if __name__ == '__main__':
    nums = list(range(31,0,-1))
    selection_sort2(nums)
    print(nums)

插入排序

"""
------------------------------- 插入排序 --------------------------------------
一、介绍
    插入排序（英语：Insertion Sort）是一种简单直观的排序算法。
二、步骤
    通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
    插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
"""


def insert_sort(nums):
    for i in range(1, len(nums)):
        for j in range(i, 0, -1):
            if nums[j] < nums[j - 1]:
                nums[j], nums[j - 1] = nums[j - 1], nums[j]


if __name__ == '__main__':
    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    insert_sort(alist)
    print(alist)

希尔排序

"""
------------------------------- 希尔排序 --------------------------------------
一、介绍
    希尔排序（Shell Sort）也是插入排序的一种。也称为缩小增量排序，是直接插入排序算法的一种更高效的改进版本。
    希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。
二、步骤
    将待排序列划分为若干组，在每一组内进行插入排序，以使整个序列基本有序，然后再对整个序列进行插入排。
"""


def shell_sort(nums):
    size = len(nums)
    gap = size >> 1
    while gap > 0:
        for i in range(gap, size):
            j = i
            while j >= gap and nums[j - gap] > nums[j]:
                nums[j - gap], nums[j] = nums[j], nums[j - gap]
                j -= gap
        gap = gap >> 1


if __name__ == '__main__':
    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    shell_sort(nums)
    print(nums)