List Data Structure

The list can be defined as an abstract data type in which the elements are stored in an ordered manner for easier and efficient retrieval of the elements. List Data Structure allows repetition that means a single piece of data can occur more than once in a list. In the case of multiple entries of the same data, each entry of that repeating data is considered as a distinct item or entry. It is very much similar to the array but the major difference between the array and the list data structure is that array stores only homogenous data in them whereas the list (in some programming languages) can store heterogeneous data items in its object. List Data Structure is also known as a sequence.

The list can be called Dynamic size arrays, which means their size increased as we go on adding data in them and we need not to pre-define a static size for the list.

For example,

numbers = [ 1, 2, 3, 4, 5]

In this example, 'numbers' is the name of the List Data Structure object and it has five items stored in it. In the object named numbers, we have stored all the elements of numeric type. In the list, the indexing starts from zero, which means if we want to access or retrieve the first element of this list then we need to use index zero and similarly whenever we want to access any element from this list named numbers. In other words, we can say that element 1 is on the index 0 and element 2 is on index 1 and similarly for further all elements.

Mixed_data = [205, 'Nirnay', 8.56]

In this second example, mixed_data is the name of the list object that stores the data of different types. In the mixed_data list, we have stored data of three types, first one is the integer type which is id '205', after the integer data we have stored a string type data having the value 'Nirnay' stored at index 1 and at last the index value 2, we have stored a float type data having the value '8.56'.

To access the elements of the mixed_data list, we need to follow the same approach as defined in the previous example.

And we can add more data to these defined List objects and that will get appended at the last of the list. For example, if we add another data in the mixed_data list, it will get appended after the float value object having value '8.56'. And we can add repeating values to these list-objects.

Various operations on the List Data Structure:

The various operations that are performed on a List Data Structure or Sequence are:

Add or Insert Operation: In the Add or Insert operation, a new item (of any data type) is added in the List Data Structure or Sequence object.
Replace or reassign Operation: In the Replace or reassign operation, the already existing value in the List object is changed or modified. In other words, a new value is added at that particular index of the already existing value.
Delete or remove Operation: In the Delete or remove operation, the already present element is deleted or removed from the Dictionary or associative array object.
Find or Lookup or Search Operation: In the Find or Lookup operation, the element stored in that List Data Structure or Sequence object is fetched.

Now, let us see the usage of the List Data Structure or Sequence in different programming languages.

Python:

A sample python code to perform all the basic four operations like create, update, delete and update on the List Data Structure or Sequence object.

Code:

# python code to implement all the basic functionalities on an object of list named roll_nos

# a list object named roll_nos is created that will store all the roll nos in it
roll_nos = list()

# a fucntion named add_roll_no is created to add new data in the list object named roll_nos
def add_roll_no():

	# data is taken from the user
	data = int(input('Enter the roll no that you want to add to the list : '))

	# data entered by the user is appended to the list object named roll_nos
	roll_nos.append(data)
# a fucntion named delete_roll_no is created to delete data from the list object named roll_nos
def delete_roll_no():
	data = int(input('Enter the roll no that you want to delete or remove from the list : '))

	# data is removed from the list object named roll_nos with the use of remove()
	roll_nos.remove(data)
# a fucntion named add_roll_no is created to print all the data present in the list object named roll_nos
def print_roll_nos():
	print('Contents of the Roll No List are : ')
	# a for loop is used to iterate through the list object
	for i in roll_nos:
		print(i, end=' ')

	print()
# a function named add_roll_no is created to update the already existing data in the list object named roll_nos
def update_roll_no():

	# the old data and the new data is taken as input from the user in two variables named old_data and new_data respectively 

	old_data = int(input('Enter the old roll no that you want to update : '))
	new_data = int(input('Enter the new roll no that you want to add : '))

	# logic for updating the data in the list object named roll_nos
	for index, data in enumerate(roll_nos):
		if old_data == data:
			roll_nos[index] = new_data
			break

# a main fucntion is created to call all the functionalitiy fucntions written above
def main():

	print('Add Data to the List Object::')
	# add_roll_no fucntion is called to add or append the new data to the list object named roll_nos six times
	add_roll_no()
	add_roll_no()
	add_roll_no()
	add_roll_no()
	add_roll_no()
	add_roll_no()

	# added is printed by calling the print_roll_nos fucntion
	print_roll_nos()

	print()
	print('Update Data from the List Object::')
	# already existing data is updated to by calling the update_roll_no fucntion
	update_roll_no()
	# printing the data after update operation by calling the print_roll_nos fucntion
	print('The Result after updating the List Object::')
	print_roll_nos()


	print()
	print('Delete Data from the List Object::')
	# some data is deleted from the list object named roll_nos by calling the delete_roll_no fucntion
	delete_roll_no()
	# printing the data after delete operation by calling the print_roll_nos fucntion
	print('The Result after delete operation on the List Object::')
	print_roll_nos()



# the main fucntion is called in order to execute all the fucntions that will perfrom different operations on the list object 
if __name__ == '__main__':
	main()

Output:

Add Data to the List Object::
Enter the roll no that you want to add to the list: 101
Enter the roll no that you want to add to the list: 103
Enter the roll no that you want to add to the list: 107
Enter the roll no that you want to add to the list: 108
Enter the roll no that you want to add to the list: 124
Enter the roll no that you want to add to the list: 112
Contents of the Roll No List are : 
101 103 107 108 124 112 

Update Data from the List Object::
Enter the old roll no that you want to update: 103
Enter the new roll no that you want to add: 104
The result after updating the List Object::
Contents of the Roll No List are : 
101 104 107 108 124 112 

Delete Data from the List Object::
Enter the roll no that you want to delete or remove from the list: 124
The result after delete operation on the List Object::
Contents of the Roll No List are : 
101 104 107 108 112

In the code that is written above, we can see that all the basic functions like inserting data to the list object, reading data from the list object, deleting the list object and updating data in the list object is performed successfully. The flow of the code written is like, first, we added six roll numbers to the list object named roll_nos. After the successful insertion of data in the list object, we confirmed the insertion by printing all the elements of the list object. After printing, the content or element of the list object is updated. In this case, we updated the data present at the first index having value 103 and replaced or updated that value by 104, and then printed the updated contents of the list object. After updation, we deleted an element from the list object. In this case, we deleted the element having value 124 and then printed the remaining list.

Java:

A sample java code to perform all the basic four operations like create, update, delete and update on the List Data Structure or Sequence object.

Code:

// a sample java code to implement all the basic functionalities on an object of list named names

// List class is imported from util package for use in the program
import java.util.List;
// ArrayList class is imported from util package for use in the program
import java.util.ArrayList;
// Scanner class is imported from util package for use in the program
import java.util.Scanner;
// A class named ListClass is created that will have four Function named add_data, print_data, update_data, and remove_data 
// that will perform the insertion, displaying, updation, and deletion operation respectively on the List object named names
class ListClass{
	// a static List object named names is created in which we store the names entered by the user 
	static List<String> names = new ArrayList<String>();

	// an object of Scanner class is also created to take input from the console
	static Scanner sc = new Scanner(System.in);

	// a Function named add_data is created to take input from the user with the help of the Scanner class object and then add that data to the List object
	public static void add_data(){

		// the input data will be temporary stored in the String object named data
		String data = null;

		System.out.println("Enter the name to be added in the list object : ");
		data = sc.nextLine();

		// data is added to the List object named names with the help of the add() Function
		names.add(data);

	}
	// a Function named print_data to display all the data that is present in the List object named names
	public static void print_data(){

		System.out.println();
		System.out.println("The data in the List Object is : ");
		// a for loop is used to iterate through the names object
		for(int index=0; index<names.size(); index++){

			System.out.print(names.get(index));
			System.out.print("\n");

		}
		System.out.println();		
	}
	// a Function named update_data is created that will be used to update or modify the already existing data present in the List object
	public static void update_data(){

		String old_data = null;
		String new_data = null;

		// the old data and the new data is taken as input from the user in two variables named old_data and new_data respectively 
		System.out.println("Enter the old data that needs to be updated : ");
		old_data = sc.nextLine();

		System.out.println("Enter the new data that will be updated : ");
		new_data = sc.nextLine();

		// the index of the old_data is found with the help of the indexOf() Function
		int sourceIndex = 0;
		sourceIndex = names.indexOf(old_data);
		// data is updated in the names list using the set() Function
		names.set(sourceIndex,new_data);
	}
	// a Function named remove_data is created to delete or remove the data present in the List object named names
	public static void remove_data(){
		String data = null;
		System.out.println("Enter the name to be deleted from the list object : ");
		data = sc.nextLine();
		// data is remove with the help of the remove() Function
		names.remove(data);

	}

}// end of ListClass class

//The main class is created to call the Function that is present in the ListClass class
class Main{


	// main function starts
	public static void main(String[] nk) {
		

		// An object of the ListClass class is created to call the Function that are present in the ListClass class
		ListClass object = new ListClass();

		// The add_data() Function is called five times to add data in the names object
		System.out.println("Enter data in the Data in the List Object :: ");
		object.add_data();
		object.add_data();
		object.add_data();
		object.add_data();
		object.add_data();

		// The print_data() Function is called to print data that is present in the List object named names
		object.print_data();
		System.out.println();


		// The update_data() Function is called to update or modify the already existing data
		System.out.println("Update the Data that is present in the List Object :: ");
		object.update_data();
		// The List is printed with the updated contents after the Update Operation
		System.out.println("The Result after the Update Operation :: ");
		object.print_data();
		System.out.println();


		// The remove_data() Function is called to remove or delete the data present in the List object named names 
		System.out.println("Delete a data that is present in the List Object :: ");
		object.remove_data();
		// The List is printed with the updated contents after the Delete Operation
		System.out.println("The Result after the Delete Operation :: ");
		object.print_data();
		System.out.println();


	}// main function ends
}// end of main class

Output:

Enter data in the Data in the List Object:: 
Enter the name to be added in the list object : 
Andrew
Enter the name to be added in the list object : 
Simon
Enter the name to be added in the list object : 
Paul
Enter the name to be added in the list object : 
Nirnay
Enter the name to be added in the list object : 
Dexteer

The data in the List Object is : 
Andrew
Simon
Paul
Nirnay
Dexteer


Update the Data that is present in the List Object:: 
Enter the old data that needs to be updated : 
Dexteer
Enter the new data that will be updated : 
Dexter
The Result after the Update Operation:: 

The data in the List Object is : 
Andrew
Simon
Paul
Nirnay
Dexter


Delete a data that is present in the List Object:: 
Enter the name to be deleted from the list object : 
Paul
The Result after the Delete Operation:: 

The data in the List Object is : 
Andrew
Simon
Nirnay
Dexter

In the code that is written above, we can see that all the basic functions like inserting data to the list object, reading data from the list object, deleting the list object and updating data in the list object is performed successfully. The flow of the code written is like, first, we added five names of the persons to the list object named names. After the successful insertion of data in the list object, we confirmed the insertion by printing all the elements of the list object. After printing, the content or element of the list object is updated. In this case, we updated the data present at the last index having the value 'Dexteer' and replaced or updated that value by 'Dexter', and then printed the updated contents of the list object by calling the print_names() function. After updation, we deleted an element from the list object. In this case, we deleted the element named paul and after the successful deletion of the string object named 'Paul,' we again confirmed the results by printing the updated list by giving a call to the print_names() function.

C++:

A sample C++ code to perform all the basic four operations like create, update, delete and update on the List Data Structure or Sequence object.

Code:

// a sample C++ code to implement all the basic functionalities on an object of list named names

// iostream is included to use the cin and cout objects to take input and print the result to the console respectively.
#include <iostream>
// list library is included to use the List provided by the C++ Standard Template Library
#include <list>
// string is included to store the elements in the List object in the string format with the use of this library
#include <string>
// the iterator library is included to iterate through the List object created 
// The traversal operation is required in deleting an element from the List object, updating an element in the List object, and printing the elements of the List object
#include <iterator>
using namespace std;
// an object of the List is created by the name 'names' that will be used to store the names that will be entered by the user
list<string> names;
// a Function named add_names is created to take input from the user with the help of cin object and then add that data to the List object named names
void add_names(string data){
	// the data is added in the names list with the help of push_back() Function
	names.push_back(data);
}
// a Function named print_names is created to display all the data that is present in the List object named names
void print_names(){
	// An iterator named 'it' is created to iterate through the List object named names
	list<string> :: iterator it;
	for(it = names.begin(); it != names.end(); ++it){
	    cout << *it;
	    cout<< std::endl;
	}
	cout << '\n';
}

// a Function named update_name is created that will be used to update or modify the already existing data present in the List object named names
void update_name(string old_data, string new_data){
	// First we iterate through the List object named names
	for (auto it = names.rbegin(); it != names.rend(); it++) {
		// when our current data in the List object is matched with the search key data that is stored in the variable named old_data  
	    if (*it == old_data) {
	    	// after the match the new data stored in the new_data variable is updated at that location
			*it = new_data;
		}
	}
}
// a Function named delete_data is created to delete or remove the data present in the List object named names
void delete_data(string data){
	// An iterator named 'it' is created to iterate through the List object named names
	list<string> :: iterator it =  names.begin();

	while(1){

		// when our current data in the List object is matched with the search key data that is stored in the variable named data 
		if(*it==data){

			// after the match the data to be deleted is removed from the List object with the use of the erase() Function
			names.erase(it);
			
			// after calling the erase() Function the while loop is broken in order to avoid further not required iterations
			break;
		}
		// if the match is not found then the iterator is incremented by one value to move its location to the next element of the List object
		++it;
	}
}

// main Function is written to call all these fucntions 
int main(){


	// the input is taken and add_names() Function is called five to add data to the List object named names
	cout<<"Enter Data in the List Object::";
	cout<<std::endl;
	string input;
	cout<<"Enter the name to be added to the List Object : ";
	cout<<std::endl;
	cin>>input;
	add_names(input);
	cout<<"Enter the name to be added to the List Object : ";
	cout<<std::endl;
	cin>>input;
	add_names(input);
	cout<<"Enter the name to be added to the List Object : ";
	cout<<std::endl;
	cin>>input;
	add_names(input);
	cout<<"Enter the name to be added to the List Object : ";
	cout<<std::endl;
	cin>>input;
	add_names(input);
	cout<<"Enter the name to be added to the List Object : ";
	cout<<std::endl;
	cin>>input;
	add_names(input);

	// Printing the data by calling the print_names() Function after sucessful addition to the List
	cout<<"The data in the List Object::"<<std::endl;
	print_names();

	// Two variables named data_to_update and data_to_add are declared that will be passed as parameters to the update_name() Function
	string data_to_update;
	string data_to_add;
	cout<<"Enter the already existing data that you want to update from the List Object:: ";
	cout<<std::endl;
	cin>>data_to_update;
	cout<<"Enter the data that you want to add to the List Object::";
	cout<<std::endl;
	cin>>data_to_add;

	// After taking input in the data_to_add and data_to_update variables teh update_name() Function is called by passing these variables as parameters to this fucntion to update the already existing data in the List object named names
	update_name(data_to_update,data_to_add);
	
	// after the sucessful updation of the elements of the List object named names the updated contents are printed calling the print_names() Function 
	cout<<"Result after the Update operation::";
	cout<<std::endl;
	print_names();
	// One string variable named delete_key is declared that will be passed as a parameter to the delete_data() Function
	string delete_key;
	cout<<"Enter the element from the List Object that you want to delete or remove::";
	cout<<std::endl;
	cin>>delete_key;

	// After taking input in the delete_key variable the delete_data() Function is called by passing this variable as parameter to this fucntion to delete the already existing data in the List object named names
	delete_data(delete_key);

	// after the sucessful deletion of the elements of the List object named names the updated contents are printed calling the print_names() Function 
	cout<<"Result after the Delete or Remove operation::";
	cout<<std::endl;
	print_names();
	return 0;
}// end of the main function

Output:

The output of the above code is:

Enter Data in the List Object::
Enter the name to be added to the List Object : 
Alex
Enter the name to be added to the List Object : 
Andrew
Enter the name to be added to the List Object : 
Pete
Enter the name to be added to the List Object : 
Samuel
Enter the name to be added to the List Object : 
Pauil
The data in the List Object::
Alex
Andrew
Pete
Samuel
Pauil

Enter the already existing data that you want to update from the List Object:: 
Pauil
Enter the data that you want to add to the List Object::
Paul
The result after the Update operation::
Alex
Andrew
Pete
Samuel
Paul

Enter the element from the List Object that you want to delete or remove::
Andrew
Result after the Delete or Remove operation::
Alex
Pete
Samuel
Paul

In the code that is written above, we can see that all the basic functions like inserting data to the list object, reading data from the list object, deleting the list object and updating data in the list object is performed successfully. The flow of the code written is like, first, we added five names of the persons to the list object named names. After the successful insertion of data in the list object, we confirmed the insertion by printing all the elements of the list object. After printing, the content or element of the list object is updated. In this case, we updated the data present at the last index having the value 'Pauil' and replaced or updated that value by 'Paul', and then printed the updated contents of the list object by calling the print_names() function. After updation, we deleted an element from the list object. In this case, we deleted the element named paul and after the successful deletion of the string object named 'Paul,' we again confirmed the results by printing the updated list by giving a call to the print_names() function.

JavaScript:

A sample JavaScript code to perform all the basic four operations like create, update, delete and update on the List Data Structure or Sequence object.

Code:

const car_names = [];
	var index = 0;
	// a Function named add_names is created to take input from the user with the help of cin object and then add that data to the List object named names
	function add_data(data){
		car_names[index] = data;
		index++;
	}
	// a Function named print_names is created to display all the data that is present in the List object named names
	function print_data(){
		console.log(car_names);
	}
	// a Function named update_name is created that will be used to update or modify the already existing data present in the List object named names
	function update_data(key, new_data){
		var new_index = car_names.indexOf(key);
		car_names[new_index]=new_data; 
	// a Function named delete_data is created to delete or remove the data present in the List object named names
	function delete_data(key){
		var key_index = car_names.indexOf(key);
	  	if (key_index > -1) {
	    	car_names.splice(key_index, 1);
	  	}
	}

	// main Function is written to call all these fucntions 
	function main(){

		// the add_data() fucntion is called 5 times to add the names of the cars
		add_data("BMW");
		add_data("Ferrari");
		add_data("Aston Martin");
		add_data("Land Rover");
		add_data("Audii");

		// the data is printed after adding five elements to the List object named car_names
		console.log("The Data in the list is :: ")
		print_data();

		// after the sucessful updation of the elements of the List object named car_names the updated contents are printed calling the print_data() Function 
		console.log("The Data in the list after the  sucessful Update Operation is :: ")
		update_data("Audii","Audi")
		print_data();

		// after the sucessful deletion of the elements of the List object named car_names the updated contents are printed calling the print_data() Function
		console.log("The Data in the list after the  sucessful Delete Operation is :: ")
		delete_data("BMW");
		print_data();
	}

	main();

Output:

The output of the above code is:

The Data in the list after the  sucessful Insertion Operation is :: 
[ 'BMW', 'Ferrari', 'Aston Martin', 'Land Rover', 'Audii' ]
The Data in the list after the  sucessful Update Operation is :: 
[ 'BMW', 'Ferrari', 'Aston Martin', 'Land Rover', 'Audi' ]
The Data in the list after the  sucessful Delete Operation is :: 
[ 'Ferrari', 'Aston Martin', 'Land Rover', 'Audi' ]

So, this article explains the List Data Structure and what are the basic functions or operations that we can perform on a List Data Structure object. We also understood the usage of the List Data Structure in various programming languages like Java, Python, and C++ along with their functionalities that are required to perform the basic operations on this Data Structure. Other than these examples, there are various scenarios where we can use the List Data Structure. The most ideal scenario for using the List Data Structure is where we need to store our data in a single sequence object.

Next TopicTypes of Tree in Data Structure

← prev next →