Blog: Common Array Algorithms

In this blog, we will explore some of the common array algorithms that are widely used in programming. These algorithms provide efficient solutions for various array-related operations such as searching and sorting. We will discuss the following algorithms:

1. Linear Search

2. Binary Search

3. Merge Sort

4. Insertion Sort

5. Selection Sort

6. Bubble Sort

Let's dive into each algorithm and understand its working principles, implementation, and time complexity.

7.1 Linear Search

Linear search is a basic algorithm used to find a specific element in an array. It works by sequentially scanning the array from the beginning and comparing each element with the target element. The search process continues until a match is found or the end of the array is reached. Linear search is straightforward but may not be efficient for large arrays.

Implementation in Python:

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

7.2 Binary Search

Binary search is an efficient algorithm used to find an element in a sorted array. It follows a divide-and-conquer approach by repeatedly dividing the search space in half. It compares the target element with the middle element of the array and determines whether the target is in the left or right half. This process continues until the target element is found or the search space is empty.

Implementation in Python:

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

7.3 Merge Sort

Merge sort is a popular sorting algorithm that follows the divide-and-conquer approach. It divides the input array into two halves, recursively sorts each half, and then merges them to obtain a sorted array. Merge sort has a time complexity of O(n log n) and is stable, meaning it preserves the order of equal elements.

Implementation in Python:

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]

    left = merge_sort(left)
    right = merge_sort(right)

    return merge(left, right)

def merge(left, right):
    result = []
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    while i < len(left):
        result.append(left[i])
        i += 1

    while j < len(right):
        result.append(right[j])
        j += 1

    return result

7.4 Insertion Sort

Insertion sort is a simple sorting algorithm that builds the final sorted array one element at a time. It iterates through the array and inserts each element into its proper position in the already sorted part of the array. Insertion sort has a time complexity of O(n^2) but performs well for small or nearly sorted arrays.

Implementation in Python:

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and

 arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

7.5 Selection Sort

Selection sort is another simple sorting algorithm that repeatedly selects the smallest element from the unsorted part of the array and swaps it with the element at the beginning of the unsorted part. It continues this process until the entire array is sorted. Selection sort has a time complexity of O(n^2) and performs the same number of swaps as the number of elements.

Implementation in Python:

def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

7.6 Bubble Sort

Bubble sort is a simple sorting algorithm that repeatedly compares adjacent elements and swaps them if they are in the wrong order. This process is repeated until the entire array is sorted. Bubble sort has a time complexity of O(n^2) and is mostly used for educational purposes due to its simplicity.

Implementation in Python:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

These common array algorithms provide efficient solutions for various array operations such as searching and sorting. By understanding the principles and implementation details of these algorithms, you can apply them effectively in your programming tasks.