java单链表常用操作

总结提高，与君共勉

概述、

数据结构与算法亘古不变的主题，链表也是面试常考的问题，特别是手写代码常常出现，将从以下方面做个小结

【链表个数】

【反转链表-循环】

【反转链表-递归】

【查找链表倒数第K个节点】

【查找链表中间节点】

【判断链表是否有环】

【从尾到头打印单链表-递归】

【从尾到头打印单链表-栈】

【由小到大合并有序单链表-循环】

【由小到大合并有序单链表-递归】

通常在java中这样定义单链表结构

<span style="font-family:Microsoft YaHei;font-size:14px;">class Node{
	int value;
	Node next;
	public Node(int n){
		this.value = n;
		this.next = null;
	}
}
</span>

1、链表个数

这个比较简单，不再赘述

<span style="font-family:Microsoft YaHei;font-size:14px;">	// 求单链表的结点个数
	public int getListLen(Node head) {
		int len = 0;
		while (head != null) {
			len++;
			head = head.next;
		}
		return len;
	}</span>

2、反转链表-循环

采用双指针，主要是4行代码，其中2,3俩行完成指针反转，1,4主要是保持head往下指

<span style="font-family:Microsoft YaHei;font-size:14px;">// 反转单链表(循环)
	public Node reverseList(Node head) {
		// 安全性检查
		if (head == null || head.next == null)
			return head;
		Node pre = null;
		Node temp = null;
		while (head != null) {
			// 以下1234均指以下四行代码
			temp = head.next;// 与第4行对应完成头结点移动
			head.next = pre;// 与第3行对应完成反转
			pre = head;// 与第2行对应完成反转
			head = temp;// 与第1行对应完成头结点移动
		}
		return pre;
	}</span>

3、反转链表-递归

<span style="font-family:Microsoft YaHei;font-size:14px;">// 将单链表反转,递归
	public static Node reverseListRec(Node head) {
		if (head == null || head.next == null)
			return head;
		Node reHead = reverseListRec(head.next);
		head.next.next = head;
		head.next = null;
		return reHead;
	}</span>

4、查找链表倒数第K个节点

双指针法，不多解释

<span style="font-family:Microsoft YaHei;font-size:14px;">// 查找单链表倒数第K个结点 双指针法
	public Node reKNode(Node head, int k) {
		if (head == null)
			return head;
		int len = getListLen(head);
		if (k > len)
			return null;
		Node targetK = head;
		Node nextK = head;
		// 先走到K个位置
		for (int i = 0; i < k; i++) {
			nextK = nextK.next;
		}
		// 再和头结点一起走，nextk走到结尾，此时targetk为倒数第K个节点
		while (nextK != null) {
			nextK = nextK.next;
			targetK = targetK.next;
		}
		return targetK;
	}</span>

5、查找链表中间节点

快慢指针，不多解释

<span style="font-family:Microsoft YaHei;font-size:14px;">public Node getMid(Node head) {
		// 类似的快慢指针法
		// 安全性检查
		if (head == null || head.next == null)
			return head;
		Node target = head;
		Node temp = head;
		while (temp != null && temp.next != null) {
			target = target.next;
			temp = temp.next.next;
		}
		return target;
	}</span>

6、判断链表是否有环

主要还是快慢指针，如果快的指针能够追上慢指针则有环

<span style="font-family:Microsoft YaHei;font-size:14px;">// 判断一个单链表中是否有环,快慢指针
	public boolean hasCycle(Node head) {
		boolean flag = false;
		Node p1 = head;
		Node p2 = head;
		while (p1 != null && p2 != null) {
			p1 = p1.next;
			p2 = p2.next.next;
			if (p2 == p1) {
				flag = true;
				break;
			}
		}
		return flag;
	}</span>

7、从尾到头打印单链表-递归

<span style="font-family:Microsoft YaHei;font-size:14px;">// 从尾到头打印单链表(递归)
	public void reList1(Node head) {
		// 安全性检查
		if (head == null)
			return;
		else {
			reList1(head.next);
			System.out.println(head.value);
		}

	}</span>

8、从尾到头打印单链表-栈

利用栈FILO的性质，先存储节点然后输出每个栈的节点值

<span style="font-family:Microsoft YaHei;font-size:14px;">// 从尾到头打印单链表（栈）
	public void reList2(Node head) {
		Stack<Node> s = new Stack<Node>();
		while (head != null) {
			s.push(head);
			head = head.next;
		}
		while (!s.isEmpty()) {
			System.out.println(s.pop().value);
		}
	}</span>

9、由小到大合并有序单链表-循环

<span style="font-family:Microsoft YaHei;font-size:14px;">	// 由小到大合并俩个有序的单链表(循环)
	public Node mergeSort1(Node head1, Node head2) {
		// 安全性检查
		if (head1 == null)
			return head2;
		if (head2 == null)
			return head1;
		// 新建合并节点
		Node target = null;
		// 确定第一个元素的节点
		if (head1.value > head2.value) {
			target = head2;
			head2 = head2.next;
		} else {
			target = head1;
			head1 = head1.next;
		}
		target.next = null;
		// 开始合并
		Node mergeHead = target;
		while (head1 != null && head2 != null) {
			// 当两个链表都不为空
			if (head1.value > head2.value) {
				target.next = head2;
				head2 = head2.next;
			} else {
				target.next = head1;
				head1 = head1.next;
			}
			target = target.next;
			target.next = null;
		}
		if (head1 == null)
			target.next = head2;
		else
			target.next = head1;
		return mergeHead;

	}</span>

10、由小到大合并有序单链表-递归

<span style="font-family:Microsoft YaHei;font-size:14px;">// 由小到大合并俩个有序的单链表(递归)
	public Node mergeSort2(Node head1, Node head2) {
		if (head1 == null)
			return head2;
		if (head2 == null)
			return head1;
		if (head1.value > head2.value) {
			head2.next = mergeSort2(head2.next, head1);
			return head2;
		} else {
			head1.next = mergeSort2(head1.next, head2);
			return head1;
		}
	}</span>