Day 03 选择排序链表数组递归和栈

最新推荐文章于 2024-10-07 15:43:52 发布

A1L__

最新推荐文章于 2024-10-07 15:43:52 发布

阅读量142

点赞数

分类专栏： Leetcode打卡文章标签：数据结构 python 算法

本文链接：https://blog.csdn.net/A1L__/article/details/108049588

版权

Leetcode打卡专栏收录该内容

7 篇文章 0 订阅

订阅专栏

二、选择排序

2.1内存工作的原理

需要将数据存储到内存时，你请求计算机提供存储空间，计算机给你一个存储地址。需要存储多项数据时，有两种基本方式——数组和链表。

2.2数组和链表

2.2.1 链表

链表中的元素可存储在内存的任何地方。

链表的每个元素都存储了下一个元素的地址，从而使一系列随机的内存地址串在一起。

链表的优势在于插入元素方面，需要同时读取所有元素时，链表的效率很高。

链表的缺点：在读取链表的最后一个元素时，你不能直接读取，因为你不知道他所处的地址，必须先访问元素1，然后元素2…直到访问最后一个元素。跳跃读取的话链表的效率就很低。

当需要在中间插入元素时，链表是更好地选择。

删除元素时链表也是更好地选择，因为只需修改前一个元素的指向地址就可以了，二使用数组时，删除元素后，必须将后面的元素都向前移。

通常我们都记录了链表的第一个元素和最后一个元素，因此删除这些元素时的运行时间为O（1）

2.2.2 数组

数组知道其中每个元素的地址。需要随机读取元素时，数组的效率很高，因为可以迅速找到数组中的任何元素。在链表中，元素并非靠在一起的，你无法迅速计算出第五个元素的内存地址，而必须先访问第一个元素以获得第二个元素的地址，在访问第二个元素以获得第三个元素的地址，以此类推，直到访问第五个元素。

通常情况下数组用的多，因为他支持随机访问。顺序访问：从第一个元素开始逐个的读取元素。链表只能顺序访问！随机访问意味着可以直接跳到要访问的元素上。所以支持随机访问的数组读取速度更快！

2.2.3 术语

数组的元素带编号，编号从0开始而不是从1开始，主要是从0开始觊觎数组的代码编写起来更容易，因此程序员始终坚持这样做。几乎所有的编程语言都从0开始对数组进行编号。

元素的位置称为索引，用索引表示位置。

2.2.4 删除

删除元素总能成功，因为是释放内存，如果没有足够的内存，插入操作可能失败，但任何情况下都能将元素删除。

选择排序

方法一、

# 选择排序

# 获取数组中的最小
import time


def findSmallest(arr):
    smallest = arr[0]  # 可以是数组中的任意一个元素
    smallest_index = 0  # 元素的索引
    for i in range(1, len(arr)):  # 遍历数组中的元素
        if arr[i] < smallest:
            smallest = arr[i]  # 最小元素换绑定名
            smallest_index = i  # 最小元素 索引换绑定名
        return smallest_index  # 返回索引名


def selectionSort(arr):
    start = time.time()
    newArr = []
    for i in range(len(arr)):
        smallest = findSmallest(arr)
        newArr.append(arr.pop(smallest))
    end = time.time()
    print(f"find运行时间： {end - start}")
    return newArr

方法二、

def selectSort(arr):
    start = time.time()
    newArr = []
    newArr.append(min(arr))
    end = time.time()
    print(f"min运行时间： {end - start}")
    return newArr

arr = [i for i in range(999999)]
res2 = selectionSort(arr)[:9]
res1 = selectSort(arr)[:9]
print(res1, res2)

在速度上方法一远远没有方法二快，但是可以做为初学的一种方式，我们知道min其实是一种迭代器，将数组中两个元素作对比。

小结

计算机内存犹如一大堆抽屉。
需要存储多个元素时，可使用数组或链表
数组的元素都在一起
链表的元素是分开的，其中每个元素都存储了下一个元素的地址。
数组的读取速度很快
链表的插入和删除速度很快
在同一个数组中，所有元素的类型都必须相同（都为int、double等）。

三、递归

如果使用循环，程序的性能可能更高；如果使用递归，程序可能更容易理解。如何选择要看什么对你来说更重要。

基线条件和递归条件

由于递归函数调用自己，因此编写这样的函数容易出错，进而导致无限循环。所以编写递归时，必须告诉他何时停止递归。正因如此，每个地柜函数都有两部分：基线条件和递归条件。递归条件指的是函数自己调用自己，而基线条件则指的是函数不在调用自己，从而避免无限循环。

For example

def add(i, result=0):
    result += i
    # print(result)
    if i <= 0:  # 基线条件
        return
    else:  # 递归条件
        return (add(i - 1, result=result))

add(88)

调用栈

栈是拥有插入和弹出操作的数据结构

计算机在内部使用被称为调用栈的栈。我们来看看计算机是如何使用调用栈的。下面是一个简单地函数。

def greet2(name):
    print(f"how are you {name}?")


def bye():
    print("ok bye!")


def greet(name):
    print(f"hello {name}!")
    greet2(name)
    print("nice to meet you!")
    bye()

我们知道每次定义一个函数，都会在内存中生成一个名称空间，每调用一次函数都会执行里面的代码，函数里调用涉及的所有变量的值存储到内存中。我们运行greet(superme)，打印hello superme,再调用greet2(superme)。同样，计算机也为这个函数调用分配了一块内存。

计算机使用一个栈来表示这些内存块，其中第二个内存块位于第一个内存块上面（greet2(superme)在greet(superme)上面）,当greet2(superme)运行完毕(调用返回

),此时栈顶的内存被弹出。

现在栈顶的内存是greet(superme)，此时greet(superme)函数还未运行完毕，还在栈底（第一个栈），然后运行nice to meet you,执行bye函数，栈顶加载bye的内存块。最终运行完bye，返回到greet函数，完成整个函数的返回。这个栈用于存储多个函数的变量，称为调用栈

递归调用栈

递归函数也使用调用栈，下面是计算阶乘的递归函数

def fact(x):
    if x == 1:
        return 1
    else:
        return x * fact(x - 1)


result = fact(3)
print(result)

下面详细分析调用fact(3)时调用栈是如何变化的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TksSORYQ-1597628982460)(C:%5CUsers%5CS%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20200815230406416.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u0tYGOwI-1597628982463)(C:%5CUsers%5CS%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20200815230511472.png)]

注意每个fact调用都有自己的x变量。在一个函数调用不能访问另一个的x变量。

栈在递归中扮演着重要的角色。