Data Structures Using C- Problems and Solutions by Mukherjee India - Free download as PDF mmoonneeyy.info) or read online for free. Data Structures Using C- Problems and Solutions by Mukherjee India. DownloadReport. Published on Mar View Download AddThis . Data Structure Using C By Tanenbaum - ??Data Structure Using C By mmoonneeyy.info Data Structures and Algorithm Analysis in C++, Data structures.
|Language:||English, Spanish, German|
|Genre:||Health & Fitness|
|ePub File Size:||17.47 MB|
|PDF File Size:||10.19 MB|
|Distribution:||Free* [*Regsitration Required]|
Data-Structures-Using-CProblems-and-Solutions-by- mmoonneeyy.info - Free download as PDF File .pdf) or read online for free. Data Structures Using C- Problems and Solutions by Mukherjee India. September 29, | Author: Invalid or corrupted PDF file. More Information. Download Data Structures Using C- Problems and Solutions by Mukherjee India.
The next node after the last node is the first node. Another example is the merging two sorted lists: After defining separate structures for each type of data, a generic structure can be defined that contains the minimum amount of data shared by all the other structures and contained at the top beginning of the structures. The problem of machine translation for natural language processing led Victor Yngve at Massachusetts Institute of Technology MIT to use linked lists as data structures in his COMIT programming language for computer research in the field of linguistics. One may also use a sentinel node at the end of the list, with an appropriate data field, to eliminate some end-of-list tests.
Another example is the merging two sorted lists: However, sentinel nodes use up extra space especially in applications that use many short lists , and they may complicate other operations such as the creation of a new empty list. However, if the circular list is used merely to simulate a linear list, one may avoid some of this complexity by adding a single sentinel node to every list, between the last and the first data nodes.
With this convention, an empty list consists of the sentinel node alone, pointing to itself via the next-node link. The list handle should then be a pointer to the last data node, before the sentinel, if the list is not empty; or to the sentinel itself, if the list is empty. The same trick can be used to simplify the handling of a doubly linked linear list, by turning it into a circular doubly linked list with a single sentinel node.
However, in this case, the handle should be a single pointer to the dummy node itself. When manipulating linked lists in-place, care must be taken to not use values that you have invalidated in previous assignments. This makes algorithms for inserting or deleting linked list nodes somewhat subtle. This section gives pseudocode for adding or removing nodes from singly, doubly, and circularly linked lists in-place.
Throughout we will use null to refer to an end-of-list marker or sentinel , which may be implemented in a number of ways. Our node data structure will have two fields.
We also keep a variable firstNode which always points to the first node in the list, or is null for an empty list. Traversal of a singly linked list is simple, beginning at the first node and following each next link until we come to the end:.
The following code inserts a node after an existing node in a singly linked list. The diagram shows how it works. Inserting a node before an existing one cannot be done directly; instead, one must keep track of the previous node and insert a node after it.
Inserting at the beginning of the list requires a separate function. This requires updating firstNode. Similarly, we have functions for removing the node after a given node, and for removing a node from the beginning of the list.
The diagram demonstrates the former. To find and remove a particular node, one must again keep track of the previous element.
Notice that removeBeginning sets list. Since we can't iterate backwards, efficient insertBefore or removeBefore operations are not possible. Inserting to a list before a specific node requires traversing the list, which would have a worst case running time of O n. Appending one linked list to another can be inefficient unless a reference to the tail is kept as part of the List structure, because we must traverse the entire first list in order to find the tail, and then append the second list to this.
In the Lisp family of languages, list appending is provided by the append procedure. Many of the special cases of linked list operations can be eliminated by including a dummy element at the front of the list. This ensures that there are no special cases for the beginning of the list and renders both insertBeginning and removeBeginning unnecessary.
In this case, the first useful data in the list will be found at list. In a circularly linked list, all nodes are linked in a continuous circle, without using null.
For lists with a front and a back such as a queue , one stores a reference to the last node in the list. The next node after the last node is the first node. Elements can be added to the back of the list and removed from the front in constant time. Both types of circularly linked lists benefit from the ability to traverse the full list beginning at any given node. This often allows us to avoid storing firstNode and lastNode , although if the list may be empty we need a special representation for the empty list, such as a lastNode variable which points to some node in the list or is null if it's empty; we use such a lastNode here.
This representation significantly simplifies adding and removing nodes with a non-empty list, but empty lists are then a special case. Assuming that someNode is some node in a non-empty circular singly linked list, this code iterates through that list starting with someNode:. If the test was moved to the beginning of the loop, the procedure would fail whenever the list had only one node.
This function inserts a node "newNode" into a circular linked list after a given node "node". If "node" is null, it assumes that the list is empty.
Suppose that "L" is a variable pointing to the last node of a circular linked list or null if the list is empty. To append "newNode" to the end of the list, one may do. Languages that do not support any type of reference can still create links by replacing pointers with array indices.
The approach is to keep an array of records , where each record has integer fields indicating the index of the next and possibly previous node in the array. Not all nodes in the array need be used. If records are also not supported, parallel arrays can often be used instead.
A linked list can be built by creating an array of these structures, and an integer variable to store the index of the first element. Links between elements are formed by placing the array index of the next or previous cell into the Next or Prev field within a given element.
For example:. In the above example, ListHead would be set to 2, the location of the first entry in the list.
Notice that entry 3 and 5 through 7 are not part of the list.
These cells are available for any additions to the list. By creating a ListFree integer variable, a free list could be created to keep track of what cells are available.
If all entries are in use, the size of the array would have to be increased or some elements would have to be deleted before new entries could be stored in the list. This approach has one main disadvantage, however: This leads to the following issues:. For these reasons, this approach is mainly used for languages that do not support dynamic memory allocation. These disadvantages are also mitigated if the maximum size of the list is known at the time the array is created.
Many programming languages such as Lisp and Scheme have singly linked lists built in. In many functional languages , these lists are constructed from nodes, each called a cons or cons cell. The cons has two fields: Although cons cells can be used to build other data structures, this is their primary purpose. In languages that support abstract data types or templates, linked list ADTs or templates are available for building linked lists.
In other languages, linked lists are typically built using references together with records. When constructing a linked list, one is faced with the choice of whether to store the data of the list directly in the linked list nodes, called internal storage , or merely to store a reference to the data, called external storage.
Internal storage has the advantage of making access to the data more efficient, requiring less storage overall, having better locality of reference , and simplifying memory management for the list its data is allocated and deallocated at the same time as the list nodes.
External storage, on the other hand, has the advantage of being more generic, in that the same data structure and machine code can be used for a linked list no matter what the size of the data is.
It also makes it easy to place the same data in multiple linked lists. Although with internal storage the same data can be placed in multiple lists by including multiple next references in the node data structure, it would then be necessary to create separate routines to add or delete cells based on each field. It is possible to create additional linked lists of elements that use internal storage by using external storage, and having the cells of the additional linked lists store references to the nodes of the linked list containing the data.
In general, if a set of data structures needs to be included in linked lists, external storage is the best approach. If a set of data structures need to be included in only one linked list, then internal storage is slightly better, unless a generic linked list package using external storage is available.
Likewise, if different sets of data that can be stored in the same data structure are to be included in a single linked list, then internal storage would be fine. Another approach that can be used with some languages involves having different data structures, but all have the initial fields, including the next and prev if double linked list references in the same location.
After defining separate structures for each type of data, a generic structure can be defined that contains the minimum amount of data shared by all the other structures and contained at the top beginning of the structures. Then generic routines can be created that use the minimal structure to perform linked list type operations, but separate routines can then handle the specific data.
This approach is often used in message parsing routines, where several types of messages are received, but all start with the same set of fields, usually including a field for message type. The generic routines are used to add new messages to a queue when they are received, and remove them from the queue in order to process the message. The message type field is then used to call the correct routine to process the specific type of message.
Suppose you wanted to create a linked list of families and their members. Using internal storage, the structure might look like the following:. Notice that when using external storage, an extra step is needed to extract the record from the node and cast it into the proper data type. This is because both the list of families and the list of members within the family are stored in two linked lists using the same data structure node , and this language does not have parametric types.
As long as the number of families that a member can belong to is known at compile time, internal storage works fine. If, however, a member needed to be included in an arbitrary number of families, with the specific number known only at run time, external storage would be necessary.
Finding a specific element in a linked list, even if it is sorted, normally requires O n time linear search. This is one of the primary disadvantages of linked lists over other data structures.
In addition to the variants discussed above, below are two simple ways to improve search time. In an unordered list, one simple heuristic for decreasing average search time is the move-to-front heuristic , which simply moves an element to the beginning of the list once it is found.
C program to multiply two matrices. C program to swap two Strings. C Program to Sort an array of names or strings.
C program to find second most frequent character. C Program to print first n Fibonacci Numbers. C program to find area of a circle. C program to find area of a triangle. C program to calculate the value of nPr. Read more Read less. To get the free app, enter mobile phone number. See all free Kindle reading apps.
Tell the Publisher! I'd like to read this book on Kindle Don't have a Kindle? Product details Paperback: English ISBN Share your thoughts with other customers. Write a product review.