Hi! This is not a tutorial, though I'll explain any code I post here. On this blog I post source codes of various programs I have written, though the questions/programming problems may or may not be my own. These include solutions to some questions of some good books too. Not too language specific, since I'll be posting codes in C, C++, Java, C#, etc. For contact information, see my Disclosure Policy, for more info, check out my first post: http://letsplaycoding.blogspot.com/2014/03/welcome.html
To implement alternate split operation on Linked List.
Explanation of Problem
In this program we would be implementing a Linked List. Make sure you have a strong understanding of pointers to understand Linked Lists. A linked list is a basic data structure that is used in dynamic memory allocation applications. It comprises of 'nodes' which are linked together to form a sequence of nodes called Linked List. The linkage is done using memory addresses of adjacent nodes (next node in singly linked list, and both next & previous node in doubly linked list).
In this program we use a struct to implement the node of our linked list. We will implement addition function to get some data in linked list before we can perform desired operations on it. Adding a new node to the list means, creating a new node structure, allocating memory to it and linking it to the list.
Consider we have a linked list. With alternate split operation, we output two lists. If we number our elements in the list like 0, 1, 2, 3, 4..., then each element at even position goes to list one, and other elements to list two. For example, our original input list is 1 -> 2 -> 3 -> 4 -> 5. Output would be two lists, i.e., 1 -> 3 -> 5 and 2 -> 4.
#include <iostream> -> The compiler calls the Preprocessor to include the IOSTREAM(Standard Input / Output Streams Library) header file into the program, thus letting the use of the Standard Input / Output Streams functions like std::cin and std::cout. As per C++11 specification, including <iostream> automatically includes also <ios>, <streambuf>, <istream>, <ostream> and <iosfwd>.
int main() -> The entry point of the program where the execution starts. This function has to be named main. As per the ANSI specification, the return type has to be int. Since the return type is specified as int in my program, I have to use a return statement at the end of my code. So I use return 0 since zero returned from a function, by convention, implies a correct execution of the program. The return values are used to debug the program.
std::cin (extern istream cin) -> Standard Input Stream, and object of class istream. It is generally used with the extraction operator (>>), though we can use member functions like get (cin.get()), read (cin.read()), etc. for the input. The use of extraction operator is much more popular due to the fact that it aids in getting formatted input.
std::cout (extern ostream cout) -> Standard Output Stream, and object of class ostream. It is generally used with the insertion operator (<<), though we can use member functions like write (cout.write()) for the output. The use of insertions operator is much more popular due to the fact that it aids in giving formatted output.
using namespace std; -> In modern IDEs, we have to explicitly write std::cout instead of cout to use the ostream cout object. Namespace std helps in easing off the pain of writing std:: again and again. Though make sure you are not trapped! The classes defined in std should not be redefined by you. So in case you want to define a class 'distance', you can't do so if you have used std namespace. Though you can define 'Distance' (capital D).
std::endl (ostream& endl (ostream& os)) -> This is a function which is used to insert a newline character and flush the stream. Because this function is a manipulator, it is designed to be used alone with no arguments in conjunction with the insertion (<<) operations on output streams.
struct node
{
int data;
node* next;
}; ->
This is where we create the struct node that is going to be the building block of our linked list. It comprises of an int 'data' where the user shall store the data they wish. Please note, you can use as many variables and of as many types in the struct, but be sure you handle them correctly. For simplicity we have used int type in our case. The other variable inside our node is 'next', which is a pointer to node. This would be used to build the linkage between the nodes of our linked list. 'next' is going to hold the address of the next node in the sequence.
node* startListFirst; node* startListSecond; -> These are the pointers, which we are going to use to point to the first node / root node / start node of the linked list, that will be out output from the alternate split function, which we are going to implement in this program.
int choice; -> This variable 'choice' will be used for the user’s choice in the menu driven program.
This function is used to add a new node at the end of our linked list. The user input which is fed as a parameter to the function, is stored in the ‘newNode’ which is the pointer to the new node that we are going to add to our list. The first statement of this function means, memory is allocated for a node type variable and a pointer is returned which we capture in the variable ‘newNode’. The program checks if the list is empty which we come to know if the ‘rootNode’, i.e., root node of the linked list is initialised as yet or not. If the root node is not yet initialised for our list, we make the ‘rootNode’ pointer to point to the ‘newNode’ we just created. Else, we traverse through the list. Starting from the root node, we hold the position in a new pointer, ‘currentNode’. Since the last node’s ‘next’ won't point to any node, thus we use currentNode->next != NULL for that. Till so is the case, we keep on assigning the address of the next node in sequence to the pointer ‘currentNode’. So as and when we encounter the last node in the list, we come out of the loop. The pointer ‘currentNode’ now holds the address to the last node in the list. So we define the ‘next’ for this last node of ours as the newNode we just created. Now the next of newNode is set to NULL, hence the newNode is added at the end of the list.
We first check if our original list is empty. If so, we prompt the user about it and exit out of the function. Else we go ahead.
We traverse through the list, and assign the nodes to our lists alternatingly. We start at with the rootNode of our original list, as done in the line node *currentNode = rootNode;. Until we encounter NULL, representing the end of list, we traverse through the list. We then add the first node to first list by calling addToLast function, and passing the reference of rootNode of first list and the data at the current node to the call. Then we move our pointer, currentNode, to the next node. If the next node is not end of list (not NULL), then we add this node to the second list by calling addToList function. We pass the rootNode reference of second list and the data at the current node to the function call to do this, and we move the pointer, currentNode, to next node.
The approach we are using reduces the number of iterations of the loop to half the size of list, though we are traversing every node internally in the loop.
At the end we have two lists, pointed by the input reference pointers, passed as paramter 2 and parameter 3 to our function.
This function is used to display the list. The functions accepts the address of the root node as the argument. It then starts traversing through the list from root node, until it finds a node which points to NULL as the next element, indicating the end of list. While traversing through, the function displays the values held in each node on the screen separated by '->'.
do{..}while() -> The program loop which encapsulates the whole program. Until the user chooses to exit the program, the control loops within this.
exit(0); -> This function is used to exit the program with an error code as it's argument. '0' implies normal exit. Other values are used for debugging purposes.
std::cin.get() -> This statement is used to pause our program, until user presses a key. This function is not necessary in your program, I use it to see my outputs at a paused screen. If you use cmd to run your programs, you might not need this. If you use linux/unix you might not need this. Moreover, removing this line of code from this program, doesn't affect the functionality of the program.
To implement intersection operation on Linked List.
Explanation of Problem
In this program we would be implementing a Linked List. Make sure you have a strong understanding of pointers to understand Linked Lists. A linked list is a basic data structure that is used in dynamic memory allocation applications. It comprises of 'nodes' which are linked together to form a sequence of nodes called Linked List. The linkage is done using memory addresses of adjacent nodes (next node in singly linked list, and both next & previous node in doubly linked list).
In this program we use a struct to implement the node of our linked list. We will implement addition function to get some data in linked list before we can perform desired operations on it. Adding a new node to the list means, creating a new node structure, allocating memory to it and linking it to the list.
Consider we have two linked lists. Intersection means finding those unique nodes which are common to both the lists. For example, if we have two lists, 1->2->3->4 and 1->1->2->8->4->6, then the intersection is 1->2->4.
#include <iostream> -> The compiler calls the Preprocessor to include the IOSTREAM(Standard Input / Output Streams Library) header file into the program, thus letting the use of the Standard Input / Output Streams functions like std::cin and std::cout. As per C++11 specification, including <iostream> automatically includes also <ios>, <streambuf>, <istream>, <ostream> and <iosfwd>.
int main() -> The entry point of the program where the execution starts. This function has to be named main. As per the ANSI specification, the return type has to be int. Since the return type is specified as int in my program, I have to use a return statement at the end of my code. So I use return 0 since zero returned from a function, by convention, implies a correct execution of the program. The return values are used to debug the program.
std::cin (extern istream cin) -> Standard Input Stream, and object of class istream. It is generally used with the extraction operator (>>), though we can use member functions like get (cin.get()), read (cin.read()), etc. for the input. The use of extraction operator is much more popular due to the fact that it aids in getting formatted input.
std::cout (extern ostream cout) -> Standard Output Stream, and object of class ostream. It is generally used with the insertion operator (<<), though we can use member functions like write (cout.write()) for the output. The use of insertions operator is much more popular due to the fact that it aids in giving formatted output.
using namespace std; -> In modern IDEs, we have to explicitly write std::cout instead of cout to use the ostream cout object. Namespace std helps in easing off the pain of writing std:: again and again. Though make sure you are not trapped! The classes defined in std should not be redefined by you. So in case you want to define a class 'distance', you can't do so if you have used std namespace. Though you can define 'Distance' (capital D).
std::endl (ostream& endl (ostream& os)) -> This is a function which is used to insert a newline character and flush the stream. Because this function is a manipulator, it is designed to be used alone with no arguments in conjunction with the insertion (<<) operations on output streams.
struct node
{
int data;
node* next;
}; ->
This is where we create the struct node that is going to be the building block of our linked list. It comprises of an int 'data' where the user shall store the data they wish. Please note, you can use as many variables and of as many types in the struct, but be sure you handle them correctly. For simplicity we have used int type in our case. The other variable inside our node is 'next', which is a pointer to node. This would be used to build the linkage between the nodes of our linked list. 'next' is going to hold the address of the next node in the sequence.
node* startListFirst; node* startListSecond; -> These are the pointers, which we are going to use to point to the first node / root node / start node of the linked list, that we are going to implement in this program.
int choice; -> This variable 'choice' will be used for the user’s choice in the menu driven program.
This function is used to add a new node at the end of our linked list. The user input which is fed as a parameter to the function, is stored in the ‘newNode’ which is the pointer to the new node that we are going to add to our list. The first statement of this function means, memory is allocated for a node type variable and a pointer is returned which we capture in the variable ‘newNode’. The program checks if the list is empty which we come to know if the ‘rootNode’, i.e., root node of the linked list is initialised as yet or not. If the root node is not yet initialised for our list, we make the ‘rootNode’ pointer to point to the ‘newNode’ we just created. Else, we traverse through the list. Starting from the root node, we hold the position in a new pointer, ‘currentNode’. Since the last node’s ‘next’ won't point to any node, thus we use currentNode->next != NULL for that. Till so is the case, we keep on assigning the address of the next node in sequence to the pointer ‘currentNode’. So as and when we encounter the last node in the list, we come out of the loop. The pointer ‘currentNode’ now holds the address to the last node in the list. So we define the ‘next’ for this last node of ours as the newNode we just created. Now the next of newNode is set to NULL, hence the newNode is added at the end of the list.
bool findNode(node* rootNode, int findData)
{
node *currentNode = rootNode;
while (currentNode)
{
if (currentNode -> data == findData)
return true;
currentNode = currentNode -> next;
}
return false;
} ->
This is a helper/utility function for our program. Though it is not necessary, we have implemented it as a function to keep the code cleaner, and modular. This is a simple function, which is used to ascertain if the value is present in a given list or not. The code traverses through the list, the rootNode pointer of which is passed to it. While traversing it looks for the value passed as the second parameter. If the value is found in the list, the function returns true, else it returns false.
This function implements the intersection operation on 2 linked lists which are passed to the function, and create a new list starting at the address passed as third argument.
We first check if either list empty. If so, we simply return, since that means there would be nothing common between the lists. Else, we traverse through the lists and seek common values between them. If such value is found, we add it to the intersection output list, provided it is not already present there. We check the latter using our helper function findNode, passing it the value we have found and the rootNode of the intersection output linked list.
The outer while loop traverses throuhg list one, and the inner loop traverses through list two, comparing each node of the lists. if (thisNode -> data == currentNode -> data && ! findNode(*rootIntersect, thisNode -> data)) statement checks if the value is present in both the lists, and is not yet fed to intersection output. The first half compares the values. The second half checks if the value is present i nthe output already or not. Since we want to keep only unique values going in, we need this second check in place.
This function is used to display the list. The functions accepts the address of the root node as the argument. It then starts traversing through the list from root node, until it finds a node which points to NULL as the next element, indicating the end of list. While traversing through, the function displays the values held in each node on the screen separated by '->'.
do{..}while() -> The program loop which encapsulates the whole program. Until the user chooses to exit the program, the control loops within this.
exit(0); -> This function is used to exit the program with an error code as it's argument. '0' implies normal exit. Other values are used for debugging purposes.
std::cin.get() -> This statement is used to pause our program, until user presses a key. This function is not necessary in your program, I use it to see my outputs at a paused screen. If you use cmd to run your programs, you might not need this. If you use linux/unix you might not need this. Moreover, removing this line of code from this program, doesn't affect the functionality of the program.
