01.02数组基础知识

睇唔明

已于 2024-04-21 23:04:49 修改

阅读量861

点赞数 13

文章标签：算法数据结构

于 2024-04-19 23:25:10 首次发布

本文链接：https://blog.csdn.net/weixin_53530135/article/details/137888341

版权

1、数组简介

1.1 数组定义(Array)：一种线性表数据结构。它使用一组连续的内存空间，来存储一组具有相同类型的数据。简而言之，数组是实现线性表的顺序结构存储的基础。

也可以两个方面来解释一下数组的定义。

1）线性表：线性表就是所有数据元素排成像一条线一样的结构，线性表上的数据元素都是相同类型，且每个数据元素最多只有前、后两个方向。数组就是一种线性表结构，此外，栈、队列、链表都是线性表结构。

2）连续的内存空间：线性表有两种存储结构：「顺序存储结构」和「链式存储结构」。其中，「顺序存储结构」是指占用的内存空间是连续的，相邻数据元素之间，物理内存上的存储位置也相邻。数组也是采用了顺序存储结构，并且存储的数据都是相同类型的。

1.2 如何随机访问数组元素

数组的一个最大特点是：可以进行随机访问。即数组可以根据下标，直接定位到某一个元素存放的位置。

寻址公式如下：下标 $i$ 对应的数据元素地址 = 数据首地址 + $i$ × 单个数据元素所占内存大小。

1.3 多为数组

举例二维数组是一个由 m 行 n 列数据元素构成的特殊结构，其本质上是以数组作为数据元素的数组，即 「数组的数组」。二维数组的第一维度表示行，第二维度表示列。

1.4 python语言中数组的实现

原生 Python 中其实没有数组的概念，而是使用了类似 Java 中的 ArrayList 容器类数据结构，叫做列表。通常我们把列表来作为 Python 中的数组使用。Python 中列表存储的数据类型可以不一致，数组长度也可以不一致。例如：

Array = ["1","as","123",["123","ijl"]]

2、数组的基本操作

一般涉及到增、删、改、查共 4 种情况

2.1 访问元素

访问数组中第 $i$ 个元素：

只需要检查 $i$ 的范围是否在合法的范围区间，即 $0 \leq i\leq len(nums) -1$ 。超出范围的访问为非法访问。
当位置合法时，由给定下标得到元素的值。

#从数组nums中找出下标为i的数据元素值

def value(nums, i):
    if 0<= i <= len(nums) -1
        print(nums[i])

arr = [0,4,1,6,7,8]
value(arr, 3)

「访问数组元素」的操作不依赖于数组中元素个数，因此，「访问数组元素」的时间复杂度为 $O(1)$

2.2 查找元素

查找数组中元素值为 $val$ 的位置：

建立一个基于下标的循环，每次将 $val$ 与当前数据元素 $nums[i]$ 进行比较。
在找到元素的时候返回元素下标。
遍历完找不到时可以返回一个特殊值（例如 −1）

# 从数组 nums 中查找元素值为 val 的数据元素第一次出现的位置

def find(nums, val):
    for i in range(len(nums)):
        if nums[i] == val:
            return i
    return -1

arr = [0,2,4,5,1,7]
print(find(arr,5))

此方法也称线性查找，线性查找操作依赖于数组中元素个数，因此「查找元素」的时间复杂度为 $O(n)$

2.3 插入元素

两种[在数组尾部插入 $val$ ]和[对应位置 $i$ 插入元素 $val$ ]

1）在数组尾部插入 $val$

python中的 list 列表直接封装了尾部插入操作，直接调用 append 方法即可

arr = [1,5,7,0,4,9]
val = 5
arr.append[val]
print(arr)

「在数组尾部插入元素」的时间复杂度为 $O(1)$

2) 对应位置 $i$ 插入元素 $val$

先检查插入下标 $i$ 是否合法，即 0≤ $i$ ≤ $len(nums)$
确定合法位置后，通常情况下第 $i$ 个位置上已经有数据了（除非 $i == len(nums)$ ），要把第 $i$ ~ len(nums) - 1 位置上的元素依次向后移动。
然后再在第 $i$ 个元素位置赋值为 $val$ ，并更新数组的元素计数值。

Python 中的 list 列表直接封装了中间插入操作，直接调用 insert 方法即可。

arr = [1,5,7,0,4,9]
i, val = 2, 5
arr.insert(i, val)
print(arr)

「在数组中间位置插入元素」的最坏和平均时间复杂度都是 $O(n)$

2.4 改变元素

将数组中的第i个元素值改为val

1. 首先查找 i 是不是在合法的范围内，及验证 $0\leq i\leq len(nums)-1$

2. 将第i个元素赋值为val

def change(nums, i, val):
    if 0 <= i <= len(val)-1:
        nums[i] = val


nums = [1,2,3,1,7]
i,val = 3,1
change(nums, i, val)
print(nums)

「改变元素」的时间复杂度为 $O(1)$

2.5 删除元素

删除元素分为三种情况：「删除数组尾部元素」、「删除数组第 $i$ 个位置上的元素」、「基于条件删除元素」

1）删除数组尾部元素

Python 中的 list 列表直接封装了删除数组尾部元素的操作，只需要调用 pop 方法即可。

arr = [1,2,3,5,1]
arr.pop()
print(arr)

「删除数组尾部元素」的时间复杂度为 $O(1)$

2）删除数组第 $i$ 个位置上的元素

先检查下标 $i$ 是否合法，即 $0\leq i\leq len(nums)-1$ 。
如果下标合法，则将第 $i$ +1 个位置到第 $len(nums) - 1$ 位置上的元素依次向左移动。
删除后修改数组的元素计数值。

arr = [1,2,3,15,21,12]
i = 3
arr.pop(i)
print(arr)

「删除数组中间位置元素」的最坏和平均时间复杂度都是 $O(n)$

3）基于条件删除元素

一般不给定被删元素的位置，而是给出一个条件要求删除满足这个条件的（一个、多个或所有）元素。这类操作也是通过循环检查元素，查找到元素后将其删除。

#删除数组中第1个val
arr = [0,8,5,7,4]
arr.remove(8)
print(arr)

「基于条件删除元素」的最坏和平均时间复杂度都是 $O(n)$

Leecode Day3

0066 加1

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        digits = [0] + digits
        digits[len(digits)-1] = digits[len(digits)-1] + 1
        for i in range(len(digits)-1, 0, -1 ):
            if digits[i] != 10:
                break
            else:
                digits[i] = 0
                digits[i-1] = digits[i-1] + 1
        if digits[0] == 0:
            return digits[1:]
        else:
            return digits

0724 寻找数组的中心下标

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        leftsum = 0
        for i in range(len(nums)): 
            rightsum = sum(nums[i+1:len(nums)])
            if leftsum == rightsum:
                return i 
            leftsum += nums[i]
        return -1

0189 轮转数组

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        k = k % n
        self.reverse(nums, 0, n-1)
        self.reverse(nums,0,k-1)
        self.reverse(nums,k,n-1)
    def reverse(self, nums:List[int], left: int, right: int) ->None:
        while left < right:
            tmp = nums[left]
            nums[left] = nums[right]
            nums[right] = tmp
            left += 1
            right -= 1

Leecode Day4

048 旋转图像90°

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        n = len(matrix)
        tmp = copy.deepcopy(matrix)
        for i in range(n):
            for j in range(n):
                matrix[j][n-1-i] = tmp[i][j]

        return matrix

新占用了空间，空间复杂度O（n2）

看了leecode大佬的新方法

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        n = len(matrix)
        for i in range(n // 2):
            for j in range((n + 1) // 2):
                tmp = matrix[i][j]
                matrix[i][j] = matrix[n - 1 - j][i]
                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]
                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]
                matrix[j][n - 1 - i] = tmp

作者：Krahets
链接：https://leetcode.cn/problems/rotate-image/solutions/1228078/48-xuan-zhuan-tu-xiang-fu-zhu-ju-zhen-yu-jobi/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

0054 螺旋矩阵

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        n = len(matrix)
        m = len(matrix[0])
        right, bottom, left, top, res = m-1, n-1, 0, 0, []  
        while True:
            #从左向右遍历
            for i in range(left,right+1):
                res.append(matrix[top][i])
            #往下一行
            top += 1
            if top > bottom:
                break
            #触碰到最右边，从上往下遍历
            for i in range(top,bottom+1):
                res.append(matrix[i][right])
            #往左一列
            right -= 1
            if right < left:
                break
            #触碰到最底部，从右向左遍历
            for i in range(right, left-1, -1):
                res.append(matrix[bottom][i])
            #往上一行       
            bottom -= 1
            if bottom > top:
                break
            #触碰到左端，从下向上遍历
            for i in range(bottom, top-1, -1):
                res.append(matrix[i][left])
            #往右一列
            left += 1
            if left > right:
                break
        return res

睇唔明

关注

13
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
01.02数组基础知识

其中，「顺序存储结构」是指占用的内存空间是连续的，相邻数据元素之间，物理内存上的存储位置也相邻。：线性表就是所有数据元素排成像一条线一样的结构，线性表上的数据元素都是相同类型，且每个数据元素最多只有前、后两个方向。举例二维数组是一个由 m 行 n 列数据元素构成的特殊结构，其本质上是以数组作为数据元素的数组，即。简而言之，数组是实现。此方法也称线性查找，线性查找操作依赖于数组中元素个数，因此「查找元素」的时间复杂度为。「访问数组元素」的操作不依赖于数组中元素个数，因此，「访问数组元素」的时间复杂度为。
复制链接

扫一扫