singly-linked-list

I do not quiet understand why deleting at the end of a single linked list goes in O(1) time, as the wikipedia article says. A single linked list consists out of nodes. A node contains some kind of data, and a reference to the next node. The reference of the last node in the linked list is null. -------------- -------------- -------------- | data | ref | -> | data | ref | -> ... -> | data | ref | -------------- -------------- -------------- I indeed can remove the the last node in O(1). But in that case you don't set the reference of the newly last node, the previous one, to null since it still

I want to be able to sum the squares of the even elements in the list, however my current code only sums the elements, not the squares. Does anyone know of any modifications that can be made to make this to sum the squares of the even-valued elements in the list? (define (sum elemList) (if (null? elemList) 0 (+ (car elemList) (sum (cdr elemList))) ) ) My input would be: (sum-evens (list 1 2 3 4)) Output would be: 20 Which is (2*2) + (4*4) . If possible, it would be good to see both a recursive and iterative solution. Any ideas? There are two possibilities, either we implement the recursion

One method which I can think of is to reverse the list and then read it. But this involves changing the list which is bad. OR I can make a copy of the list and then reverse it, but this uses additional O(n) memory. Is there any better method which doesn't use extra memory and doesn't modify the list and runs in O(n) time reverse linked list code is something like this in c# Void Reverse (Node head) { Node prev= null; Node current = head; Node nextNode = null; while (current!=null) { nextNode = current.Next; current.Next = prev; prev=current; current = nextNode; } head = prev; } Recursive

Node reverse(Node head) { Node previous = null; Node current = head; Node forward; while (current != null) { forward = current.next; current.next = previous; previous = current; current = forward; } return previous; } How exactly is it reversing the list? I get that it first sets the second node to forward . Then it says current.next is equal to a null node previous . Then it says previous is now current . Lastly current becomes forward ? I can't seem to grasp this and how its reversing. Can someone please explain how this works? You reverse the list iteratively and always have the list in the

The following code works fine when head is sent as a parameter to it. As I am new to C, I couldn't understand how it works. Help me out please. struct node *recursiveReverseLL(struct node *list) { struct node *revHead; if (list == NULL || list->link == NULL) { return list; } revHead = recursiveReverseLL(list->link); list->link->link = list; list->link = NULL; return revHead; } I dont know how the links are provided using those recursive calls. ie) if the links are as, 1 -> 2 -> 3 -> 4 then hw is it changed as, 4 -> 3 -> 2 -> 1 codaddict The general recursive algorithm for this is: Divide the