Python篇——数据结构与算法（第一部分）

 

目录

一、查找

1、顺序查找：也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止。

2、二分查找：也叫折半查找，从有序列表的初始候选区li[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。

二、排序

1、冒泡排序（原地排序）

2、选择排序 

3、插入排序

4、快速排序

---

一、查找

查找：在一些数据元素中、通过一定的方法找出与给定关键字相同数据元素的过程

列表查找（线性表查找）：从列表中查找指定元素

        输入：列表、待查找元素

        输出：元素下标（未找到元素时一般返回None或-1）

内置列表查找函数：index（）（底层就是顺序查找，因为二分查找需要有序列表）

1、顺序查找：也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止。

 顺序查找例子：

def linea_search(li, val):
    for index, v in enumerate(li):
        if v == val:
            return index
    else:
        return None
        # print(index)
        # print(v)


if __name__ == '__main__':
    line = linea_search([1, 2, 3, 4, 5, 6, 7], 7)
    print(line)

2、二分查找：也叫折半查找，从有序列表的初始候选区li[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。

 二分查找例子：

def binary_search(list, val):
    left = 0
    right = len(list) - 1
    while left <= right:
        mid = (left + right) // 2
        if list[mid] == val:
            return mid
        elif list[mid] > val:
            right = mid - 1
        else:
            left = mid + 1
    else:
        return None


if __name__ == '__main__':
    a = binary_search([1, 2, 3, 4, 5, 6], 3)
    print(a)

二、排序

• 什么是列表排序
• 常见排序算法
• 排序算法分析

排序：将一组“无序”的记录序列调整为“有序”的记录序列

列表排序：将无序列表变为有序列表

        输入：列表

        输出：有序列表

升序（小到大）、降序（大到小）

内置排序函数：sort（）

常见排序算法：

冒泡排序、选择排序、插入排序

快速排序、堆排序、归并排序

希尔排序、计数排序、基数排序

1、冒泡排序（原地排序）

• 列表每相邻的两个数，如果前面的比后面的大，则交换这两个数

• 一趟排序完成后，无序区少一个数，有序区多一个数

import random


def buffer_search(n):
    for i in range(len(n) - 1):  # 趟数
        exchange = False
        for j in range(len(n) - i - 1):
            if n[j] > n[j + 1]:
                n[j], n[j + 1] = n[j + 1], n[j]
                exchange = True
            else:
                exchange = False
        if not exchange:
            break
        print(n)


if __name__ == '__main__':
    # li = [random.randint(0, 10000) for i in range(10)]
    # print("len(li):", len(li))
    # print(li)
    # buffer_search(li)
    # print(li)

    li2 = [9, 8, 7, 1, 2, 3, 4, 5, 6]
    buffer_search(li2)

Note：

• 整个冒泡排序只需要走n-1躺，因为最后剩下的一定是最小的
• 代码关键点：趟数、无序区范围
• 趟数n-1
• 第一趟可以确定一个数到有序区，那么无序区范围是n-i-1，还剩n-i个数
• 复杂度O（n^2）
• 改进点：如果列表中没有发生数字的交换、那么就是已经排好序了，例如： li2 = [9, 8, 7, 1, 2, 3, 4, 5, 6]

2、选择排序 

• 每一趟选择一个最小的放入新列表

def select_search_1(li):
    li_new = []
    for i in range(len(li)):
        min_val = min(li)
        li_new.append(min_val)
        li.remove(min_val)
    return li_new

缺点：remove（）操作和min（）操作，增大了开销，并且增加了一个新列表li_new[]。不是原地排除

改进：

def select_search_2(li):
    '''改进'''
    for i in range(len(li)):
        min_loc = i
        for j in range(i + 1, len(li)):
            if li[j] < li[min_loc]:
                min_loc = j
        li[i], li[min_loc] = li[min_loc], li[i]
        print('i:%s,li:%s', i, li)

•  原地排序，第一趟，找到无序区最小的数与第一个数进行交换位置，第二趟找到无序区最小的数与第二个位置进行交换，以此类推
• 将列表在排序的过程中划分为了有序区和无序区
• 时间复杂度O（n^2）

3、插入排序

• 初始时手里（有序区）只有一张牌
• 每次（从无序区）摸一张牌，插入到自己手里已经有牌的正确位置

 

def inseart_search(list):
    for i in range(1, len(list)):
        temp = list[i]
        j = i - 1
        while j >= 0 and list[j] > temp:
            list[j + 1] = list[j]
            j -= 1
        list[j + 1] = temp
        print(list)

if __name__ == '__main__':
    list = [3, 2, 5, 7, 4, 1, 9, 8, 6]
    inseart_search(list)

Note：

 for i in range(1, len(list)):

•  i 表示摸到的牌的下标

        j = i - 1

•  j指的是手里的牌的下标
• 时间复杂度O（n^2）

4、快速排序

• 快速排序思路：
• 取一个元素p（第一个元素），使元素p归位
• 列表被p分成两部分，左边都比p小，右边都比p大
• 递归完成排序
• 时间复杂度：O（nlogn）
• 快速排序问题：
  • 递归
  • 最坏情况：例如 [9,8,7,6,5,4,3,2,1] 这时候时间复杂度为 O(n^2)
  • 解决思路：随机找一个数与第一个数进行先交换，在进行快速排序。

def partition(list, left, right):
    temp = list[left]  # 存值
    while left < right:
        while left < right and list[right] >= temp:
            right -= 1
        list[left] = list[right]
        while left < right and list[left] <= temp:
            left += 1
        list[right] = list[left]
    list[left] = temp
    return left


def quick_sort(list, left, right):
    if left < right:
        mid = partition(list, left, right)
        quick_sort(list, mid + 1, right)
        quick_sort(list, left, mid - 1)


if __name__ == '__main__':
    list = [3, 2, 5, 6, 8, 9, 1, 7, 4]
    # 单步测试
    # partition(list, 0, len(list) - 1)
    # print(list)
    quick_sort(list, 0, len(list) - 1)
    print(list)