数据结构和算法（一）设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

相交链表编程题

编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表：

在节点 c1 开始相交。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。
注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

**具体思路：**

考虑要找到两个长度不同的链表的交点，我们先将两个结点以右边为基准进行对齐，然后把长度大的那个结点多出来的结点删掉，因为这些结点绝对不是相交的结点，接下来的思路具体看代码注释

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
       if (headA==null || headB==null) 
           return null; 
        int lengthA=0,lengthB=0; 
        ListNode pA=headA,pB=headB;
        while (headA!=null){ 
            lengthA++; 
            headA=headA.next; } 
        while (headB!=null){ 
            lengthB++;
            headB= headB.next; }
        for (int i=0;i<Math.abs(lengthA-lengthB);i++){ 
            if (lengthA>lengthB){ 
                pA=pA.next; }
            else { 
                pB=pB.next; 
                 } 
        }
        while (pA!=null){ 
            if (pA==pB) 
                return pA; 
            pA=pA.next; 
            pB=pB.next; } 
            return null;
    }
}

删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：
给定的 n 保证是有效的。
进阶：
你能尝试使用一趟扫描实现吗？

这个编程题目主要考察代码的鲁棒性，程序能够判断输入是否合乎规范要求，并对不符合要求的输入予以合格的处理。
需要格外关注函数的输入参数，比如输入参数有指针，就要考虑指针为空的特殊情况；输入参数有字符串，需要考虑字符串为空的情况；
然后这道题目，我们需要考虑
1、链表节点的个数是不是大于N个；
2、头节点为空；
3、输入的参数k的值为0；
首先会想到遍历链表两次，第一次统计链表的节点的个数，第二次找到第N-n+1个节点就行，但需要的解法是只需要遍历链表一次；
为了只遍历一次链表就能找到倒数第k个节点，可以定义两个指针，一个快指针先走k-1步，然后慢指针从表头开始遍历，当快指针到达链表尾节点，慢指针正好指向倒数第k个节点；

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
       if(head==null||head.next==null){
            return null;
        }
        //1.
        ListNode right=head;
        ListNode left=head;
        //2.
        for(int i=0;i<n;i++){
            right=right.next;
        }
        //3.
        if(right==null){
            return head.next;
        }
        //4.
        while(right.next!=null){
            right=right.next;
            left=left.next;
        }
        //5.
        //6.
        left.next=left.next.next;
        return head;
    }
}

奇偶链表
给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。

示例 1:

输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

示例 2:

输入: 2->1->3->5->6->4->7->NULL
输出: 2->3->6->7->1->5->4->NULL

说明:

应当保持奇数节点和偶数节点的相对顺序。
链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。

思路

穿针引线的赶脚

1.定义odd指针从head开始，用于穿奇数位节点

2.定义even指针从head.next开始，用于穿偶数为节点

3.在此注意一点，先穿奇，后穿偶，但是穿完之后，偶数位链表要在奇数位链表之后，所以事先存好偶数位链表的开始节点

4.开穿，直到even到达末尾（偶数肯定先到最后嘛）

5.然后把偶连在奇后头

6.返回head即可，head始终还是奇的开始.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode oddEvenList(ListNode head) {
        if(head==null ||head.next==null)
            return head;
        ListNode odd=head;//奇数指针；
        ListNode even=head.next;//偶数指针；
        ListNode evenStart =head.next;
        
        while(even!=null&&even.next!=null){
            odd.next=odd.next.next;
            even.next=even.next.next;
            odd=odd.next;
            even=even.next;     
            
        }
        
        odd.next=evenStart;//这一步将连接起来奇偶；
        return head; 
        
    }
}

合并两个有序链表
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
分析：
定义一个递归函数完成合并过程；
解决代码鲁棒性的问题，在本题中一旦输入空链表就会引入空的指针，因此要对空链表单独处理。当第一个链表是空链表，那么它和第二个链表合并，显然合并的结果就是第二个链表。同样第二个链表是空的，我们把第一个链表合并得到的结果就是第一个链表。如果两个链表都是空的，则合并的结果是得到一个空链表。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null || l2 == null)
            return l1 != null ? l1 : l2;
        ListNode merge = null;
        if(l1.val<l2.val)
        {
            merge=l1;
        merge.next=mergeTwoLists(l1.next,l2);
        }
        else
        {
            merge=l2;
        merge.next=mergeTwoLists(l1,l2.next);
        }
       
        return  merge;
        
    }
}