数据结构——排序和查找

递归时间复杂度的计算:

数据结构——排序和查找_第1张图片

知道一般递归的时间复杂度为O(nlogn)

写递归方法时一定要注意出口条件,否则会一直递归下去

 

排序

1、快速排序:最好的排序算法,递归实现

选用数组的第一个数,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面(一趟排序)

交换ki和kj

 

①找中间值,数据分为两部分

②小于中间值数据放左边,大于中间值数据放右边,再用步骤①处理左右两边数据

具体步骤:

1、取第一个数为k,从左向右找大数kj,从右向左找小数ki

若大数位置在小数前面,交换ki和kj位置,继续1步骤

若大数位置在小数后面,交换kj和基数位置,然后继续1步骤

数据结构——排序和查找_第2张图片

时间复杂度:

一趟排序后,有一个元素被放在正确的位置上

不是稳定排序法(时间复杂度没有弄明白?):

在最差情况下,划分之后一边是一个,一边是n-1个。划分由 n 个元素构成的数组需要进行 n 次比较(每次交换大数和小数后重新开始遍历数组)和 n 次移动。因此划分所需时间为 O(n)  。该算法需要 (n-1)+(n-2)+…+2+1= O(n^2) 时间。

在最佳情况下,每次主元将数组划分为规模大致相等的两部分。设 T(n) 表示使用快速排序算法对包含 n 个元素的数组排序所需的时间,因此,和归并排序的分析相似,快速排序的 T(n)= O(nlogn)。(递归的时间复杂度)

程序实现:

①比较暴力的方法:递归实现,左边部分+第一个元素+右边部分

def quicksort(lis):
    if len(lis)<2:
        return lis#只有一个元素时,直接返回该元素
    else:
        base=lis[0]#设置第一个元素为比较元素,即基元素
        left_part = [i for i in lis[1:] if i < base]  # 这里的索引值必须从1开始
        right_part = [j for j in lis[1:] if j >= base]
        '''
        left_part=[i for i  in range(1,len(lis)) if i=base]
                '''
    return quicksort(left_part)+[base]+quicksort(right_part)

lis=[3,6,2,9,8]
print(quicksort(lis))

这个错误之前肯定犯过很多次,列表在不需要索引的情况下可以用lis[0:]来进行遍历

这个算法暴力在增加了空间复杂度,每次的left_part和right_part都需要空间来存储

②改进方法:对应上面的解释过程(视频讲解程序没有实现出来)

不使用中间变量怎么交换数据

lis=1
base=2
# base,lis=lis,base#一行写是交换数据,输出结果为2 1
base=lis#两行写是赋值,最后输出结果为1 1
lis=base
print(lis,base)

 

2、冒泡排序(相邻交换,一次扫描完后,最后一个值一定是最大的)

两元素窗口不断向后移动,窗口中前面元素大于后面元素则交换元素位置。窗口走第一趟,最右边的元素变为最大,窗口走第二趟只需要走到倒数第二个元素,则倒数第二个元素变为最大

核心:比较元素大小

时间复杂度:

最坏情况:按照从大到到小的顺序排列,第一趟比较n-1次(交换n-1次),第二趟比较n-2次……(n-1)+(n-2)+……+2+1=n(n-1)/2,所以时间复杂度为O(n^2)

最好情况:当数据本来就排序好,走一趟不需要数据交换时,只需要比较n-1即可,时间复杂度为O(n)

程序实现:

def bubbleSort(nums):
    for i in range(len(nums)-1):    # 这个循环负责设置冒泡排序进行的次数
        for j in range(len(nums)-i-1):  # 每次扫描完,下一次扫描比较的次数会少一次,所以需要减去i
            if nums[j] > nums[j+1]:
                nums[j], nums[j+1] = nums[j+1], nums[j]
    return nums

nums = [5,2,45,6,8,2,1]

print(bubbleSort(nums))

为什么当时自己脑子一片空白,原因:自己随便写一个列表出来啊!

 

 

3、堆排(堆积排序,是一种完全二叉树)看不懂?

在这里要注意区分堆和堆栈,堆表示二叉树

数据结构——排序和查找_第3张图片

数据结构——排序和查找_第4张图片

数据结构——排序和查找_第5张图片

用数组实现堆,没有用到二叉树

数据结构——排序和查找_第6张图片

如何将一个列表构造成大根堆:

拿到一个列表,肯定是乱序的。现在需要比较节点值,调整元素位置。一个for循环就可以将列表顺序调整为大根堆的顺序(这个顺序在堆中是从大到小的,但是在列表中不是)

需要将堆顶元素取出后,继续将列表转为大根堆

 

有孩子的最大索引值为len(lis)//2

https://www.jianshu.com/p/d174f1862601详细链接

 

选择排序(找最小值交换):依次选出最小值放在最前面

时间复杂度:因为需要找最小/大值,因此需要比较次数(n-1)+(n-2)+……+2+1=n(n-1)/2,所以时间复杂度为O(n^2)

比如有7个元素

for i in range(7):

   for j in range(i+1,8):

        if data[i]>data[j]

            data[i]=data[j]

            data[j]=data[i]

堆排是选择排序的改进版,减少选择排序中的比较次数

堆排用堆积树完成排序的,堆积树的节点值大于左右子节点值,根节点值最大(分为最小堆和最大堆,最小堆的根节点值最小)

数组二叉树(每层从左往右写的顺序将数组转化为二叉树)转化为堆积树:

每一层之间的值不比较,而是层与上一层值比较,若子节点值比节点值大,交换位置,再将交换位置的值与上上层的节点值比较,直到与根节点值比较为止

时间复杂度O(nlogn)

数据结构——排序和查找_第7张图片

最快的平均比较次数为nlogn,nlogn的曲线图介于n^2和n之间

 

归并排序:while循环

两个有序数组使归并结果元素从小到大排序(注意两个数组已经是有序的)

lis_a=[1,3,5,7]
lis_b=[2,4,6,8,9,10]
a,b=len(lis_a),len(lis_b)

#给两个指针(视频中是这样解释的,新的理解:赋值的变量可以当做指针)
i=j=0
lis=[]

while i

只需要比较a或b次(比较次数为列表长度较短的值),即O(n)

 

其他排序(了解过程)

插入排序:将数组的前两个元素先排好,再将第三个元素插入适当的位置,再继续将后面的元素插入适当位置

显然最差情况O(n^2),最好情况是从大到小的列表时间复杂度为O(n)

 

 

查找(查找数组中是否有某一个元素)

顺序查找:

最后一个元素才是要找的数据,即最差情况需要比较n次,时间复杂度为O(n)

怎么不用排序的方法找出中位数(之前和彭讨论就是说的此方法,还是用的排序的方法)

 

算法稳定与否:

排序后两个键值保持原来的相对前后次序

数据结构——排序和查找_第8张图片

排序后7左任然在7右的左边则是稳定的排序

 

哈希查找:通俗理解就是存在索引值

更具数据可以建立哈希表

 

哈希查找的应用:无序数组中找出和为N的两个数(三个数、四个数)

两个数:

统一用此方法

def getRes_HashMap(nums, target):
    result = []
    for i in range(0,len(nums)-1):#i只能取到最后一个数的前一个数
        if (target - nums[i]) in nums[i + 1:]:
            result.append((nums[i], target - nums[i]))
    return result

三个数和:

第一个指针轮询列表

第二个指针轮询第一个指针后面的列表

判断第三个值是否在第二个指针后面的列表

def Sum3(arr, target):  # 3sum问题
    res = []
    for i in range(0,len(arr)-2):#
        for j in range(i+1,len(arr)-1):
            if(target-arr[i]-arr[j]) in arr[j+1:]:
                res.append((arr[i],arr[j],target-arr[i]-arr[j]))
    print(res)

'''
#去重操作
def Sum3(arr, target):  # 3sum问题
    res = []
    for i in range(0,len(arr)-2):#
        for j in range(i+1,len(arr)-1):
            if(target-arr[i]-arr[j]) in arr[j+1:]:
                temp=[arr[i],arr[j],target-arr[i]-arr[j]]
                temp.sort()
                res.append(tuple(temp))                
    print(list(set(res)))
'''
if __name__ == '__main__':
    arr = [int(i) for i in input().split()]
    target = int(input())
    Sum3(arr, target)

注;

这里有一种特殊情况没有考虑,可能出现重复的情况

-1 0 1 2  -1 -4
0
[(-1, 0, 1), (-1, 2, -1), (0, 1, -1)]所以要进行去重

四个和:三层for循环

def Sum3(arr, target):  # 4sum问题
    res = []
    for i in range(0,len(arr)-3):#4sum问题,是减3,不是减4,索引错了结果肯定是错的
        for j in range(i+1,len(arr)-2):
            for k in range(j+1,len(arr)-1):
                if(target-arr[i]-arr[j]-arr[k]) in arr[k+1:]:
                    temp=[arr[i],arr[j],arr[k],target-arr[i]-arr[j]-arr[k]]
                    temp.sort()
                    res.append(tuple(temp))
    print(list(set(res)))

if __name__ == '__main__':
    arr = [int(i) for i in input().split()]
    target = int(input())
    Sum4(arr, target)

别人面试问到:不使用排序的方法怎么找到一个数组的中位数

你可能感兴趣的:(数据结构)