本篇主要是单向链表题型的实战，比如反转单向链表、查找单向链表的中间节点、判断一个链表是否有环、合并两个有序链表、判断一个单向链表是否是回文链表。
/** * Node为链表结点对象 */ class Node { public Integer data; public Node next; public Node(Integer data){ this.data = data; } } public class LinkedListUtil { /** * 反转一个单向链表 * 思路：申请两个变量(指针）pre、cur,pre指向null，cur指向头结点，cur充当临时变量保存着当前操作结点的下一结点 * @param head * @return */ public static Node reverseList(Node head){ Node pre = null; Node cur = head; while(cur != null){ cur = head.next; head.next = pre; pre = head; head = cur; } return pre; } /** * 获得链表的中间节点,若是单节点链表则返回头结点 * 思路：申请两个变量(指针)pre、cur，pre指向头结点，cur指向头结点的下一个结点，然后pre每次走一步，cur每次走两步，当cur为null或者cur的下一结点为null则此时pre即为中间节点 * @param head * @return */ public static Node getMiddleNode(Node head) { if(head == null) { return head; } Node pre = head; Node cur = head.next; while(cur != null && cur.next != null){ pre = pre.next; cur = cur.next.next; } return pre; } /** * 判断一个链表是否有环 * 思路：申请两个变量（指针）pre、cur指向头结点，pre每次走一步，cur每次走两步，若pre等于cur则说明有环 * @param head * @return */ public static boolean isCircle(Node head) { Node pre = head; Node cur = head; while(cur != null && cur.next != null){ pre=pre.next; cur=cur.next.next; if(pre == cur){ return true; } } return false; } /** * 合并两个有序链表为一个升序链表 * * @param head1 有序链表1的头节点 * @param head2 有序链表2的头节点 * @return */ public static Node merageOrderedList(Node head1, Node head2) { if (head1 == null) { return head2; } if (head2 == null) { return head1; } Node temp1 = head1; Node temp2 = head2; Node tempHead1 = head1; Node tempHead2 = head2; /*判断链表1是否升序，若不是则反转链表1*/ while(temp1 != null && temp1.next != null){ if(temp1.data > temp1.next.data){ tempHead1 = reverseList(tempHead1); break; } temp1 = temp1.next; } /*判断链表2是否升序，若不是则反转链表2*/ while(temp2 != null && temp2.next != null){ if(temp2.data > temp2.next.data){ tempHead2 = reverseList(tempHead2); break; } temp2 = temp2.next; } //用变量head保存合并后有序链表的头节点 Node head = null; if(tempHead1.data < tempHead2.data){ head = tempHead1; tempHead1 = tempHead1.next; }else { head = tempHead2; tempHead2 = tempHead2.next; } Node cur = head; /*执行合并两个链表*/ while(tempHead1 != null && tempHead2 != null){ if(tempHead1.data < tempHead2.data){ cur.next= tempHead1; tempHead1= tempHead1.next; cur = cur.next; }else{ cur.next = tempHead2; tempHead2 = tempHead2.next; cur = cur.next; } } /*执行合并操作结束后，若其中一个链表不为空则将该链表接到合并链表之后*/ if(tempHead1!= null){ cur.next = tempHead1; } if(tempHead2!= null){ cur.next = tempHead2; } return head; } /** * 判断一个单向链表是否为回文链表 * 思路：反转后半部分链表，然后与前半部分比对，若有不同则不是回文链表，否则是回文链表，然后反转链表复原并拼接到前半部分 * @param head * @return */ public static boolean isPalindrome(Node head){ if(head == null || head.next == null){ return false; } boolean flag = true; //找到链表的中间节点 Node pre = getMiddleNode(head); //反转后半部分的链表 Node reverseHead = reverseList(pre.next); //用cur临时存储一份反转链表的头结点 Node cur = reverseHead; Node helpHead = head; while (cur != null){ if(!cur.data.equals(helpHead.data)){ flag = false; break; } cur = cur.next; helpHead = helpHead.next; } pre.next = reverseList(reverseHead); return flag; } public static void main(String[] args){ Node head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); boolean isCircle = isCircle(head); boolean palindrome = isPalindrome(head); Node middle = getMiddleNode(head); System.out.println("是否为环：" + isCircle); System.out.println("是否是回文串"+palindrome); System.out.println("中间节点：" + middle.data); // System.out.println(); // Node reverse = reverseList(head); // while (reverse != null){ // System.out.print(reverse.data + "\t"); // reverse = reverse.next; // } // System.out.println(); // Node root = new Node(3); // root.next = new Node(5); // Node mearge = merageOrderedList(head,reverse); // while(mearge != null) { // System.out.print(mearge.data + "\t"); // mearge = mearge.next; // } // Node ress = reverseList(head); Node test = new Node(1); test.next = test; System.out.println(isCircle(test)); } }