In order to use linked memory, we usually define a structure, called linked list. To form a linked list, at first, we define a node. A node comprises two fields. i.e. the object field that holds the actual list element and the next that holds the starting location of the next node.
A chain of these nodes forms a linked list. Now let’s consider our previous list, used with an array i.e . 2, 6, 8, 7, 1. Following is the figure which represents the list stored as a linked list. This diagram just represents the linked list. In the memory, different nodes may occur at different locations but the next part of each node contains the address of the next node. Thus it forms a chain of nodes which we call a linked list.
While using an array we knew that the array started from index 1that means the first element of the list is at index 1. Similarly in the linked list we need to know the starting point of the list. For this purpose, we have a pointer head that points to the first node of the list. If we don’t use head, it will not be possible to know the starting position of the list. We also have a pointer current to point to the current node of the list. We need this pointer to add or remove current node from the list. Here in the linked list, the current is a pointer and not an index as we used while using an array. The next field of the last node points to nothing .It is the end of the list. We place the memory address NULL in the last node. NULL is an invalid address and is inaccessible.
Now again consider the list 2, 6, 8, 7, 1. The previous figure represents this list as a linked list. In this linked list, the head points to 2, 2 points to 6, 6 points to 8, 8 points to 7 and 7 points to 1. Moreover we have the current position at element 8.
This linked list is stored in the memory. The following diagram depicts the process through which this linked list is stored in the memory.
There are two parts of this figure. On the left is the linked list chain that is actually the conceptual view of the linked list and on the right is the linked list inside the computer memory. Right part is a snapshot of the computer memory with memory addresses from 1051 to 1065. The head pointer is pointing to the first element in the linked list. Note that head itself is present in the memory at address 1062. It is actually a pointer containing the memory address 1054. Each node in the above linked list has two parts i.e. the data part of the node and the pointer to the next node. The first node of the linked list pointed by the head pointer is stored at memory address 1054. We can see the data element 2 present at that address. The second part of the first node contains the memory address 1051. So the second linked list’s node starts at memory address 1051. We can use its pointer part to reach the third node of the list and in this way, we can traverse the whole list. The last node contains 1 in its data part and 0 in its pointer part. 0 indicates that it is not pointing to any node and it is the last node of the linked list.
Linked List Operations
The linked list data structure provides operations to work on the nodes inside the list.
The first operation we are going to discuss here is to create a new node in the memory. The Add(9) is used to create a new node in the memory at the current position to hold ‘9’. You must remember while working with arrays, to add an element at the current position that all the elements after the current position were shifted to the right and then the element was added to the empty slot.
Here, we are talking about the internal representation of the list using linked list. Its interface will remain the same as in case of arrays.
We can create a new node in the following manner in the add() operation of the linked list with code in C++:
Node * newNode = new Node(9);
The first part of the statement that is on the left of the assignment is declaring a variable pointer of type Node. It may also be written as Node * newNode. On the right of this statement, the new operator is used to create a new Node object as new Node(9). This is one way in C++ to create objects of classes. The name of the class is provided with the new operator that causes the constructor of the class to be called. The constructor of a class has the same name as the class and as this a function, parameters can also be passed to it. In this case, the constructor of the Node class is called and ‘9’ is passed to it as an int parameter.
Hence, the whole statement means:
“Call the constructor of the Node class and pass it ‘9’ as a parameter. After constructing the object in memory, give me the starting memory address of the object. That address will be stored in the pointer variable newNode.”
To create an object of int type in the same manner, we can write as:
int * i = new int ;
Previously, we used the same technique to allocate memory for an array of int as:
int * i = new int [10] ;
Now after the node has been created, how the node is fit into the chain of the linked list.
Fig 2. Insertion of new Node into the linked list
In the above figure, there is a linked list that contains five nodes with data elements as 2, 6, 8, 7 and 1. The current pointer is pointing to the node with element as 8. We want to insert a new node with data element 9. This new node will be inserted at the current position (the position where the current pointer is pointing to). This insertion operation is performed in a step by step fashion.
- The first step is to point next pointer of the new node (with data element as 9) to the node with data element as 7.
- The second step is to point the next pointer of the node with data element 8 to the node the new node with data element 9.
- The third step is to change the current pointer to point to the new node.
Now, the updated linked list has nodes with data elements as 2, 6, 8, 9, 7 and 1. The list size has become 6.
Linked List Using C++
/* The Node class */
class Node
{
public:
int get() { return object; };
void set(int object) { this->object = object; };
Node * getNext() { return nextNode; };
void setNext(Node * nextNode) { this->nextNode = nextNode; };
private:
int object;
Node * nextNode;
};
|
Whenever, we write a class, it begins with the word class followed by the class-name and the body of the class enclosed within curly braces. In the body, we write its public variables, methods and then private variables and methods, this is normally the sequence.
If there is no code to write inside the constructor function of a class, we need not to declare it ourselves as the compiler automatically creates a default constructor for us. Similarly, if there is nothing to be done by the destructor of the class, it will be better not to write it explicitly. Rather, the compiler writes it automatically. Remember, the default constructor and destructor do nothing as these are the function without any code statements inside.
Let’s start with the data members first. These are given at the bottom of the class body with the scope mentioned as private. These data members are actually two parts of a linked list’s node. First variable is object of type int, present there to store the data part of the node. The second variable is nextNode, which is a pointer to an object of type Node. It has the address of the next element of the linked list.
The very first public function given at the top is get(). We have written its code within the class Node. It returns back the value of the variable object i.e. of the type of int.
When we write class in C++, normally, we make two files (.h and .cpp) for a class. The .h file contains the declarations of public and private members of that class. The public methods are essentially the interface of the class to be employed by the users of this class. The .cpp file contains the implementation for the class methods that has the actual code. This is usually the way that we write two files for one class. But this is not mandatory. In the code given above, we have only one file .cpp, instead of separating into two files. As the class methods are very small, so their code is written within the body of the class. This facilitates us in carrying on discussion. Thus instead of talking about two files, we will only refer to one file. On the other hand, compiler takes these functions differently that are called inline functions. The compiler replaces the code of these inline functions wherever the call to them is made.
The second method in the above-mentioned class is set() that accepts a parameter of type int while returning back nothing. The accepted parameter is assigned to the internal data member object. Notice the use of this pointer while assigning the value to the internal data member. It is used whenever an object wants to talk to its own members.
The next method is getNext() which returns a pointer to an object of type Node lying somewhere in the memory. It returns nextNode i.e. a pointer to an object of type Node. As discussed above, nextNode contains the address of next node in the linked list.
The last method of the class is setNext() that accepts a pointer of type Node, further assigned to nextNode data member of the object. This method is used to connect the next node of the linked list with the current object. It is passed an address of the next node in the linked list.
Let’s discuss a little bit about classes. A very good analogy of a class is a factory. Think about a car factory. On the placement of order, it provides us with the number of vehicles we ordered for. Similarly, you can see number of other factories in your daily-life that manufacture the specific products.
Let’s take this analogy in C++ language. Suppose, we want to make a factory in C++. By the way, what is our Node class? It is actually a factory that creates nodes. When we want to make a new node, a new operator is used. By using new operator with the Node class, actually, we send an order to Node factory, to make as many as nodes for us.
So we have a good analogy, to think about a class as a factory. The products that are made by the factory have their own characteristics. For example, a car made by an automobile factory has an engine, wheels, steering and seats etc. These variables inside a class are called state variables. Now the kinds of operations this car can do are the methods of its class. A car can be driven, engine can be started, gears can be shifted and an accelerator can be pressed to run it faster.
Similarly, the Node class creates nodes, where every node has two-state variables i.e. object and nextNode. We have already seen its operations in the above code. We use new to create new object or an array of new objects, stored in memory.
Let’s see the code below.
/* List class */
#include <stdlib.h>
#include "Node.cpp"
class List
{
public:
// Constructor
List() {
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
size = 0;
}
|
We are creating a list factory here employed to create list objects. Remember the list operations; add, remove, next, back and start etc. Let’s see the above class declaration code in detail.
There are two include statements at the start. The first line is to include a standard library stdlib.h while the second line includes the Node class file Node.cpp. This Node class is used to create nodes that form a List object. So this List factory will order Node class to create new nodes. The List class itself carries out the chain management of these Node objects.
We have written our own constructor of List class as the default constructor is not sufficient enough to serve the purpose. The List constructor is parameterless. The very first step it is doing internally is that it is asking Node class to create a new node and assigning the starting address of the new Node’s object to the headNode data member. In the second statement, we are calling setNext() method of the Node class for the object pointed to by the headNode pointer. This call is to set the nextNode data member to NULL, i.e. Node’s object pointed to by the headNode pointer is not pointing to any further Node. The next statement is to set the currentNode pointer to NULL. So at the moment, we have initialized the currentNode pointer to NULL that is not pointing to any Node object. The next statement is to initialize the size data member to 0 indicating that there is no node present in the list. All this processing is done inside the constructor of List class, as we want all this done when a list object is created. Considering the analogy of car factory, the constructor function can perform certain tasks: The oil is poured into the engine, the tyres are filled-in with air etc.
Let’s see the add method of the List class:
/* add() class method */
void add (int addObject)
{
1. Node * newNode = new Node();
2. newNode->set(addObject);
3. if( currentNode != NULL )
4. {
5. newNode->setNext(currentNode->getNext());
6. currentNode->setNext( newNode );
7. lastCurrentNode = currentNode;
8. currentNode = newNode;
9. }
10. else
11. {
12. newNode->setNext(NULL);
13. headNode->setNext(newNode);
14. lastCurrentNode = headNode;
15. currentNode = newNode;
16. }
17. size ++;
}
|
The interface or signatures of add() method is similar to the one discussed in case of an array. This method takes the object to be added as a parameter. The implementation of this add() method is a bit longer as the method is being implemented for linked list. In the first statement, a new Node object is created with its address stored in the newNode pointer variable. The second statement is to call set() method of the Node object pointed to by the newNode pointer. You can note the way the method is called. A pointer variable is at the left most side then an arrow sign (->), then the name of the method with appropriate arguments within parenthesis. It is followed by the if-statement that checks the currentNode is not NULL to perform certain operations inside the if-code block. Inside the if-statement, at line 5, the nextNode pointer of the new node is being set to the nextNode of the object pointed to by the currentNode pointer. In order to understand the statements given in this code properly, consider the fig 2 above, where we added a node in the linked list. We have done step 1 at line5. At line 6, we are performing the second step by setting the newNode in the nextNode pointer of the object pointed to by the currentNode. At line 7, we are saving the current position (address) of the currentNode pointer in the pointer variable lastCurrentNode, which might be useful for backward traversing. Although, the fig 1 (left part) indicates movement in one direction from left to right but the lastCurrentNode pointer node can be used by the back() member function to traverse one position back from right to left. At line 8, the currentNode pointer is assigned the address of the object pointed to by newNode. This way, a new node is added in already existent linked list.
Line 10 is start of the else part of if-statement. This is executed if the currentNode is NULL. It means that there is no node present in the list previously and first node is going to be added. At line 12, we are setting the nextNode pointer of the object pointed to by newNode pointer. The nextNode is being set to NULL by calling the setNext() method. Then at line 13, we point the head pointer (headNode) to this new node pointed to by newNode pointer. Note that headNode is pointing to a node that is there despite the fact that the size of the linked list is 0. Actually, we have allocated a Node object for headNode pointer. Although, we don’t need a Node object here, yet it will be helpful when we perform other operations like remove() and find().
At line 14, the headNode address is being assigned to lastCurrentNode. At line 15, currentNode pointer is assigned the address of newNode. At the end i.e. at line 17, the size of the list is incremented by 1.
Fig 3. Add operation of linked list
Following is the crux of this add() operation :
Firstly, it will make a new node by calling Node class constructor. Insert the value e.g. 2. of the node into the node by calling the set method. Now if the list already exists (has some elements inside or its size is non-zero), it will insert the node after the current position. If the list does not already exist, this node is added as the first element inside the list.
Let’s try to add few more elements into the above linked list in the figure. The following are the lines of code to be executed to add nodes with values 8, 7 and 1 into the linked list.
list.add(8); list.add(7); list.add(1);
Fig 4. More Nodes added into linked list
Now we will see the remaining methods of the linked list. The get() method of the List class is given below
/* get() class method */
int get()
{
if (currentNode != NULL)
return currentNode->get();
}
|
This method firstly confirms that the currentNode pointer is not NULL. If it is not NULL, then it must be pointing to some Node object as inside the constructor of the List class, we have initialized this pointer variable to NULL. That indicates that the currentNode is NULL when there is no element inside the list. However, when a Node object is added into it, it starts pointing to it. So, this get() returns the address of the node pointed to by the currentNode pointer.
Further, we have another method given below:
/* next() class method */
bool next()
{
1. if (currentNode == NULL) return false;
2.
3. lastCurrentNode = currentNode;
4. currentNode = currentNode->getNext();
5. return true;
};
|
This is next() method, used to advance the currentNode pointer to the next node inside the linked list. At line 1, the currentNode is being checked to confirm that there are some elements present in the list to advance further. At line 1, the method is returning false if there is no element present in the list. At line 3, it is storing the value of the currentNode pointer into the lastCurrentNode. At line 4, currentNode is calling the getNext() method to get the address of next node to be stored in the currentNode pointer to advance the currentNode pointer to the next element. At line 5, it returns true indicating the method is successful in moving to the next node.
Example Program
Given below is the full source code of the example program. You can copy, paste and compile it right away. In order to understand the linked list concept fully, it is highly desirable that you understand and practice with the below code.
#include <iostream.h>
#include <stdlib.h>
/* The Node class */
class Node
{
public:
int get() { return object; };
void set(int object) { this->object = object; };
Node * getNext() { return nextNode; };
void setNext(Node * nextNode) { this->nextNode = nextNode; };
private:
int object;
Node * nextNode;
};
/* The List class */
class List
{
public:
List();
void add (int addObject);
int get();
bool next();
friend void traverse(List list);
friend List addNodes();
private:
int size;
Node * headNode;
Node * currentNode;
Node * lastCurrentNode;
};
/* Constructor */
List::List()
{
headNode = new Node();
headNode->setNext(NULL);
currentNode = NULL;
lastCurrentNode = NULL;
size = 0;
}
/* add() class method */
void List::add (int addObject)
{
Node * newNode = new Node();
newNode->set(addObject);
if( currentNode != NULL )
{
newNode->setNext(currentNode->getNext());
currentNode->setNext( newNode );
lastCurrentNode = currentNode;
currentNode = newNode;
}
else
{
newNode->setNext(NULL);
headNode->setNext(newNode);
lastCurrentNode = headNode;
currentNode = newNode;
}
size ++;
}
/* get() class method */
int List::get()
{
if (currentNode != NULL)
return currentNode->get();
}
/* next() class method */
bool List::next()
{
if (currentNode == NULL) return false;
lastCurrentNode = currentNode;
currentNode = currentNode->getNext();
if (currentNode == NULL || size == 0)
return false;
else
return true;
}
/* Friend function to traverse linked list */
void traverse(List list)
{
Node* savedCurrentNode = list.currentNode;
list.currentNode = list.headNode;
for(int i = 1; list.next(); i++)
{
cout << "\n Element " << i << " " << list.get();
}
list.currentNode = savedCurrentNode;
}
/* Friend function to add Nodes into the list */
List addNodes()
{
List list;
list.add(2);
list.add(6);
list.add(8);
list.add(7);
list.add(1);
cout << "\n List size = " << list.size <<'\n';
return list;
}
main()
{
List list = addNodes();
traverse(list);
}
|
The output of the example program is as follows:
List size = 5
Element 1 2
Element 2 6
Element 3 8
Element 4 7
Element 5 1
|
![clip_image017[1]](http://lh3.ggpht.com/-vSgdtst2ajU/UI2PgdpoJUI/AAAAAAAAArM/gUCrg0wMFpE/s1600-h/clip_image017%25255B1%25255D%25255B4%25255D.jpg "clip_image017[1]")
![clip_image017[2]](http://lh3.ggpht.com/-4FMzwIPgu7o/UI2Pin_zItI/AAAAAAAAArc/g_Ltdxf49UM/s1600-h/clip_image017%25255B2%25255D%25255B4%25255D.jpg "clip_image017[2]")
![clip_image011[1]](http://lh6.ggpht.com/-E4Dbk3UFKIA/UI2Pux0NbdI/AAAAAAAAAss/Grwn2DWnUEQ/s1600-h/clip_image011%25255B1%25255D%25255B4%25255D.jpg "clip_image011[1]")
![clip_image015[1]](http://lh3.ggpht.com/-GIfqRN4_iNA/UI2P-faIddI/AAAAAAAAAt8/QER_JQcYR8k/s1600-h/clip_image015%25255B1%25255D%25255B3%25255D.jpg "clip_image015[1]")
![clip_image008[1]](http://lh3.ggpht.com/-Hz2XxD6uSeM/UI2QYLSZF9I/AAAAAAAAAv8/cTVCY4mioNg/s1600-h/clip_image008%25255B1%25255D%25255B2%25255D.jpg "clip_image008[1]")
![clip_image015[2]](http://lh3.ggpht.com/-LzueE_-qny0/UI2Qkt3be_I/AAAAAAAAAxM/1TcMwSQ1gc0/s1600-h/clip_image015%25255B2%25255D%25255B3%25255D.jpg "clip_image015[2]")
![clip_image043[1]](http://lh3.ggpht.com/-R53dob_H-3g/UI2Qn3p2z_I/AAAAAAAAAxc/W2wWxhQpDQE/s1600-h/clip_image043%25255B1%25255D%25255B3%25255D.jpg "clip_image043[1]")
