1. 两数相加问题
给定两个链表，分别表示两个非负整数。他们的数字逆序存储在链表中，且每个节点只存储一个数字，计算两个数的和，并且返回和的链表头指针。
如：输入：2->4->3 , 5->6->4, 输出：7->0->8.
分析：因为两个数都是逆序存储的，因此可以从头往后加，而且每个节点存储的都是个位数，因此相加不会超过18。模拟两个数按位相加的过程就可以了。用一个额外的变量记录当前位相加是否有进位。
注意：
- 当两个链表长度不相等时该怎么处理？
- 最后一位是否有进位？
/** * 该算法计算两个逆序放置的链表的和，返回和的头指针 * 如：输入：2->4->3 , 5->6->4, 输出：7->0->8. * @param l1 * @param l2 * @return */ public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode h = new ListNode(-1); ListNode res = h; int flag = 0; ListNode p = l1, q = l2; while( p != null && q != null) { int temp = p.val + q.val; if(flag == 1) temp++; flag = temp / 10; temp %= 10; ListNode node = new ListNode(temp); res.next = node; res = res.next; p = p.next; q = q.next; } while(p != null) { int temp = p.val; if(flag == 1) temp++; flag = temp / 10; temp %= 10; ListNode node = new ListNode(temp); res.next = node; res = res.next; p = p.next; } while(q != null) { int temp = q.val; if(flag == 1) temp++; flag = temp / 10; temp %= 10; ListNode node = new ListNode(temp); res.next = node; res = res.next; q = q.next; } if(flag == 1) { ListNode node = new ListNode(1); res.next = node; } return h.next; }
2. 链表部分翻转问题
给定一个链表，翻转该链表熊m到n的位置。要求直接翻转而非申请新空间。
如：给定1->2->3->4->5，m=2, n=4, 返回1->4->3->2->5。
假设给出的参数满足：1 <= m <= n <= 链表长度。
/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ public class Solution { public ListNode reverseBetween(ListNode l, int m, int n) { if(l == null || l.next == null) return l; if(m == n) return l; ListNode l1 = new ListNode(-1); l1.next = l; int count = 0; ListNode head = l1; while(count + 1< m) { head = head.next; count++; } count++; ListNode t = head.next; ListNode p, q; while(count < n) { p = t.next; q = head.next; head.next = p; t.next = p.next; p.next = q; count++; } return l1.next; } }
3. 链表去重问题
1) 给定排序的链表，删除重复元素，只保留重复元素第一次出现的结点。
如：给定：2->3->3->4->7->7->8， 返回：2->3->4->7->8.
/** * 删除链表中所有重复的节点（重复的节点中保留一个） * @param l * @return */ public ListNode deleteDuplicates(ListNode l) { if(l == null || l.next == null) return l; ListNode p = l; while(p != null && p.next != null) { if(p.val == p.next.val) { ListNode q = p.next; p.next = q.next; q.next = null; } else p = p.next; } return l; }
2）给定排序的链表，若发现重复元素，则重复元素全部删除。
如：给定：2->3->3->4->7->7->8， 返回：2->4->8.
/** * 该算法删除所有重复的节点，只要有重复，则全部删除 * @param l * @return */ public ListNode deleteDuplicatesII(ListNode l) { if(l == null || l.next == null) return l; ListNode head = new ListNode(-1); head.next = l; ListNode p = head; int temp = -1; while(p != null && p.next != null) { temp = p.next.val; ListNode q = p.next; boolean flag = false; while(q != null && q.next != null) { if(q.next.val == temp) { flag = true; q = q.next; } else break; } if(flag == true) { p.next = q.next; q.next = null; } else p = q; } return head.next; }
4. 链表划分问题
给定一个链表和一个值x,将链表划分成两部分，使得划分后小于x的节点在前，大于等于x的节点在后。在这两部分中要保持原链表汇总出现的顺序。
如：给定链表1->4->3->2->5->2和x=3，返回1->2->2->4->3->5.
/** * 给定一个链表和一个值x,将链表划分成两部分，使得划分后小于x的节点在前，大于等于x的节点在后。在这两部分中要保持原链表汇总出现的顺序。 * @param head * @param x * @return */ public ListNode partition(ListNode head, int x) { if(head == null || head.next == null) return head; ListNode head1 = new ListNode(-1); ListNode head2 = new ListNode(-1); ListNode h1 = head1, h2 = head2; ListNode p = head, q; while(p != null && p.next != null) { q = p.next; if(p.val < x) { h1.next = p; p.next = null; p = q; h1 = h1.next; } else { h2.next = p; p.next = null; p = q; h2 = h2.next; } } // System.out.println(p.val); if(p.val < x) { h1.next = p; h1 = h1.next; } else { h2.next = p; h2 = h2.next; } h1.next = head2.next; return head1.next; }
5. 单链公共节点问题
给定两个单向链表，计算两个链表的第一个公共节点，若没有公共节点，则返回空。
分析：因为是单链表，所以如果两个链表中有公共结点，只要相遇了就不会分开。以短的链表的长度为基准。
/** * 给定两个单向链表，计算两个链表的第一个公共节点，若没有公共节点，则返回空。 * @param head1 * @param head2 * @return */ public ListNode getIntersectionNode(ListNode head1, ListNode head2) { int len1 = 0, len2 = 0; ListNode p1 = head1, p2 = head2; while(p1 != null) { p1 = p1.next; len1++; } while(p2 != null) { p2 = p2.next; len2++; } ListNode q1 = (len1 > len2) ? head1 : head2; int count = 0; while(count < Math.abs(len1 - len2)) { q1 = q1.next; count++; } ListNode q2 = (len1 <= len2) ? head1 : head2; while(q1 != null && q2 != null) { if(q1 == q2) return q1; else { q1 = q1.next; q2 = q2.next; } } return null; }