If you’re actually building a real system, then yes, you’d typically just use the stuff in the standard library if what you need is available there. That said, don’t think of this as a pointless exercise. It’s good to understand how things work, and understanding linked lists is an important step towards understanding more complex … Read more
An iterative function to free your list: void freeList(struct node* head) { struct node* tmp; while (head != NULL) { tmp = head; head = head->next; free(tmp); } } What the function is doing is the follow: check if head is NULL, if yes the list is empty and we just return Save the head … Read more
From a correctness perspective, there is no reason that you need to use the number two. Any choice of step size will work (except for one, of course). However, choosing a step of size two maximizes efficiency. To see this, let’s take a look at why Floyd’s algorithm works in the first place. The idea … Read more
It’s not just better, it’s the only possible way. If you stored a Node object inside itself, what would sizeof(Node) be? It would be sizeof(int) + sizeof(Node), which would be equal to sizeof(int) + (sizeof(int) + sizeof(Node)), which would be equal to sizeof(int) + (sizeof(int) + (sizeof(int) + sizeof(Node))), etc. to infinity. An object like … Read more
You’re missing several things; the most important being linked lists are not arrays, and as such you cannot easily do certain algorithms with both interchangeably. With that please consider the following: List length is determined by reaching the last node, but you don’t need it for this algorithm. There should be no reason to scan … Read more
Here’s a continuation-based version. It’s tail-recursive and returns the list in the original order. let partitionWhileCps c l = let rec aux f = function | h::t when c h -> aux (fun (acc, l) -> f ((h::acc), l)) t | l -> f ([], l) aux id l Here are some benchmarks to go … Read more
Functional Quicksort and Mergesort Here’s a linked list with quicksort and mergesort methods written in a functional style: class List { public int item; public List rest; public List(int item, List rest) { this.item = item; this.rest = rest; } // helper methods for quicksort public static List Append(List xs, List ys) { if (xs … Read more
The most glaring bug is in your loop, you keep overwriting mergedList->next, losing the previously added node. That is, your returned list will never contain more than two nodes, regardless of input … It’s been a while since I did C, but I would do it as follows: Node* merge(Node* list1, Node* list2) { Node* … Read more
This takes O(M+N) time and O(1) space, where M and N are the total length of the linked lists. Maybe inefficient if the common part is very long (i.e. M,N >> m,n) Traverse the two linked list to find M and N. Get back to the heads, then traverse |M − N| nodes on the … Read more
You can use Collections#sort to sort things alphabetically.