面试大总结：Java搞定面试中的链表题目总结

e (k > 1 && q != null) { q = q.next; k--; } // 当节点数小于k，返回null if (k > 1 || q == null) { return null; } // 前后两个指针一起走，直到前面的指针指向最后一个节点 while (q.next != null) { p = p.next; q = q.next; } // 当前面的指针指向最后一个节点时，后面的指针指向倒数k个节点 return p; }
// 前面指针每次走两步，直到指向最后一个结点，后面指针每次走一步 while (q.next != null) { q = q.next; p = p.next; if (q.next != null) { q = q.next; } } return p; }
/** * 从尾到头打印单链表 * 对于这种颠倒顺序的问题，我们应该就会想到栈，后进先出。所以，这一题要么自己使用栈，要么让系统使用栈，也就 * 。时间复杂度为O（n） */ public static void reversePrintListStack(Node head) { Stack<Node> s = new Stack<Node>(); Node cur = head; while (cur != null) { s.push(cur); cur = cur.next; } while (!s.empty()) { cur = s.pop(); System.out.print(cur.val + " "); } System.out.println(); } /** * 从尾到头打印链表，使用递归（优雅！） */ public static void reversePrintListRec(Node head) { if (head == null) { return; } else { reversePrintListRec(head.next); System.out.print(head.val + " "); } }
2
// 反转后新链表指针
// 用preCur保存住对要处理节点的引用 // cur更新到下一个节点 // 更新要处理节点的next引用 // reHead指向要处理节点的前一个节点
1 -> 2 -> 3 -> 4 head 1-------------| 4 -> 3 -> 2 reHead head.next 4 -> 3 -> 2 -> 1 reHead 4 -> 3 -> 2 -> 1 -> null reHead */ public static Node reverseListRec(Node head){ if(head == null || head.next == null){ return head; } Node reHead = reverseListRec(head.next); head.next.next = head; // 把head接在reHead串的最后一个后面 head.next = null; // 防止循环链表 return reHead; }
//
printList(n1); System.out.println(getListLength(n1)); Node head = reverseList(n1); Node head = reverseListRec(n1); printList(head); Node x = reGetKthNode(head, 2); System.out.println(x.val); x = getMiddleNode(head); System.out.println(x.val); System.out.println("reversePrintListStack:"); reversePrintListStack(head);
// 查找单链表的中间结点 /** * 此题可应用于上一题类似的思想。也是设置两个指针，只不过这里是，两个指针同时向前走，前面的指针每次走两步， * 前面的指针走到最后一个结点时，后面的指针所指结点就是中间结点，即第（n/2+1）个结点。注意链表为空，链表结 */
3
public static Node getMiddleNode(Node head) { if (head == null || head.next == null) { return head; } Node q = head; Node p = head; // p---q
// Node r // head.next.next // head.next = null;
/** * 查找单链表中的倒数第K个结点（k > 0） * 最普遍的方法是，先统计单链表中结点的个数，然后再找到第（n-k）个结点。注意链表为空，k为0，k为1，k大于链 * 。时间复杂度为O（n）。代码略。 这里主要讲一下另一个思路，这种思路在其他题目中也会有应用。 * 主要思路就是使用两个指针，先让前面的指针走到正向第k个结点 * ，这样前后两个指针的距离差是k-1，之后前后两个指针一起向前走，前面的指针走到最后一个结点时，后面指针所指 */ public static Node reGetKthNode(Node head, int k) { // 这里k的计数是从1开始，若k为0或链表为空返回null if (k == 0 || head == null) { return null; } Node q = head; // q在p前面 Node p = head; // p在q后面 p--q
1
System.out.println("reversePrintListRec:"); reversePrintListRec(head); } private static class Node { int val; Node next; public Node(int val) { this.val = val; } } public static void printList(Node head) { while (head != null) { System.out.print(head.val + " "); head = head.next; } System.out.println(); } // 求单链表中结点的个数 // 注意检查链表是否为空。时间复杂度为O（n） public static int getListLength(Node head) { // 注意头结点为空情况 if (head == null) { return 0; } int len = 0; Node cur = head; while (cur != null) { len++; cur = cur.next; } return len; } // 翻转链表（遍历） // 从头到尾遍历原链表，每遍历一个结点， // 将其摘下放在新链表的最前端。 // 注意链表为空和只有一个结点的情况。时间复杂度为O（n） public static Node reverseList(Node head) { // 如果链表为空或只有一个节点，无需反转，直接返回原链表表头 if (head == null || head.next == null) { return head; } Node reHead = null; Node cur = head; while (cur != null) { Node preCur = cur; cur = cur.next; preCur.next = reHead; reHead = preCur; } return reHead; } // 翻转递归（递归） // 递归的精髓在于你就默认reverseListRec已经成功帮你解决了子问题了！但别去想如何解决的 // 现在只要处理当前node和子问题之间的关系。最后就能圆满解决整个问题。 /* head
面 试大总结：Java搞定面试中的链表题目总结
链表是面试中常出现的一类题目，本文用Java实现了面试中常见的链表相关题目。本文主要参考整合重写了《轻松 搞定面试中的链表题目》和 《算法大全（1）单链表》两篇大作。两篇大神的实现分别是C和C#，因为我更喜欢用 Java面试，所以用Java重写了所有实现，并附上自己的一些思考注释。算法大全（1）单链表 尚未有一些问题尚未 整合进来，很快我会更新本文。接下来还会出关于二叉树的大总结和栈和队列的大总结。因为这些都属于面试中的送 分题！必须毫无偏差地拿下。至于像动态规划这些比较“高端”的算法，就只能靠日积月累，而不能像这样临时突 击了。
/** * 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序 * 这个类似归并排序。尤其注意两个链表都为空，和其中一个为空时的情况。只需要O（1）的空间。时间复杂度为O（m */ public static Node mergeSortedList(Node head1, Node head2) { // 其中一个链表为空的情况，直接返回另一个链表头，O(1) if (head1 == null) { return head2; } if (head2 == null) { return head1; } Node mergeHead = null; // 先确定下来mergeHead是在哪里 if (head1.val < head2.val) {
package LinkedListSummary; import java.util.HashMap; import java.util.Stack;
/** * /luckyxiaoqiang/article/details/7393134 轻松搞定面试中的链表题目 * /jax/archive/2009/12/11/1621504.html 算法大全（1）单链表 * * 目录： * 1. 求单链表中结点的个数: getListLength * 2. 将单链表反转: reverseList（遍历），reverseListRec（递归） * 3. 查找单链表中的倒数第K个结点（k > 0）: reGetKthNode * 4. 查找单链表的中间结点: getMiddleNode * 5. 从尾到头打印单链表: reversePrintListStack，reversePrintListRec（递归） * 6. 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序: mergeSortedList, mergeSortedLis * 7. 判断一个单链表中是否有环: hasCycle * 8. 判断两个单链表是否相交: isIntersect * 9. 求两个单链表相交的第一个节点: getFirstCommonNode * 10. 已知一个单链表中存在环，求进入环中的第一个节点: getFirstNodeInCycle, getFirstNodeInCycleHashMap * 11. 给出一单链表头指针pHead和一节点指针pToBeDeleted，O(1)时间复杂度删除节点pToBeDeleted: delete * */ public class Demo { public static void Node n1 = Node n2 = Node n3 = Node n4 = Node n5 = n1.next = n2.next = n3.next = n4.next = main(String[] args) { new Node(1); new Node(2); new Node(3); new Node(4); new Node(5); n2; n3; n4; n5;