# Search, insert and delete in an unsorted array

In this post search, insert and delete operation in an unsorted array is discussed.

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Search Operation

In an unsorted array, the search operation can be performed by linear traversal from the first element to the last element.

## C

```// C program to implement linear search in
// unsorted array
#include<stdio.h>

/* Function to implement search operation */
int findElement(int arr[], int n,int key)
{
int i;
for (i=0; i<n; i++)
if (arr[i] == key)
return i;

return -1;
}

/* Driver program to test above function */
int main()
{
int arr[] = {12, 34, 10, 6, 40};
int n = sizeof(arr)/sizeof(arr[0]);

//Using a last element as search element
int key =40;
int position = findElement(arr,n,key);

if (position==-1)
else
printf("Element Found at Position: %d", position+1 );

return 0;
}
```

## Java

```// Java program to implement linear
// search in unsorted arrays

class Main
{
/* Function to implement
search operation */
static int findElement(int arr[], int n,int key)
{
for (int i=0; i<n; i++)
if (arr[i] == key)
return i;

return -1;
}

// main Function
public static void main(String args[])
{
int arr[] = {12, 34, 10, 6, 40};
int n = arr.length;

// Using a last element as search element
int key =40;
int position = findElement(arr,n,key);

if (position==-1)
else
System.out.println("Element Found at Position: "
+ (position+1));
}
}
```

## Python

```# Python program for searching in
# unsorted array

def findElement(arr, n, key):
for i in range (n):
if (arr[i] == key):
return i
return -1

arr = [12, 34, 10, 6, 40]
key = 40
n = len(arr)

#search operation
index = findElement(arr, n, key)
if index != -1:
print ("element found at position: " + str(index + 1 ))
else:

# Thanks to Aditi Sharma for contributing
# this code
```

Output:

```Element Found at Position: 5
```

Insert Operation

In an unsorted array, the insert operation is faster as compared to sorted array because we don’t have to care about the position at which the element is to be placed.

## C

```// C program to implement insert operation in
// an unsorted array.
#include<stdio.h>

// Inserts a key in arr[] of given capacity.  n is current
// size of arr[]. This function returns n+1 if insertion
// is successful, else n.
int insertSorted(int arr[], int n, int key, int capacity)
{
// Cannot insert more elements if n is already
// more than or equal to capcity
if (n >= capacity)
return n;

arr[n] = key;

return (n+1);
}

/* Driver program to test above function */
int main()
{
int arr[20] = {12, 16, 20, 40, 50, 70};
int capacity = sizeof(arr)/sizeof(arr[0]);
int n = 6;
int i, key = 26;

printf("\nBefore Insertion: ");
for (i=0; i<n; i++)
printf("%d  ", arr[i]);

// Inserting key
n = insertSorted(arr, n, key, capacity);

printf("\nAfter Insertion: ");
for (i=0; i<n; i++)
printf("%d  ",arr[i]);

return 0;
}
```

## Java

```// Java program to implement insert
// operation in an unsorted array.

class Main
{
/* Function to insert a given key in
the array. This function returns n+1
if insertion is successful, else n. */
static int insertSorted(int arr[], int n, int key, int capacity)
{
// Cannot insert more elements if n
// is already more than or equal to
// capcity
if (n >= capacity)
return n;

arr[n] = key;

return (n+1);
}

/* Driver program to test above function */
public static void main (String[] args)
{
int[] arr = new int[20];
arr[0] = 12;
arr[1] = 16;
arr[2] = 20;
arr[3] = 40;
arr[4] = 50;
arr[5] = 70;
int capacity = 20;
int n = 6;
int i, key = 26;

System.out.print("Before Insertion: ");
for (i=0; i<n; i++)
System.out.print(arr[i]+" ");

// Inserting key
n = insertSorted(arr, n, key, capacity);

System.out.print("\nAfter Insertion: ");
for (i=0; i<n; i++)
System.out.print(arr[i]+" ");
}
}
```

## Python

```# Python program for inserting
# an element in an unsorted array

# method to insert element
def insert(arr, element):
arr.append(element)

# declaring array and key to insert
arr = [12, 16, 20, 40, 50, 70]
key = 26

# array before inserting an element
print ("Before Inserting: ")
print (arr)

# array after Inserting element
insert(arr, key)
print("After Inserting: ")
print (arr)

# Thanks to Aditi Sharma for contributing
# this code
```

Output:

```Before Insertion: 12 16 20 40 50 70
After Insertion: 12 16 20 40 50 70 26
```

Delete Operation

In delete operation, the element to be deleted is searched using the linear search and then delete operation is performed followed by shifting the elements.

## C

```// C program to implement delete operation in a
// unsorted array
#include<stdio.h>

// To search a key to be deleted
int findElement(int arr[], int n, int key);

/* Function to delete an element */
int deleteElement(int arr[], int n, int key)
{
// Find position of element to be deleted
int pos = findElement(arr, n, key);

if (pos==-1)
{
return n;
}

// Deleting element
int i;
for (i=pos; i<n-1; i++)
arr[i] = arr[i+1];

return n-1;
}

/* Function to implement search operation */
int findElement(int arr[], int n, int key)
{
int i;
for (i=0; i<n; i++)
if (arr[i] == key)
return i;

return -1;
}

// Driver code
int main()
{
int i;
int arr[] = {10, 50, 30, 40, 20};

int n = sizeof(arr)/sizeof(arr[0]);
int key = 30;

printf("Array before deletion\n");
for (i=0; i<n; i++)
printf("%d  ", arr[i]);

n = deleteElement(arr, n, key);

printf("\n\nArray after deletion\n");
for (i=0; i<n; i++)
printf("%d  ", arr[i]);

return 0;
}
```

## Java

```// Java program to implement delete
// operation in an unsorted array

class Main
{
// function to search a key to
// be deleted
static int findElement(int arr[], int n, int key)
{
int i;
for (i=0; i<n; i++)
if (arr[i] == key)
return i;

return -1;
}

/* Function to delete an element */
static int deleteElement(int arr[], int n, int key)
{
// Find position of element to be
// deleted
int pos = findElement(arr, n, key);

if (pos==-1)
{
return n;
}

// Deleting element
int i;
for (i=pos; i<n-1; i++)
arr[i] = arr[i+1];

return n-1;
}

// main Function
public static void main(String args[])
{
int i;
int arr[] = {10, 50, 30, 40, 20};

int n = arr.length;
int key = 30;

System.out.println("Array before deletion");
for (i=0; i<n; i++)
System.out.print(arr[i] + " ");

n = deleteElement(arr, n, key);

System.out.println("\n\nArray after deletion");
for (i=0; i<n; i++)
System.out.print(arr[i]+" ");
}
}
```

## Python

```# Python program to delete an element
# from an unsorted array

# Declaring array and key to delete
arr = [10, 50, 30, 40, 20]
key = 30

print("Array before dletion:")
print arr

# deletes key if found in the array
# otherwise shows error not in list
arr.remove(key)
print("Array after deletion")
print(arr)

# Thanks Aditi Sharma for contributing
# this code
```

Output:

```Array before deletion
10 50 30 40 20

Array after deletion
10 50 40 20
```

Time complexities:
Search: O(n)
Insert: O(1)
Delete: O(n)

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
1.2 Average Difficulty : 1.2/5.0
Based on 158 vote(s)