##### Table of Contents Show

# Linear Search In C

Linear search is a fundamental searching algorithm that is widely used in computer science. It is also known as sequential search, and it works by traversing a list of elements one by one until it finds the desired element. Linear search is a simple algorithm to implement and understand, which makes it a popular choice for small to medium-sized datasets.

In C programming, linear search is implemented using a for loop to compare each element in an array with the key element that we are searching for. If the key element is found, we return the position in the array where it was found. If the key element is not found, we return -1 to indicate that it was not found. The time complexity of linear search is O(n), which means that the worst-case time complexity is proportional to the number of items in the list.

One of the advantages of linear search is that it works on unsorted arrays, which means that we do not need to sort the array before searching for an element. However, this also means that the worst-case complexity can be high if the key element is not found in the array. In this case, the algorithm will traverse the entire list before returning -1. Linear search is not the most efficient search algorithm for large datasets, but it is a good starting point for beginners who are learning about search algorithms.

## What is Linear Search?

Linear search is a simple searching algorithm used to find the position of a target value within an array or list. It is also known as a sequential search, where we traverse the entire array or list from the beginning to the end to find the desired value.

In linear search, we compare each element of the array or list with the target value until we find a match or reach the end of the array or list. If the target value is found, we return the index position of the element. If the target value is not present in the array or list, we return a message indicating that the element is not found.

Linear search is an efficient algorithm for small arrays or lists. However, for larger arrays or lists, it can be inefficient as it requires traversing the entire array or list, even if the target value is present at the beginning of the array or list.

Linear search can be implemented in C using a for loop or a while loop. In C, arrays are used to store a collection of elements of the same data type. Therefore, linear search is commonly used to search for an element within an array in C.

When implementing linear search in C, it is important to remember that the array index starts from 0. Therefore, we need to traverse the array from the first element (index 0) to the last element (index n-1), where n is the size of the array.

Overall, linear search is a simple and straightforward algorithm that is easy to understand and implement in C.

## Linear Search Algorithm

Linear search, also known as sequential search, is a searching algorithm that checks each element in a list or array until a match is found. It is a simple and straightforward algorithm that works well for small datasets.

The linear search algorithm is implemented using a loop that iterates through each element in the list. We start at the first element and compare it with the search item. If the search item is found, we return the index of the element. If the search item is not found, we continue iterating through the list until the end is reached. If the end is reached and the search item is still not found, we return a “not found” value.

In C, we can implement the linear search algorithm using a function. The function takes in two arguments – the list or array to be searched and the search item. The function returns the index of the search item if it is found, and a “not found” value otherwise.

Here is an example of a linear search function in C:

```
int linearSearch(int arr[], int n, int x) {
int i;
for(i = 0; i < n; i++) {
if(arr[i] == x) {
return i;
}
}
return -1;
}
```

In the above function, `arr`

is the array to be searched, `n`

is the length of the array, and `x`

is the search item. The function returns the index of `x`

if it is found, and `-1`

if it is not found.

The best case scenario for linear search is when the search item is found at the first element of the list. In this case, the algorithm only needs to perform one comparison and returns immediately. The worst case scenario is when the search item is not found in the list, in which case the algorithm needs to iterate through the entire list to determine that the item is not present.

Overall, linear search is a simple and effective algorithm for searching small datasets. However, for large datasets, more efficient algorithms such as binary search should be used.

## Time Complexity of Linear Search

When it comes to searching algorithms, one of the most basic and straightforward options is the linear search algorithm. This algorithm is also known as the sequential search algorithm. It works by checking each element in a list or array until it finds the target element or reaches the end of the list. While this algorithm is simple, it can be slow for large datasets.

The time complexity of linear search is O(n), where n is the number of elements in the list or array. This means that the worst-case scenario for linear search is that it has to check every element in the list before finding the target element. The best-case scenario is that the target element is found in the first iteration of the loop, resulting in a time complexity of O(1).

To understand the time complexity of linear search, we need to understand what O(n) means. In simple terms, it means that the time taken by the algorithm to complete increases linearly with the size of the input. So, if the size of the input is doubled, the time taken by the algorithm will also double.

While linear search is a simple and easy-to-implement search algorithm, it is not suitable for large datasets. As the number of elements increases, the time taken by the algorithm to complete also increases. Therefore, it is recommended to use more efficient search algorithms such as binary search for larger datasets.

In terms of implementation, the time complexity of linear search can be improved by optimizing the comparison operation. By minimizing the number of comparisons, we can reduce the overall time taken by the algorithm. Additionally, it is also possible to use parallel processing to speed up the search process.

Overall, linear search is a basic and simple search algorithm that is suitable for small datasets. However, it can be slow for larger datasets and is not recommended for use in such cases.

## Space Complexity of Linear Search

When we talk about the space complexity of an algorithm, we are referring to the amount of memory required by the algorithm to execute. In the case of Linear Search, the space complexity is O(1), which means that the algorithm requires a constant amount of memory, regardless of the size of the input.

This is because Linear Search only requires a few variables to be stored in memory, such as the array being searched, the value being searched for, and a few counters and indices. As a result, the space complexity of Linear Search is very low, making it a great option for searching small arrays.

It’s important to note that the space complexity of an algorithm is different from its time complexity. While the space complexity refers to the amount of memory required, the time complexity refers to the amount of time required to execute the algorithm. In the case of Linear Search, the time complexity is O(n), where n is the size of the input array.

In C, we can implement Linear Search using a simple for loop that iterates through the array and checks each element for a match with the search value. Since the space complexity of Linear Search is so low, we don’t need to worry about allocating additional memory or using complex data structures.

Overall, the space complexity of Linear Search is very low, making it an efficient and practical algorithm for searching small arrays in C.

## Worst Case Time Complexity of Linear Search

In Linear Search, the worst case occurs when the element we are searching for is not present in the list. In this case, we have to iterate through all the items in the list to determine that the element is not present. This means that the worst-case time complexity of Linear Search is O(n), where n is the number of items in the list.

Let’s say we have a list of 100 items, and we are searching for an element that is not present in the list. In this case, we have to iterate through all 100 items in the list to determine that the element is not present. This means that the worst-case time complexity of Linear Search for this list is O(100), which is equivalent to O(n).

The worst-case time complexity of Linear Search is the maximum amount of time it will take to search for an element in the list. This occurs when the element is not present in the list. In this case, we have to search through all the items in the list to determine that the element is not present.

It’s important to note that the worst-case time complexity of Linear Search only occurs when the element we are searching for is not present in the list. If the element is present in the list, the time complexity will be less than O(n), and will depend on the location of the element in the list.

In summary, the worst-case time complexity of Linear Search is O(n), where n is the number of items in the list. This occurs when the element we are searching for is not present in the list, and we have to search through all the items in the list to determine that the element is not present.

## Implementation of Linear Search

When implementing a linear search in C, we first need to declare an array and the element we want to search for. We can then use a for loop to traverse the entire array and search for the element in a sequential fashion. As soon as we encounter a match, we can return the element along with its position in the array.

Here’s an example implementation of linear search in C:

```
#include <stdio.h>
int linearSearch(int arr[], int n, int x) {
int i;
for (i = 0; i < n; i++) {
if (arr[i] == x) {
return i;
}
}
return -1;
}
int main() {
int arr[] = {2, 4, 0, 1, 9};
int x = 1;
int n = sizeof(arr) / sizeof(arr[0]);
int result = linearSearch(arr, n, x);
if (result == -1) {
printf("Element not foundn");
} else {
printf("Element found at index %dn", result);
}
return 0;
}
```

In this example, we have an array `arr`

of size 5 and we want to search for the element `x = 1`

. We pass the array, its size `n`

, and the element to search for `x`

to the `linearSearch`

function. The function then uses a for loop to traverse the entire array and search for the element in a sequential fashion. If it finds a match, it returns the index of the element. If it doesn’t find a match, it returns -1.

The linear search algorithm is a very simple and basic search algorithm that is easy to implement in C. It is also known as a sequential search algorithm because it searches for an element in a sequential manner. We can use this algorithm to search for elements in arrays of any size.

While the example implementation above is in C, we can also implement linear search in other programming languages such as Python and JavaScript. The basic idea remains the same – we need to traverse the entire array and search for the element in a sequential fashion using a for loop.

## Average Case Complexity of Linear Search

When analyzing the performance of an algorithm, it is essential to consider the average case complexity. In the case of linear search, the average case complexity is O(n/2), which is equivalent to O(n).

To understand this, let’s consider a scenario where we are searching for an element in an unordered list. In the average case, the element we are searching for can be present anywhere in the list. Therefore, we will need to search half of the list, on average, to find the element. This is why the average case complexity is n/2.

We can express this mathematically by using the following formula:

```
Average case complexity = (1 + 2 + 3 + ... + n) / n
= (n * (n + 1) / 2) / n
= (n + 1) / 2
```

This formula gives us the average number of comparisons required to find an element in an unordered list of size n.

When implementing linear search in C, we can use a for loop to iterate through the list and compare each element with the element we are searching for. The loop will run n/2 times on average, which is why the average case complexity is O(n).

In summary, the average case complexity of linear search is O(n), and we can use a for loop to implement it in C.

## Advantages of Linear Search

Linear search is a simple and straightforward algorithm that can be used to search for a specific element in an array. Here are some advantages of using Linear Search:

**1. Simplicity and Ease of Implementation**

Linear search is the most basic algorithm and consists of only a loop to traverse through all the elements. As a result, it is very easy to understand and implement, making it a great option for beginners.

**2. No additional memory requirement**

Linear search does not require any additional memory space to store the elements of the array. It simply traverses through the array and checks each element until it finds the desired element.

**3. Can be used on any data type**

Linear search can be used on arrays of any data type, including integers, characters, and strings. This makes it a versatile algorithm that can be used in a wide range of applications.

**4. Well-suited for small datasets**

Linear search is a well-suited algorithm for small datasets. It is fast and efficient when the number of elements in the array is small.

**5. Works on unsorted arrays**

Linear search can be used irrespective of whether the array is sorted or not. This makes it a useful algorithm when the data is not sorted or when sorting is not possible.

In conclusion, Linear Search is a simple and efficient algorithm that can be used to search for an element in an array. Its simplicity, ease of implementation, and versatility make it a great option for beginners and for small datasets.

## Linear Search vs Binary Search

When it comes to searching for a desired element in an array, two popular search algorithms are Linear Search and Binary Search. Both algorithms have their own advantages and disadvantages, and which one to use depends on the situation at hand.

### Linear Search

Linear Search, also known as Sequential Search, involves traversing the array sequentially and comparing each element with the key element until a match is found or the end of the array is reached. This algorithm is simple and easy to implement and works well for small arrays or when the desired element is located at the beginning of the array. Linear Search can also handle multiple occurrences of the desired element in the array.

However, Linear Search has a worst-case complexity of O(n) where n is the size of the array. This means that for larger arrays, Linear Search can be slow and inefficient. Additionally, Linear Search is not suitable for unsorted arrays.

### Binary Search

Binary Search, on the other hand, is a more efficient algorithm that works well for sorted arrays. Binary Search works by repeatedly dividing the search interval in half until the key element is found or the search interval is empty. This algorithm has a worst-case complexity of O(log n) where n is the size of the array, making it much faster than Linear Search for larger arrays.

However, Binary Search requires the array to be sorted and can’t handle multiple occurrences of the desired element in the array. Additionally, Binary Search is more complex to implement than Linear Search and requires recursion or iteration.

In summary, Linear Search is a simple and easy-to-implement algorithm that works well for small arrays or when the desired element is located at the beginning of the array. Binary Search, on the other hand, is a more efficient algorithm that works well for sorted arrays and larger arrays. When deciding which algorithm to use, it’s important to consider the size of the array, whether the array is sorted or unsorted, and whether multiple occurrences of the desired element need to be handled.