链表反转：有两种方式 - 普通、递归

2013-4-11，周四，搜狗笔试题：单链表反转。这个题是经常出现的一个笔试和面试题。

题目：输入一个链表的头结点，反转该链表，并返回反转后链表的头结点

分析：这是一道广为流传的微软面试题。由于这道题能够很好的反应出程序员思维是否严密，在微软之后已经有很多公司在面试时采用了这道题。

为了正确地反转一个链表，需要调整指针的指向。与指针操作相关代码总是容易出错的，因此最好在动手写程序之前作全面的分析。在面试的时候不急于动手而是一开始做仔细的分析和设计，将会给面试官留下很好的印象，因为在实际的软件开发中，设计的时间总是比写代码的时间长。与其很快地写出一段漏洞百出的代码，远不如用较多的时间写出一段健壮的代码。

为了将调整指针这个复杂的过程分析清楚，我们可以借助图形来直观地分析。假设l、m和n是三个相邻的结点：

a b …l m n …

假设经过若干操作，我们已经把结点l之前的指针调整完毕，这些结点的 pNext 指针都指向前面一个结点。现在我们遍历到结点m。当然，我们需要把调整结点的 pNext 指针让它指向结点l。但注意一旦调整了指针的指向，链表就断开了，如下所示：

a b…l m n…

因为已经没有指针指向结点n，我们没有办法再遍历到结点n了。因此为了避免链表断开，我们需要在调整m的 pNext 之前要把n保存下来。

接下来我们试着找到反转后链表的头结点。不难分析出反转后链表的头结点是原始链表的尾位结点。什么结点是尾结点？就是 pNext 为空指针的结点。

 

示例代码：

package com.suanfa.lianbiao;

class Node<E> {

	// 数据
	public E data;
	// 指向下一个节点
	public Node<E> next;

	public Node(E data) {
		this.data = data;
	}

	// public Node<E> getNext() {
	// return next;
	// }
	//
	// public void setNext(Node<E> next) {
	// this.next = next;
	// }

}

class LinkList<E> {

	public Node<E> first;

	// 链表中数据项的个数
	public int size;

	public LinkList() {
		first = null;
		size = 0;
	}

	// 在表头插入新的数据
	public void insertFirst(E value) {
		Node<E> link = new Node<E>(value);
		link.next = first;
		first = link;
		size++;
	}

	// 判断链表是否为空
	public boolean isEmpty() {
		return size == 0;
	}

	// 删除表头
	public Node<E> deleteFirst() {
		Node<E> temp = first;
		first = first.next;
		size--;
		return temp;
	}

	// 输出链表中的所有数据
	public void display() {
		Node<E> curr = first;
		while (curr != null) {
			System.out.print(curr.data + " ");
			curr = curr.next;
		}
		System.out.println();
	}

	// 返回链表中数据项的个数
	public int size() {
		return size;
	}

	// 获取从头至尾的第i个数据项
	public Node<E> get(int i) {
		if (i > size() - 1 || i < 0) {
			try {
				throw new IndexOutOfBoundsException();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		Node<E> curr = first;
		for (int n = 0; n < size(); n++) {
			if (n == i) {
				return curr;
			} else {
				curr = curr.next;
			}
		}
		return null;
	}

	// 输出从头至尾的第i个数据项
	public void remove(int i) {
		if (i == 0) {
			deleteFirst();
		} else if (i == size() - 1) {
			get(i - 1).next = null;
		} else {
			get(i - 1).next = get(i + 1);
		}
		size--;
	}

	// 其实下面这2个反转的方法原理都是一样的，就是有的把第一个节点当做cur，有的把第二个节点当做cur
	// 两种方式实现单链表的反转(递归、普通)
	public Node<E> reverse_1(Node<E> head) {
		if (head == null) {
			return null;
		}
		// 链表反转后的新头结点
		Node<E> reverseHead = null;
		Node<E> cur = head;
		Node<E> pre = null;

		while (cur != null) {
			Node<E> next = cur.next;
			if (next == null) {
				reverseHead = cur;
			}

			cur.next = pre;
			pre = cur;
			cur = next;
		}
		return reverseHead;
	}

	/**
	 * 遍历，将当前节点的下一个节点缓存后更改当前节点指针
	 * 
	 */
	public Node<E> reverse_2(Node<E> head) {
		if (null == head) {
			return head;
		}
		Node<E> pre = head;
		Node<E> cur = head.next;
		Node<E> next;
		while (null != cur) {
			next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}
		// 将原链表的头节点的下一个节点置为null，再将反转后的头节点赋给head
		head.next = null;
		head = pre;

		return head;
	}

	/**
	 * 递归，在反转当前节点之前先反转后续节点
	 */
	public Node<E> reverse_3(Node<E> head) {
		if (null == head || null == head.next) {
			return head;
		}

		Node<E> reversedHead = reverse_3(head.next);
		head.next.next = head;
		head.next = null;
		return reversedHead;
	}

}

public class Link_list {
	public static void main(String[] args) {
		LinkList<Long> ll = new LinkList<Long>();

		// 构造链表
		for (int i = 0; i < 10; i++) {
			Long value = (long) (Math.random() * 100);
			ll.insertFirst(value);
		}

		ll.display();

		while (!ll.isEmpty()) {
			ll.deleteFirst();
			ll.display();
		}

		System.out.println("Ok");
	}
}

 

延伸阅读：

class Node
　　{
　　Object data;
　　Node next;  //指向下一个结点
　　}
　　将数据域定义成Object类是因为Object类是广义超类，任何类对象都可以给其赋值，增加了代码的通用性。为了使链表可以被访问还需要定义一个表头，表头必须包含指向第一个结点的指针和指向当前结点的指针。为了便于在链表尾部增加结点，还可以增加一指向链表尾部的指针，另外还可以用一个域来表示链表的大小，当调用者想得到链表的大小时，不必遍历整个链表。

 

需要反复思考，总结，消化为自己的知识。

 

参考链接：

http://blog.163.com/sparkle_tiangz/blog/static/11759020320102125278750/