将单向链表逆序输出，方法有三种：
a.遍历链表，将每个节点的内容存入一个数组中，然后逆序输出数组(最简单的做法)b.使用栈来逆序输出c.直接将链表逆序然后输出
先介绍c方法：
1). 若链表为空或只有一个元素，则直接返回；2). 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继；3). 重复2),直到q为空4). 调整链表头和链表尾
示例：以逆序A->B->C->D为例，图示如下
Bean类
public class Node {private int data;private Node next;public int getData() {return data;}public void setData(int data) {this.data = data;}public Node getNext() {return next;}public void setNext(Node next) {this.next = next;}}
实现
import java.util.Scanner;public class LinkList {public Node head;public void createLinkList(int []x) { //创建一个链表Node pnew; //定义一个新的结点Node ptail = new Node();head = ptail;for(int i = 0; i < x.length; i ++) {pnew = new Node();pnew.setData(x[i]);ptail.setNext(pnew);ptail = pnew;}}public void displayLinkList() { //正序输出链表的所有内容Node node = head.getNext();while (node != null) {System.out.print(node.getData() + "--->");node = node.getNext();}System.out.println("null");}public void reverseLinkList() { //逆序输出链表的所有内容if (head == null || head.getNext() == null) { //当链表只有一个头节点或者只有一个结点，逆序还是原来的链表，所以直接返回return;} else {Node p = head.getNext();Node q = head.getNext().getNext();p.setNext(null);//将第一个结点的next置为空，否则会出现一个环Node temp = null;while (q != null) {temp = q.getNext();q.setNext(p);p = q;q = temp;}if (q == null) {head.setNext(p);q = null;}}}public static void main(String[] args) {LinkList linkList = new LinkList();Scanner input = new Scanner(System.in);int n = input.nextInt();int [] x = new int [n];for (int i = 0; i < n; i ++) {x[i] = i;}linkList.createLinkList(x);linkList.displayLinkList();linkList.reverseLinkList();linkList.displayLinkList();}}
输出结果：
100--->1--->2--->3--->4--->5--->6--->7--->8--->9--->null9--->8--->7--->6--->5--->4--->3--->2--->1--->0--->null
再介绍比较简单的b方法：
借助栈先进后出的特性，将链表存入栈中，然后出栈，刚好就实现了链表的逆序输出(此方法只实现了逆序输出，但并没有将链表逆序)
public void reverseLinkList_Stack() { //借助栈来实现逆序输出Stack<Node> stack = new Stack<Node>();Node node = head.getNext();while (node != null) {stack.push(node);node = node.getNext();}while (stack.size() > 0) {node = stack.pop();System.out.print(node.getData() + "--->");}System.out.println("null"); // 在最后添加上null作为结束标志}
代码
package list;public class ReverseList {public static void main(String[] args) {Node head = new Node(1);int[] value = {2,3,4,5};Node temp = head;for (int i = 0 ; i< value.length;i++) {Node node = new Node(value[i]);temp.next = node;temp = temp.next;}printList(head);// 反序输出一个单链表head = reverse(head);printList(head);// 再次反向head = reverseSingleList(head);printList(head);}public static void printList(Node head) {while(head!=null) {System.out.print("\t"+head.value);head = head.next;}System.out.println();}public static Node reverse(Node head) {Node pre = null;Node post = null;while(head!=null) {post = head.next;head.next = pre;pre = head;head = post;}return pre;}public static Node reverseSingleList(Node head) {Node pre = null;Node next = null;while(head!=null) {next = head.next;head.next = pre;pre = head;head = next;}return pre;}}class Node {public int value;public Node next;public Node(int value) {this.value = value;}}
经测试，代码输出正确。
1 2 3 4 55 4 3 2 11 2 3 4 5
帮助理解，下面是另一个实例：
/** * java 实现单链表的逆序 * @author Administrator * */public class SingleLinkedReverse {class Node{int data;Node next;public Node(int data){this.data = data;}}public static void main(String[] args) {SingleLinkedReverse slr = new SingleLinkedReverse();Node head, tail;head = tail = slr.new Node(0);for (int i=1; i<10; i++){Node p = slr.new Node(i);tail.next = p;tail = p;}tail = head;while(tail != null){System.out.print(tail.data+" ");tail = tail.next;}head = reverse(head);System.out.println(" ");while(head != null){System.out.print(head.data+" ");head = head.next;}}private static Node reverse(Node head) {Node p1,p2 = null;p1 = head;while(head.next != null){p2 = head.next;head.next = p2.next;p2.next = p1;p1 = p2;}return p2;}}
测试结果：
0 1 2 3 4 5 6 7 8 99 8 7 6 5 4 3 2 1 0
事实上，就是这样。
Node pre = null;Node post = null;while(head!=null){post = head.next;head.next = pre;pre = head;head = post;}
这便是逆序的核心了。
首次逆序：一开始的话，pre，post都设置为null。这是必须的，因为在head.next=pre这行代码执行完成后，我们原始的那个head节点的next将变成null，也就是我们整个链表的null了。
想象一下，原来的那个链表的最后面的next不也是一个null吗？这里道理是一致的。
此时，更新pre为原来的head节点，也是为了下一步的逆序做准备，而head也自然的变成了原来的head.next了。
不断逆序。就是一次次的将head向后移，同时更新pre节点，来达到逆序的效果。
