CareerCup

my solution in C:

void reverse(Node **head) {
 Node *current = *head;
 Node *next;
 Node *temp;
 if (head == NULL || *head == NULL || (*head)->next == NULL)
  return;
 temp = current->next;
 current->next = NULL;
 while (temp != NULL) {
  next = temp->next;
  temp->next = current;
  current = temp;
  temp = next;
 }
 *head = current;

}

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
struct node *next;
int data;
} Node;

Node* create_node(int data)
{
Node* ptr = (Node*) malloc (sizeof(Node));
ptr->next=NULL;
ptr->data=data;
return ptr;
}

add_to_list(Node** head,Node* new_node)
{
if(*head==NULL)
*head=new_node;
else
{
new_node->next = *head;
*head=new_node;
}
}

print_list(Node* rover)
{
while(rover!=NULL)
{
printf("%d => ",rover->data);
rover = rover->next;
}
printf("NULL\n");
}

Node* reverse_list(Node* head)
{
if(head==NULL)
return;


Node *prev=head,*cur=head->next,*next=head->next->next;
prev->next=NULL;

while(next!=NULL)
{
cur->next = prev;
prev = cur; cur = next; next = next->next;
}
cur->next = prev;
head = cur;
return head;
}

int main()
{
int i=0;
Node *ptr,*head=NULL;
for(i=10;i>0;i--)
{
ptr = create_node(i);
add_to_list(&head,ptr);
}
print_list(head);
head=reverse_list(head);
print_list(head);
getch();
}

node *reverse(node *first)


{
node *cur,*temp;


cur=NULL;

while(first!=NULL)


{temp=first;

first=first->link;

temp->link=cur;

cur=temp;
}

return cur;

}

Recursion can be used to reverse the list.


public void reverse(node x){
if(x == null)
return;

reverse(x.next);
System.out.println(x.data);

}

Recursion can be used to reverse the list.


public void reverse(node x){
if(x == null)
return;

reverse(x.next);
System.out.println(x.data);

}

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode* reverseList(ListNode* head) {
    ListNode* curr = head, *prev = NULL, *next;

    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    head = prev;
    return head;
}

void reverse_diffn(dnode **dpnode)
{
	dnode *curnode = *dpnode;
	unsigned int prevaddr = NULL, curraddr = NULL;

	while (curnode != NULL)
	{
		curraddr = (unsigned int)curnode;
		curnode = curnode->down;
		*((unsigned int *)curraddr + 1) = (prevaddr);
		prevaddr = curraddr;
	}
	*dpnode = ((dnode *)curraddr);
}

pussy cat pusst cat
Rascala pussy