基础算法题-链表相关

1. 输入一个链表，从尾到头打印链表每个节点的值。

先递归，再添加节点的值即可。
代码如下：

ArrayList<Integer> printListFromTailToHead(ListNode listNode) {    ArrayList<Integer> array = new ArrayList<Integer>();    if (listNode != null) {        array = printListFromTailToHead(listNode.next);        array.add(listNode.val);    }    return array;}

2. 输入一个链表，输出该链表中倒数第k个结点。

设置两个指针指向链表头，一个先走K步，然后两个指针一起向后移动，第一个指针到尾部时候，第二个指针即倒数第K个结点。
代码如下：

ListNode FindKthToTail(ListNode head, int k) {    if (head == null | k < 0) return null;    ListNode pointer1 = head;    ListNode pointer2 = head;    int count = 1;    while (pointer2.next != null) {        if (count < k) {            pointer2 = pointer2.next;            count++;        } else {            pointer2 = pointer2.next;            pointer1 = pointer1.next;        }    }    if (count == k)        return pointer1;    else        return null;}

3. 输入一个链表，反转链表后，输出链表的所有元素。

用两种方式来解决，第一种递归解决，考虑有一个k结点，将k结点后链表逆转后的头结点返回，此时k结点指向的结点是逆转后链表的尾部结点，将k结点移到逆转后链表的尾部即可。
代码如下：

ListNode ReverseList(ListNode head) {    if (head == null) return null;    //递归解决    if (head.next == null)        return head;    ListNode head1 = ReverseList(head.next);    head.next.next = head;    head.next = null;    return head1;}

第二种方式，通过在原始链表中操作，采用头插法即可逆置。
代码如下：

ListNode ReverseList(ListNode head) {    if (head == null) return null;    ListNode pointer = head.next;    ListNode pointer1 = head;    while (pointer != null) {        head.next = pointer.next;        pointer.next = pointer1;        pointer1 = pointer;        pointer = head.next;    }    return pointer1;}

4. 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

两种方式解决，一种递归，首先比较两个链表的头结点，获得了一个较小的结点，此时应该递归比较结点后的链表和另一个链表即可。
代码如下：

ListNode Merge(ListNode list1, ListNode list2) {    if (list1 == null) return list2;    if (list2 == null) return list1;    ListNode pointer1 = list1;    ListNode pointer2 = list2;    //递归实现    if (list1.val <= list2.val) {        pointer1 = list1;        pointer1.next = Merge(list1.next, list2);    } else {        pointer1 = list2;        pointer1.next = Merge(list1, list2.next);    }    return pointer1;}

第二种迭代解决。采用尾插法，不断的将较小的结点插入。代码如下：

ListNode Merge(ListNode list1, ListNode list2) {    if (list1 == null) return list2;    if (list2 == null) return list1;    ListNode pointer1 = list1;    ListNode pointer2 = list2;    ListNode head = new ListNode(0);    ListNode rear = head;//尾插法    while (pointer1 != null && pointer2 != null) {        if (pointer1.val <= pointer2.val) {            rear.next = pointer1;            rear = pointer1;            pointer1 = pointer1.next;        } else if (pointer1.val > pointer2.val) {            rear.next = pointer2;            rear = pointer2;            pointer2 = pointer2.next;        }    }    if (pointer1 != null)        rear.next = pointer1;    else if (pointer2 != null)        rear.next = pointer2;    return head.next;}

5. 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。

首先在原始复杂链表上进行复制结点操作，例如1->2->3变为1->1->2->2->3->3。然后将特殊的指针也进行赋值。每个特殊指针不为空的结点后一个结点的特殊指针指向，前一个结点特殊指针指向的结点的下一个。最后将结点分离出来即可。
代码如下：

/*public class RandomListNode {    int label;    RandomListNode next = null;    RandomListNode random = null;    RandomListNode(int label) {        this.label = label;    }}*/RandomListNode Clone(RandomListNode pHead) {    if (pHead == null) return null;    RandomListNode pointer = pHead;    while (pointer != null) {        RandomListNode node = new RandomListNode(pointer.label);        node.next = pointer.next;        pointer.next = node;        pointer = node.next;    }    pointer = pHead;    while (pointer != null) {        if (pointer.random == null)            pointer.next.random = null;        else {            pointer.next.random = pointer.random.next;        }        pointer = pointer.next.next;    }    pointer = pHead;    RandomListNode result = pHead.next;    while (pointer != null) {        RandomListNode node = pointer.next;        pointer.next = pointer.next.next;        pointer = pointer.next;        if (pointer != null && pointer.next != null) {            node.next = pointer.next;        }    }    return result;}

6. 输入两个链表，找出它们的第一个公共结点。

有多种方式，这里介绍两种，可以用两个栈将两个链表结点保存，然后两个栈同时出栈进行对比即可，另一个先计算链表长度，然后进行比对。这里只给出第二种的代码，如下：

ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {    int len1 = 0, len2 = 0;    if (pHead1 == null | pHead2 == null) return null;    ListNode pointer1 = pHead1, pointer2 = pHead2;    while (pointer1 != null) {        len1++;        pointer1 = pointer1.next;    }    while (pointer2 != null) {        len2++;        pointer2 = pointer2.next;    }    pointer1 = pHead1;    pointer2 = pHead2;    int more = Math.abs(len1 - len2);    if (len1 <= len2) {        pointer2 = pHead1;        pointer1 = pHead2;    }    while (pointer1 != null && pointer2 != null) {        if (more > 0) {            pointer1 = pointer1.next;            more--;        } else {            if (pointer1 == pointer2) {                return pointer1;            }            pointer1 = pointer1.next;            pointer2 = pointer2.next;        }    }    return pointer1;}

7. 一个链表中包含环，请找出该链表的环的入口结点。

设置三个指针，一个指针走两步，第二个指针走一步，第三个指针在表头。等两个指针在链表中相遇时候，第二个指针和第三个指针同时出发，按一步长走即可，相遇即为入口结点。
代码如下：

ListNode EntryNodeOfLoop(ListNode pHead) {    if (pHead == null | pHead.next == null) return null;    ListNode pointer1 = pHead, pointer2 = pHead;    boolean flag = true;    while (flag) {        pointer1 = pointer1.next;        pointer2 = pointer2.next.next;        if (pointer1 == pointer2) {            flag = false;        }    }    pointer1 = pHead;    if (pointer1 == pointer2) {        flag = true;    }    while (!flag) {        pointer1 = pointer1.next;        pointer2 = pointer2.next;        if (pointer1 == pointer2) {            flag = true;        }    }    return pointer2;}

8. 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。

递归实现，当某结点没有重复，则此结点指向后续结点的处理返回的链表。若有重复，则将结点迭代至最后一个重复结点处，然后后续结点处理返回的链表头结点即头结点，也就是会略过这个结点。
代码如下：

ListNode deleteDuplication(ListNode pHead) {    if (pHead == null || pHead.next == null) {        return pHead;    }    ListNode head = pHead;    boolean flag = false;    int val = pHead.val;    while (pHead.next != null && val == pHead.next.val) {        pHead = pHead.next;        flag = true;    }    if (!flag) {        head.next = deleteDuplication(pHead.next);    } else {        head = deleteDuplication(pHead.next);    }    return head;}