How to Search, Insert, and Delete in an Unsorted Array

This post discusses a code that performs search, insert, and delete actions on an unsorted array.

Search Operation:

With an unsorted array, the search operation can be accomplished by doing a linear traversal from the first to the final element.

How to Search, Insert, and Delete in an Unsorted Array

Programming execution of the search operation:

C Programming Language:

#include <stdio.h>
int findElement(int array[], int n, int key)
{
	int i;
	for (i = 0; i < n; i++)
		if (array[i] == key)
			return i;
	
	return -1;
}
int main()
{
	int array[] = { 22, 24, 30, 16, 35 };
	int n = sizeof(array) / sizeof(array[0]);

	int key = 16;

	int position = findElement(array, n, key);

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

	return 0;
}

Output

Element Found at Position: 4

C++ Program:

#include <bits/stdc++.h>
using namespace std;
int findElement(int array[], int n, int key)
{
	int i;
	for (i = 0; i < n; i++)
		if (array[i] == key)
			return i;
	
	return -1;
}

int main()
{
	int array[] = { 22, 24, 30, 16, 35 };
	int n = sizeof(array) / sizeof(array[0]);

	int key = 16;

	int position = findElement(array, n, key);

	if (position == -1)
		cout << "Element not found";
	else
		cout << "Element Found at Position: "
			<< position + 1;

	return 0;
}

Output

Element Found at Position: 4

Java:

class Main {
	static int findElement(int array[], int n, int key)
	{
		for (int i = 0; i < n; i++)
			if (array[i] == key)
				return i;
		return -1;
	}
	public static void main(String args[])
	{
		int array[] = { 22, 24, 30, 16, 35 };
		int n = array.length;

		int key = 16;
	
		int position = findElement(array, n, key);

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

Output

Element Found at Position: 4

Time Complexity will be O(N).
Auxiliary Space will be O(1).

Insert Operation:

1. Insert at the end:

In an unsorted array, the insert operation is quicker than in a sorted array as we do not need to worry about the position at which the element is to be inserted.

Programming execution of the insertion operation:

C Programming Language:

#include <stdio.h>

int insertSorted(int array[], int n, int key, int capacity)
{
	if (n >= capacity)
		return n;

	array[n] = key;

	return (n + 1);
}

int main()
{
	int array[20] = { 22, 26, 30, 50, 60, 80 };
	int capacity = sizeof(array) / sizeof(array[0]);
	int n = 6;
	int i, key = 34;

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

	n = insertSorted(array, n, key, capacity);

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

	return 0;
}

Output

Before Insertion: 22 26 30 50 60 80 
 After Insertion: 22 26 30 50 60 80 34

C++ Program:

#include <bits/stdc++.h>
using namespace std;
int insertSorted(int array[], int n, int key, int capacity)
{
	if (n >= capacity)
		return n;

	array[n] = key;

	return (n + 1);
}

int main()
{
	int array[20] = { 22, 26, 30, 50, 60, 80 };
	int capacity = sizeof(array) / sizeof(array[0]);
	int n = 6;
	int i, key = 34;

	cout << "\n Before Insertion: ";
	for (i = 0; i < n; i++)
		cout << array[i] << " ";

	n = insertSorted(array, n, key, capacity);

	cout << "\n After Insertion: ";
	for (i = 0; i < n; i++)
	cout << array[i] << " ";

	return 0;
}

Output

Before Insertion: 22 26 30 50 60 80 
 After Insertion: 22 26 30 50 60 80 34

Java:

class Main {
	static int insertSorted(int array[], int n, int key,
							int capacity)
	{
		if (n >= capacity)
			return n;

		array[n] = key;

		return (n + 1);
	}

	public static void main(String[] args)
	{
		int[] array = new int[20];
		array[0] = 22;
		array[1] = 26;
		array[2] = 30;
		array[3] = 50;
		array[4] = 60;
		array[5] = 80;
		int capacity = 20;
		int n = 6;
		int i, key = 34;

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

		n = insertSorted(array, n, key, capacity);

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

Output

Before Insertion: 22 26 30 50 60 80 
 After Insertion: 22 26 30 50 60 80 34

Time Complexity will be O(1).
Auxiliary Space will be O(1).

2. Insert at any point

Insert operations in an array can be performed at any point by moving elements to the right that are on the right side of the desired position.

Programming execution of the insertion operation:

C Programming Language:

#include <stdio.h>

void insertElement(int array[], int n, int x, int pos)
{
	for (int i = n - 1; i >= pos; i--)
		array[i + 1] = array[i];

	array[pos] = x;
}
int main()
{
	int array[15] = { 1, 3, 5, 7, 4 };
	int n = 5;

	printf("Before insertion : ");
	for (int i = 0; i < n; i++)
		printf("%d ", array[i]);

	printf("\n");

	int x = 9, pos = 3;

	insertElement(array, n, x, pos);
	n++;

	printf("After insertion : ");
	for (int i = 0; i < n; i++)
		printf("%d ", array[i]);

	return 0;
}

Output

Before insertion : 1 3 5 7 4 
After insertion : 1 3 5 9 7 4

C++ Program:

#include <bits/stdc++.h>
using namespace std;

void insertElement(int array[], int n, int x, int pos)
{
	for (int i = n - 1; i >= pos; i--)
		array[i + 1] = array[i];

	array[pos] = x;
}

int main()
{
	int array[15] = { 1, 3, 5, 7, 4 };
	int n = 5;

	cout << "Before insertion : ";
	for (int i = 0; i < n; i++)
		cout << array[i] << " ";

	cout << endl;

	int x = 9, pos = 3;

	insertElement(array, n, x, pos);
	n++;

	cout << "After insertion : ";
	for (int i = 0; i < n; i++)
		cout << array[i] << " ";

	return 0;
}

Output

Before insertion : 1 3 5 7 4 
After insertion : 1 3 5 9 7 4

Java:

import java.io.*;

class JTP {
	static void insertElement(int array[], int n, int x,
							int pos)
	{
		for (int i = n - 1; i >= pos; i--)
			array[i + 1] = array[i];
		array[pos] = x;
	}
	public static void main(String[] args)
	{
		int array[] = new int[15];
		array[0] = 1;
		array[1] = 3;
		array[2] = 5;
		array[3] = 7;
		array[4] = 4;
		int n = 5;
		int x =9, pos = 3;

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

		insertElement(array, n, x, pos);
		n += 1;

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

Output

Before insertion : 1 3 5 7 4 
After insertion : 1 3 5 9 7 4

Time complexity will be O(N).
Auxiliary Space will be O(1).

Delete Operation:

The element to be deleted is found using a linear search, and then the delete operation is executed, followed by relocating the elements.

Programming execution of the deletion operation:

C Programming Language:

#include <stdio.h>

int findElement(int array[], int n, int key);

int deleteElement(int array[], int n, int key)
{
	int pos = findElement(array, n, key);

	if (pos == -1) {
		printf("Element not found");
		return n;
	}

	int i;
	for (i = pos; i < n - 1; i++)
		array[i] = array[i + 1];

	return n - 1;
}
int findElement(int array[], int n, int key)
{
	int i;
	for (i = 0; i < n; i++)
		if (array[i] == key)
			return i;

	return -1;
}

int main()
{
	int i;
	int array[] = { 20, 60, 40, 50, 30 };

	int n = sizeof(array) / sizeof(array[0]);
	int key = 40;

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

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

	return 0;
}

Output

Array before deletion
20 60 40 50 30 
Array after deletion
20 60 50 30

C++ Program:

#include <iostream>
using namespace std;

int findElement(int array[], int n, int key);

int deleteElement(int array[], int n, int key)
{
	int pos = findElement(array, n, key);

	if (pos == -1) {
		cout << "Element not found";
		return n;
	}

	int i;
	for (i = pos; i < n - 1; i++)
		array[i] = array[i + 1];

	return n - 1;
}

int findElement(int array[], int n, int key)
{
	int i;
	for (i = 0; i < n; i++)
		if (array[i] == key)
			return i;

	return -1;
}
int main()
{
	int i;
	int array[] = { 20, 60, 40, 50, 30 };

	int n = sizeof(array) / sizeof(array[0]);
	int key = 40;

	cout << "Array before deletion\n";
	for (i = 0; i < n; i++)
		cout << array[i] << " ";
	
	n = deleteElement(array, n, key);

	cout << "\n\nArray after deletion\n";
	for (i = 0; i < n; i++)
		cout << array[i] << " ";

	return 0;
}

Output

Array before deletion
20 60 40 50 30 
Array after deletion
20 60 50 30

Java:

class Main {
	static int findElement(int array[], int n, int key)
	{
		int i;
		for (i = 0; i < n; i++)
			if (array[i] == key)
				return i;

		return -1;
	}
	static int deleteElement(int array[], int n, int key)
	{
		int pos = findElement(array, n, key);

		if (pos == -1) {
			System.out.println("Element not found");
			return n;
		}
		int i;
		for (i = pos; i < n - 1; i++)
			array[i] = array[i + 1];

		return n - 1;
	}
	public static void main(String args[])
	{
		int i;
		int array[] = { 20, 60, 40, 50, 30 };

		int n = array.length;
		int key = 40;

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

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

Output

Array before deletion
20 60 40 50 30 
Array after deletion
20 60 50 30

Time Complexity will be O(N).
Auxiliary Space will be O(1).

Next TopicCount Non-Leaf Nodes in a Binary Tree

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

Javatpoint Services

JavaTpoint offers too many high quality services. Mail us on h[email protected], to get more information about given services.

Website Designing
Website Development
Java Development
PHP Development
WordPress
Graphic Designing
Logo
Digital Marketing
On Page and Off Page SEO
PPC
Content Development
Corporate Training
Classroom and Online Training
Data Entry

Training For College Campus

JavaTpoint offers college campus training on Core Java, Advance Java, .Net, Android, Hadoop, PHP, Web Technology and Python. Please mail your requirement at [email protected].
Duration: 1 week to 2 week

^{Like/Subscribe us for latest updates or newsletter}