CareerCup

void reverse(node *root)
{
	if(!root)
		return;

	reverse(root->link);
	
	cout << root->data << endl;
}

/**
	 * reverse the linkedList
	 * 		head : the head of list
	 * @param list
	 */
	public void reverse(LinkedList<T> list){
		Node<T> p = list.head.next;
		Node<T> succ = null;
		Node<T> front = null;
		while(p != null){
			succ = p.next;
			p.next = front;
			front = p;
			p = succ;
		}
		this.head.next = front;
	}

Start traversing the singly linked list and put the nodes in a stack till you reach the end of the list.
Then pop from the stack.
The elements will be in the reverse order to the original linked list.

int counter = list.size();
	for(int i=0;i<counter;i++){
		
		System.out.println(list.pollLast());
	}

list1=1->2->.......
head=NULL;
temp=NULL;
while( list1 !=NULL ){
temp=getnode(list1->data);
temp->next=head;
head=temp;
list1=list1->next;
}

void reverse(LinkedList node){
if(node==null)
return;
reverse(node.next);
System.out.println(node.value);
}

recursion man.
go till end of link and while returning print the data

Well if allowed we can use Collections class in java to sort the LinkedList in reverse order.

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class AV {
public static void main(String[] args) {
List<Integer> ab=new LinkedList<Integer>();
ab.add(1);
ab.add(2);
ab.add(3);
ab.add(4);

Collections.reverse(ab);
for(Integer i: ab){
System.out.print(i);
}

}

}

Java
void reverse(Node node)
{
if(node.hasNext())
reverse(node.next)

System.out.println(node.value);
}

public static void reverseLinkedList(LinkedList<Integer> list){
while(list.size()>0){
System.out.println(list.removeLast());
}
}

List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
ListIterator<String> itr = list.listIterator(list.size());
while(itr.hasPrevious()) {
System.out.print(itr.previous()+"\t");
}

Reverse your list and print its reversed version.

public void Reverse_linkedlist(Linkedlist ll )
{
int count = 0;
for(int i =1 ; i<ll.getSize(); i++)
{
Node current = ll.getHead();
while(current.getNext().getNext() ! = null)
{
current = current.getNext();
}
count++;
Node temp = current.getNext();
Node current1 = ll.getHead();
for(int j= 1 ; j<count ; j++)
{
current1 = current1.getNext();
}
temp.setNext(current1.getNext());
current1.setNext(temp);
current.setNext(null);
}

}

We can use descendingIterator to reverse LinkList in java

for linkedlist we have methods like removelast() and addfirst()..
we can simply removelast element and add it at the first by using these methods till the first method becomes last!!

void printrev(struct node *head)
{
    struct node *q=NULL,*p=head;
    while(q!=head)
    {
        p=head;
        while(p->next!=q)
            p=p->next;
        printf("%d  ",p->data);
        q=p;
    }

}

package sample;

import java.util.LinkedList;
import java.util.List;

public class Linked {
	public static void main(String args[]){
		List<Integer> l = new LinkedList<Integer>();
		l.add(10);
		l.add(20);
		l.add(30);
		l.add(40);
		l.add(50);
		
		for(int i = l.size() ; i > 0 ; i--){
			System.out.println(l.get(i-1));
		}
	}

}

LinkedList<String> list = new LinkedList<String>();
		list.add("a");
		list.add("b");
		list.add("c");

		while(!list.isEmpty()) {
			System.out.println(list.pollLast());
		}

simplest one?

while(list.size()>0){
System.out.println(list.getLast());
list.removeLast();
}

public static void reversePrint(Node node){
if(node == null){
return;
}
reversePrint(node.next);
System.out.print(node.value+" ");
}

public class ReverseLinkedList {
    static class Node{
        Object value;
        Node next;
        Node(Object value){
            this.value = value;
        }
        Node next(Node next){
            this.next = next;
            return next;
        }
        @Override
        public String toString() {
            return "Node(" +value +")+>"+(next!=null?next.toString():"|");
        }
    }
    static class SingleLinkedList{
        Node head;
        void reverse(){
            Node cur=head, prev=null;
            while(cur!=null){
                Node next = cur.next;
                cur.next = prev;
                prev = cur;
                cur = next;
            }
            head=prev;
        }
    }
    public static void main(String[] args) {
        SingleLinkedList l = new SingleLinkedList();
        l.head = new Node(1);
        l.head.next(new Node(2)).next(new Node(3)).next(new Node(4)).next(new Node(5));
        System.out.println(l.head);
        l.reverse();
        System.out.println(l.head);
    }
}

Output:
Node(1)+>Node(2)+>Node(3)+>Node(4)+>Node(5)+>|
Node(5)+>Node(4)+>Node(3)+>Node(2)+>Node(1)+>|

Reverse the list and display it. Below is code to reverse the linked list using linked list node. No other data structure used. Once you get the linked list, you can print it out.

public LinkedListNode<Integer> reverse(LinkedListNode<Integer> head){
		LinkedListNode<Integer> previous = null;
		LinkedListNode<Integer> current = head;
		LinkedListNode<Integer> next = null;
		while(current != null){
			next = current.getNext();
			current.setNext(previous);
			previous = current;
			current = next;
		}
		return previous;
	}

def printBackward(n):
	if n==None:
		return
	head = n
	tail = n.next
	printBackward(tail)
	print(head,end=' ')

struct node
{
    int data;
    struct node *link;
};
typedef struct node node;

stack<int> output, input;
void reverse(node* root)
{
	if(root->link != 0)
		reverse(root->link);
	output.push(root->data);
}

int main()
{
	//take inputs into your stack input
	node* r;
	//pop elements to put into a linked list
	reverse(r)
}