linked-list

#include <stdio.h> typedef struct { int data; struct node *next; }node; void print(node *head) { node *tmp = head; while (tmp) { printf ("%d ", tmp->data); tmp = tmp->next; } } int main() { node arr[5] = { {1, &arr[1]}, {2, &arr[2]}, {3, &arr[3]}, {4, &arr[4]}, {5, NULL} }; print(arr); return 0; } Why do i get these warnings while compiling with gcc -Wall ? (even without -Wall, gcc produces the same warnings) list.c: In function ‘print’: list.c:15:7: warning: assignment from incompatible pointer type [enabled by default] list.c: In function ‘main’: list.c:22:18: warning: initialization from

(disclaimer: for school) As far as I know, recursively splitting a linked list, then sending it off to another function to merge is O(nlogn) time and O(n) space. Is it possible to do mergesort on linked list with O(nlogn) time and O(1) space complexity? How would you go about doing this? ANY HELP APPRECIATED PS: to make sure that the traditional mergesort is space complexity 0(n), this is an example of 0(n), right? How would it be changed for O(1) space? void sortTrack() { Node merge = this.head; this.head = Node (merge); } public Node mergeSort(Node head){ if ((head == null)||(head.next ==

I am implementing a LinkedList in python(3.7.4) and the code of the module is below :- LinkedList.py class Node: def __init__(self,value): self.value = value self.ref = None class LinkedList(Node): def __init__(self): self.__head = None self.__cur = None self.__count = 0 def add(self,value): if self.__head is None: self.__cur = Node(value) self.__head = self.__cur else: self.__cur.ref = Node(value) self.__cur = self.__cur.ref self.__count += 1 def getList(self): temp = self.__head while temp!=None: yield temp.value temp = temp.ref def delete(self,value): temp = self.__head while temp!=None: if

To delete a node in a linked list, what is wrong with this implementation?: def delete(self, val): tmp = self.head prev = None while tmp: if val == tmp.data: self.size -= 1 if prev==None: self.head = self.head.next else: prev.next = tmp.next else: prev = tmp tmp = tmp.next All the guides I've looked at say it should be: def delete(self, data): tmp = self.head prev = None found = False while tmp and not found: if data == tmp.data: found = True else: prev = tmp tmp = tmp.next if found: self.size -= 1 if prev == None: self.head = self.head.next else: prev.next = tmp.next but I can't figure out

There is a singly connected linked list and a block size is given.For eg if my linked list is 1->2->3->4->5->6->7->8-NULL and my block size is 4 then reverse the first 4 elements and then the second 4 elements.The output of the problem should be 4->3->2->1->8->7->6->5-NULL I was thinking of dividing the linked list into segments of size 4 and then reversing it. But that way I am forced to use a lot of extra nodes which is not desired at all. The space complexity should be kept to a minimum. It will be highly appreciable if someone can come with a better solution where the usage of extra nodes

I have some C code, where in there are two linked lists(say A and B) and A is inserted at a particular position into B and A still has elements. How do I simulate the same behavior effectively using the C++ STL? If I try splice, it makes the second one empty. Thanks, Gokul. You need to copy the elements. Consider something like this: std::copy(a.begin(), a.end(), std::inserter(b, b_iterator)); If you want the same nodes shared by two lists, this is simply not supported by std::list (STL containers always have exclusive ownership). You can avoid duplicating the elements by storing pointers in