In a program I'm working on for a final project, I've got to implement search functions for ordered and unordered linked lists. In the assignment, it's made clear that there's an expectation for a search function for each type.
I've worked with linked lists in previous classes, I understand the difference between ordered and unordered, but I hit a wall in trying to figure out what the difference would be in searching them. In my mind, both should iterate through the list until the key value is found and then return it. How should these differ?
In case of order linked list time complexity can be reduced while performing search operation. You can implement skip list for this purpose. But if your linked list need to be a singly linked list strictly then there is no difference other than mentioned by #kaylum in his comment
Related
I have a C structure that contains contact info for a person, such as name, phone number, etc. The "contact" structures are contained within a linked list. I need to insert nodes in a way such that the linked list is sorted into alphabetical (ascending) order.
Is there a built-in sorting function in C that I can call? Or do I have to write my own sorting function? If there is a built-in function, could I get an example of how I'd call it on a structure within a linked list?
There's no standard sorting method for a "list". The closest is qsort (which can indeed sort user-defined objects) but it only works on continuous ranges (arrays and the like).
You'll probably have to implement your own sorting procedure or use and array instead of a list.
Here is an example of code that performs an insertion sorted linked list. This isn't a cut and paste for you, but will show you what to expect in that type of insertion:
http://www.c.happycodings.com/Sorting_Searching/code8.html
Focus on the "insert()" call. I did not compile this code to test it, but I read it over and it looks correct to me. It shows how to search a list and pointer adjustments. You should be able to solve your problem from this code.
I have read a question ,is it possible to apply binary search on a link list?
Since link list doesn't allow random access, this looks practically impossible.
Any one has any way to do it?
The main issue, besides that you have no constant-time access to the linked list elements, is that you have no information about the length of the list. In this case, you simply have no way to "cut" the list in 2 halves.
If you have at least a bound on the linked list length, the problem is solvable in O(log n), with a skip list approach, indeed. Otherwise nothing would save you from reading the whole list, thus O(n).
So, assuming that the linked list is sorted, and you know its length (or at least the maximum length), yes it's possible to implement some sort of binary search on a linked list. This is not often the case, though.
With a plain linked list, you cannot do binary search directly, since random access on linked lists is O(n).
If you need fast search, tree-like data structures (R/B tree, trie, heap, etc.) offer a lot of the advantages of a linked list (relatively cheap random insertion / deletion), while being very efficient at searching.
Not with a classic linked list, for the reasons you state.
But there is a structure that does allow a form of binary search that is derived from linked lists: Skip lists.
(This is not trivial to implement.)
I have once implemented something like that for a singly-linked list containing sorted keys. I needed to find several keys in it (knowing only one of them at the beginning, the rest were dependent on it) and I wanted to avoid traversing the list again and again. And I didn't know the list length.
So, I ended up doing this... I created 256 pointers to point to the list elements and made them point to the first 256 list elements. As soon as all 256 were used and a 257th was needed, I dropped the odd-numbered pointer values (1,3,5,etc), compacted the even-numbered (0,2,4,etc) into the first 128 pointers and continued assigning the remaining half (128) of pointers to the rest, this time skipping every other list element. This process repeated until the end of the list, at which point those pointers were pointing to elements equally spaced throughout the entire list. I then could do a simple binary search using those 256 (or fewer) pointers to shorten the linear list search to 1/256th (or 1/whatever-th) of the original list length.
This is not very fancy or powerful, but sometimes can be a sufficient perf improvement with minor code changes.
You can do a binary search on a linked list. As you say, you don't have random access, but you can still find the element with a specific index, starting either from the start of the list or from some other position. So a straightforward binary search is possible, but slow compared with binary search of an array.
If you had a list where comparisons were much, much more expensive than simple list traversal, then a binary search would be cheaper than a linear search for suitably-sized lists. The linear search requires O(n) comparisons and O(n) node traversals, whereas the binary search requires O(log n) comparisons and O(n log n) node traversals. I'm not sure if that O(n log n) bound is tight, the others are.
According to me, there is no way to search the Linked list in binary search manner. In binary search, we usually find out 'mid' value of array which is impossible with lists, since lists are the structure where we have to strictly use the 'start' (Node pointing to very 1st node of list) to traverse to any of our list elements.
And in array, we can go to specific element using INDEX, here no question of Index (Due to Random Access unavailability in linked lists).
So, I think that binary search is not possible with linked list in usual practices.
for applying binary search on linked list, you can maintain a variable count which should iterate through the linked list and return the total number of nodes. Also you would need to keep a var of type int say INDEX in your node class which should increment upon creation of each new node. after which it will be easy for you to divide the linked list in 2 halves and apply binary search over it.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking for code must demonstrate a minimal understanding of the problem being solved. Include attempted solutions, why they didn't work, and the expected results. See also: Stack Overflow question checklist
Closed 9 years ago.
Improve this question
I was asked to write a function that takes 3 unsorted linked lists and returns one single sorted linked list that combines all three lists. What is the best way you can think of?
I don't really have restrictions of memory, but what would you do with/without memory restrictions?
One option would be to use merge sort on all three of the linked lists, then use one final merge step to merge them together into an overall sorted list.
Unlike most O(n log n) sorting algorithms, merge sort can run efficiently on linked lists. At a high-level, the intuition behind merge sort on a linked list is as follows:
As a base case, if the list has zero or one elements, it's already sorted.
Otherwise:
Split the list into two lists of roughly equal size, perhaps by moving odd elements into one list and even elements into the other.
Recursively use merge sort to sort those lists.
Apply a merge step to combine those lists into one sorted list.
The merge algorithm on linked lists is really beautiful. The pseudocode works roughly like this:
Initialize an empty linked list holding the result.
As long as both lists aren't empty:
If the first element of the first list is less than the first element of the second list, move it to the back of the result list.
Otherwise, move the first element of the second list to the back of the result list.
Now that exactly one list is empty, move all the elements from the second list to the back of the result list.
This can be made to run in O(n) time, so the overall complexity of the merge sort is O(n log n).
Once you've sorted all three lists independently, you can apply the merge algorithm to combine the three lists into one final sorted list. Alternatively, you could consider concatenating together all three linked lists, then using a giant merge sort pass to sort all of the lists at the same time. There's no clear "right way" to do this; it's really up to you.
The above algorithm runs in Θ(n log n) time. It also uses only Θ(log n) memory, since it allocates no new linked list cells and just needs space in each stack frame to store pointers to the various lists. Since the recursion depth is Θ(log n), the memory usage is Θ(log n) as well.
Another O(n log n) sort that you can implement on linked lists is a modification of quicksort. Although the linked list version of quicksort is fast (still O(n log n) expected), it isn't nearly as fast as the in-place version that works on arrays due to the lack of locality effects from array elements being stored contiguously. However, it's a very beautiful algorithm as applied to lists.
The intuition behind quicksort is as follows:
If you have a zero- or one-element list, the list is sorted.
Otherwise:
Choose some element of the list to use as a pivot.
Split the list into three groups - elements less than the pivot, elements equal to the pivot, and elements greater than the pivot.
Recursively sort the smaller and greater elements.
Concatenate the three lists as smaller, then equal, then greater to get back the overall sorted list.
One of the nice aspects of the linked-list version of quicksort is that the partitioning step is substantially easier than in the array case. After you've chosen a pivot (details a bit later), you can do the partitioning step by creating three empty lists for the less-than, equal-to, and greater-than lists, then doing a linear scan over the original linked list. You can then append/prepend each linked list node to the linked list corresponding to the original bucket.
The one challenge in getting this working is picking a good pivot element. It's well known that quicksort can degenerate to O(n2) time if the choice of pivot is bad, but it is also known that if you pick a pivot element at random the runtime is O(n log n) with high probability. In an array this is easy (just pick a random array index), but in the linked list case is trickier. The easiest way to do this is to pick a random number between 0 and the length of the list, then choose that element of the list in O(n) time. Alternatively, there are some pretty cool methods for picking an element at random out of a linked list; one such algorithm is described here.
If you want a simpler algorithm that needs only O(1) space, you can also consider using insertion sort to sort the linked lists. While insertion sort is easier to implement, it runs in O(n2) time in the worst case (though it also has O(n) best-case behavior), so it's probably not a good choice unless you specifically want to avoid merge sort.
The idea behind the insertion sort algorithm is as follows:
Initialize an empty linked list holding the result.
For each of the three linked lists:
While that linked list isn't empty:
Scan across the result list to find the location where the first element of this linked list belongs.
Insert the element at that location.
Another O(n2) sorting algorithm that can be adapted for linked lists is selection sort. This can be implemented very easily (assuming you have a doubly-linked list) by using this algorithm:
Initialize an empty list holding the result.
While the input list is not empty:
Scan across the linked list looking for the smallest remaining element.
Remove that element from the linked list.
Append that element to the result list.
This also runs in O(n2) time and uses only O(1) space, but in practice it's slower than insertion sort; in particular, it always runs in Θ(n2) time.
Depending on how the linked lists are structured, you might be able to get away with some extremely awesome hacks. In particular, if you are given doubly-linked lists, then you have space for two pointers in each of your linked list cells. Given that, you can reinterpret the meaning of those pointers to do some pretty ridiculous sorting tricks.
As a simple example, let's see how we could implement tree sort using the linked list cells. The idea is as follows. When the linked list cells are stored in a linked list, the next and previous pointers have their original meaning. However, our goal will be to iteratively pull the linked list cells out of the linked list, then reinterpret them as nodes a in binary search tree, where the next pointer means "right subtree" and the previous pointer means "left subtree." If you're allowed to do this, here's a really cool way to implement tree sort:
Create a new pointer to a linked list cell that will serve as the pointer to the root of the tree.
For each element of the doubly-linked list:
Remove that cell from the linked list.
Treating that cell as a BST node, insert the node into the binary search tree.
Do an in-order walk of the BST. Whenever you visit a node, remove it from the BST and insert it back into the doubly-linked list.
This runs in best-case O(n log n) time and worst-case O(n2). In terms of memory usage, the first two steps require only O(1) memory, since we're recycling space from the older pointers. The last step can be done in O(1) space as well using some particularly clever algorithms.
You could also consider implementing heap sort this way as well, though it's a bit tricky.
Hope this helps!
If the 3 lists were individually sorted the problem would be simple, but as they aren't it's a little more tricky.
I would write a function that takes a sorted list and an unsorted list as parameters, goes through each item of the unsorted list and adds it in the correct position in the sorted list in turn until there are no items left in the unsorted list.
Then simply create a forth "empty" list which by the very nature of being empty is "sorted" and then call your method three times with each of the unsorted lists.
Converting the lists to arrays may make things a little more efficient in terms of being able to use more advanced sort techniques, but the cost of converting to an array has to be considered and balanced against the size of the original lists.
I was thinking that you can apply quick sort. It is almost same as merge sort, only difference is that you first split and then merge, where whit quicksort you first "merge" and then you make split. If you look little different is mergesort quicksort in opposite direction
mergesort:
split -> recursion -> merge
quicksort:
umnerge (opposite of merge) -> recursion -> join (opposite of split)
The mergesort algorithm described in the popular post by #templatetypedef does not work in O(n lg n). Because a linked list is not random access, step 2.1 Split the list into two lists of roughly equal size actually means an overall algorithm of O(n^2 log n) to sort the list. Just think about it a bit.
Here is a link that uses mergesort to sort a linked list by first reading the elements into an array -- http://www.geekviewpoint.com/java/singly_linked_list/sort.
There are no effecient sorting algorithms for linked lists.
make an array, sort, and relink.
I have an unsorted linked list. I need to sort it by a certain field then return the linked list to its previous unsorted condition. How can I do this without making a copy of the list?
When you say "return the linked list to its previous unsorted condition", do you mean the list needs to be placed into a random order or to the exact same order that you started with?
In any case, don't forget that a list can be linked into more than one list at a time. If you have two sets of "next"/"previous" pointers, then you can effectively have the same set of items sorted two different ways at the same time.
To do this you will need to either sort and then restore the list or create and sort references to the list.
To sort the list directly Merge Sort is most likely the best thing you could use for the initial sort, but returning them to their original state is tricky unless you either record your moves so you can reverse them or store their original position and resort them using that as the key.
If you would rather sort the references to the list instead you will need to allocate enough space to hold pointers to each node and sort that. If you use a flat array to store the pointers then you could use the standard C qsort to do this.
If this is an assignment and you must implement your own sort then if you don't already know the length of the list you could take advantage of having to traverse it to count its length to also choose a good initial pivot point for quicksort or if you choose not to use quicksort you can let your imagination go wild with all kinds of optimizations.
Taking your points in reverse order, to support returning to original order, you can add an extra int field to each list node. Set those values based on the original order, and when you need to return it to the original order, just sort on that field.
As far as the sorting in general goes, you probably want to use something like a merge-sort or possibly a Quick-sort.
You can make that data structure somewhat like this.
struct Elem {
Elem* _next;
Elem* _nextSorted;
...
}
Then you can use any algo for sorting the list (maybe merge sort)
If you want to keep your linked list untouched, you should add information to store the ordered list of elements.
To do so, you can either create a new linked list where each element points to one element of your original linked list. Or you can add one more field in the element of your list like sorted_next.
In any case, you should use a sequential algorithm like mergesort to sort a linked list.
Here is a C source code of mergesort for linked lists that you could reuse for your project.
I guess most of the answers have already covered the usual techniques one could use. As far as figuring out the solution to the problem goes, a trick is to look at the problem and think if the human mind can do it.
Figuring out the original random sequence from a sorted sequence is theoretically impossible unless you use some other means. This can be done by
a)modifying the linked list structure (as mentioned above, you simply add a pointer for the sorted sequence separately). This would work and maybe technically you are not creating a separate linked list, but it is as good as a new linked list - one made of pointers.
b)the other way is to log each transition of the sorting algo in a stack. This allows you to not be dependent on the sorting algorithm you use. For example when say node 1 is shifted to the 3rd position, you could have something like 1:3 pushed to the stack. The notation, of course, may vary. Once you push all the transitions, you can simply pop the stack to give take it back to the original pattern / any point in between. This is more like
If you're interested in learning more about the design for loggers, I suggest you read about the Command Pattern
I have completed implementing Operation of Linear Linked List using C,
Now inorder to test my ability i need to solve some problems based on Linear Linked List, and there you people can help me by suggesting some problems/assignments ...
I think there is nothing wrong in asking this type of help from my community members .
Determine whether the linked list contains cycle or not.
In the circular linked list add new node at the end without traversing the list.
Reverse the list.
Print the nodes in the list in reverse order without reversing the list.
Make a list Circular linked list.
Sort the list.
Merge two sorted lists.