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.

# 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.

# 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).

# 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