Algorithms practice:array

introduce

The simplest data structure is the array, which is a contiguous block of memory. It is usually used to represent sequences. Given an array A, A[i] denotes the (i+1)th object stored in the array. Retrieving and updating A[i] takes O(1) time. Insertion into a full array can be handled by resizing, i.e., allocating a new array with additional memory and copying over the entries from the original array. This increases the worst-case time of insertion, but if the newarray has, for example, a constant factor larger than the original array, the average time for insertion is constant since resizing is infrequent. Deleting an element from an array entails moving all successive elements one over to the left to fill the vacated space.

Contiguous memory locations refer to a situation where multiple memory addresses are adjacent or continuous without any gaps between them. In the context of arrays, this means that the elements of the array are stored next to each other in memory.

Characteristics of Contiguous Memory:

  1. Adjacent Storage: Elements in an array are stored one after another in memory, without any other data interspersed between them. For example, if an integer array starts at memory address 1000, the next integer element will be at 1004 (assuming an integer takes 4 bytes of memory).

  2. Sequential Access: Accessing elements based on their index is efficient because the memory addresses are consecutive. By knowing the memory address of the first element and the size of each element, the location of any other element in the array can be calculated easily.

Importance in Array Operations:

  • Efficient Access: Because elements in a contiguous array are stored linearly, accessing elements by index involves simple arithmetic operations to calculate memory addresses. For example, accessing the 5th element in an array directly involves going to the memory address of the first element and adding the appropriate offset (5 times the size of each element).

  • Iteration and Traversal: Iterating through elements of the array becomes more efficient due to their sequential arrangement in memory. Looping through contiguous memory locations allows for faster traversal compared to scattered or non-contiguous data structures.

Drawbacks:

  • Fixed Size: Arrays have a fixed size once they are created. If the array needs to grow beyond its initial capacity, it might require a new allocation of contiguous memory, potentially causing inefficiency or the need to copy elements to a new location.

  • Fragmentation: Over time, as arrays are created and deleted, memory fragmentation can occur, leading to unavailability of contiguous blocks of memory even if the total free memory is sufficient.

Understanding contiguous memory is crucial for understanding the efficiency of array-based data structures and their underlying memory management. It's also relevant in optimizing algorithms that heavily rely on sequential access to elements, such as search and sorting algorithms.

The time complexity of deleting

The time complexity of deleting an element from an array depends on the position of the element that needs to be deleted.

Deleting from the End of the Array (Given the Index):

If you're deleting the last element of an array given its index, the time complexity is constant, denoted as O(1). This is because you directly access the element by its index and remove it, requiring no further rearrangement of elements.

python 复制代码
# Example: Deleting the last element from an array
arr = [1, 2, 3, 4, 5]
index_to_delete = len(arr) - 1  # Index of the last element
del arr[index_to_delete]
# Time complexity: O(1)

Deleting from the Start or Middle of the Array:

If you want to delete an element from the beginning or middle of the array, after removing the element, the subsequent elements need to be shifted to fill the gap created by the deletion. The time complexity in this case is O(n), where 'n' represents the number of elements in the array.

python 复制代码
# Example: Deleting an element from the middle of an array
arr = [1, 2, 3, 4, 5]
index_to_delete = 2  # Index of the element '3' to be deleted
arr.pop(index_to_delete)
# Time complexity: O(n)

Deleting with a Given Element (Not Index):

If you're given the value of the element to delete but not its index, finding the element's index takes O(n) time (in the worst case), and then the deletion operation itself requires shifting elements, resulting in a time complexity of O(n).

python 复制代码
# Example: Deleting an element by its value from an array
arr = [1, 2, 3, 4, 5]
element_to_delete = 3
arr.remove(element_to_delete)  # This involves finding the index first
# Time complexity: O(n) + O(n) = O(n)

In summary:

  • Deleting an element from the end of an array: O(1)
  • Deleting an element from the start or middle of an array: O(n)
  • Deleting an element by its value (not index): O(n) + O(n) = O(n)

english

  1. contiguous[kənˈtɪɡjuəs]: touching or next to sth相接的;相邻的:
    array is a contiguous block of memory
  2. denote [dɪˈnəʊt] to mean sth
    A[i] denotes the (i+1)th object stored in the array.
  3. 取数据 retrieve [rɪˈtriːv] 更新数据update
    Retrieving and updating A[i] takes O(1) time.
  4. 分配内存 allocate
相关推荐
写代码的小球2 小时前
求模运算符c
算法
大千AI助手5 小时前
DTW模版匹配:弹性对齐的时间序列相似度度量算法
人工智能·算法·机器学习·数据挖掘·模版匹配·dtw模版匹配
YuTaoShao7 小时前
【LeetCode 热题 100】48. 旋转图像——转置+水平翻转
java·算法·leetcode·职场和发展
生态遥感监测笔记7 小时前
GEE利用已有土地利用数据选取样本点并进行分类
人工智能·算法·机器学习·分类·数据挖掘
Tony沈哲7 小时前
macOS 上为 Compose Desktop 构建跨架构图像处理 dylib:OpenCV + libraw + libheif 实践指南
opencv·算法
刘海东刘海东8 小时前
结构型智能科技的关键可行性——信息型智能向结构型智能的转变(修改提纲)
人工智能·算法·机器学习
独行soc8 小时前
#渗透测试#批量漏洞挖掘#HSC Mailinspector 任意文件读取漏洞(CVE-2024-34470)
linux·科技·安全·网络安全·面试·渗透测试
pumpkin845148 小时前
Rust 调用 C 函数的 FFI
c语言·算法·rust
挺菜的9 小时前
【算法刷题记录(简单题)003】统计大写字母个数(java代码实现)
java·数据结构·算法