链表

目录

• Leetcode #160 相交链表
  • 方法1：
  • 方法2：
• Leetcode #206 翻转链表
  • 方法1：迭代
  • 方法2：递归
• Leetcode #21 合并链表
  • 方法1：常规遍历
  • 方法2：递归
• Leetcode #83 删除排序链表中重复的元素
  • 方法一：
  • 方法二：
• Leetcode #19 删除链表倒数第n个结点
  • 方法一：
  • 方法二：一次扫描
• Leetcode #24 两两交换链表中的结点
  • 方法：
• Leetcode #328 奇偶链表
  • 方法：

Leetcode #160 相交链表

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

具体描述请查看Leetcode相关网页：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/

方法1：

1.利用指针及链表特性数出两个链表各自长度
2.使较长的链表的头指针先向前移动多出来的长度，使得两链表从当前位置处开始长度相等
3.移动两个指针，直到两个指针值相等时退出循环
4.返回该指针

这个方法很显而易见，就不具体阐述了

方法2：

我们可以得出链表长度由两部分组成，一部分是公共部分，一部分是非公共部分。

要点：如果我知道了A链表和B链表各自非公共部分的长度，那么只要走完这个非公共部分的长度，指针所指即是答案。

假设有链表A、B。 A链表非公共部分长度为a，B链表非公共部分长度为b，公共部分长度为c，那么我们可以可以很容易得出的一个等式： a + c + b = b + c + a其中左边的 a + c 和右边的 b + c 其实就是两个链表各自的长度了。那么这句等式具体是什么意思呢？
我们可以这样理解：PA 和 PB刚开始是分别指向链表A、B的指针，不断的令PA、PB往下一个结点移动，当PA走完A链表的长度后(也就是走完a + c的距离后)，令PA指向B链表的头部，再走一个b的距离(也就是B链表非公共部分的长度)，这不就实现了我们的那个要点嘛！！！！

上代码：

    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *la = headA, *lb = headB;
        while(la != lb)
        {
            la = (la == NULL)? headB : la->next;
            lb = (lb == NULL)? headA : lb->next;
        }
        return la;
    }

Leetcode #206 翻转链表

题名：翻转链表
描述：反转一个单链表。分别写出迭代和递归算法。

具体描述请查看Leetcode相关网页：https://leetcode-cn.com/problems/reverse-linked-list/

方法1：迭代

迭代无非就是按顺序从头遍历，在遍历的同时就行翻转操作！
我们可以设置连个三个指针, pre, cur, next。初始时，pre指向NULL，cur指向头结点(注意这里的头结点也是元素节点，并不是空节点)，next指向头结点的下一个结点。
用这三个指针遍历整个数组，每一次将cur的指针指向pre所指的结点，next用于记录下一个结点的位置。结束条件是当cur为空。代码如下：

    ListNode* reverseList(ListNode* head) {
        ListNode *pre = NULL, *cur = head;
        while(cur)
        {
            ListNode *next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }

还有一种方法，速度要快得多，当然也消耗了多余的空间，是空间换时间的思想。它就是多申请了一个头结点，然后用头插法进行翻转。代码如下：

    ListNode* reverseList(ListNode* head) {
        ListNode *nh = new ListNode(-1);
        while(head)
        {
            ListNode *next = head->next;
            head->next = nh->next;
            nh->next = head;
            head = next;
        }
        return nh->next;
    }

方法2：递归

递归算法思想还是比较好像的，关键在于细节。
此处再次回顾一下递归的思想：把大问题化成具有相同性质的小问题，在解决小问题后再自然而然地解决大问题。
关键是：1.递归出口 2.递归式 3.返回值 4.具体实现

这个翻转链表的问题就是一个典型的递归问题。将一个较长的链表进行翻转，那我就先去翻转较短的子链表。例如要对1->2->3->4->5进行翻转，我就先去翻转2->3->4->5，要对2->3->4->5进行翻转我就先去翻转3->4->5，知道最后仅仅翻转5,这么个最小的问题，所以递归出口也就在这里了。这样大概的就可以写出一个雏形：

    ListNode* reverseList(ListNode* head) {
        //先写递归出口
        if(head == NULL || head->next == NULL)
            return head;
        //再写递归式
        ListNode *next = head->next;//指向下一个较短链表
        ListNode *newhead = reverseList(next);//翻转这个较短的链表
        
        ......
        return newhead;//返回值可以马上就确定下来，就是指向翻转后新链表的头指针
    }

这样雏形就出来了，这时候就应该想如何去翻转某个具体的链表。例如翻转4->5，head是指向4的，next是指向5的，那么要变成5->4，就是next->next = head; head->next = NULL;所以具体代码如下：

    ListNode* reverseList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode *next = head->next;
        ListNode *reversed = reverseList(next);
        next->next = head;
        head->next = NULL;
        return reversed;
    }

Leetcode #21 合并链表

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

具体描述请查看Leetcode相关网页：https://leetcode-cn.com/problems/merge-two-sorted-lists/

方法1：常规遍历

将两个链表合并成一个链表，是链表基本操作！
为了思考起来比较方便，我们可以引入一个头结点，然后设置一个用于移动遍历的指针p，指向头结点。对l1，l2进行遍历每次穿起较小的那个节点，代码如下：

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *newlist = new ListNode(-1);
        ListNode *p = newlist;
        while(l1 && l2)
        {
            if(l1->val <= l2->val)
            {
                p->next = l1;
                p = l1;
                l1 = l1->next;   
            }
            else
            {
                p->next = l2;
                p = l2;
                l2 = l2->next; 
            }
        }
        while(l1)
        {
            p->next = l1;
            p = l1;
            l1 = l1->next;
        }
        while(l2)
        {
            p->next = l2;
            p = l2;
            l2 = l2->next;
        }
        return newlist->next;
    }

方法2：递归

递归思想回顾：
1.递归出口； 显而易见，当链表为空时，就到了递归的边界了。
2.递归式；
3.返回值； 因为是单链表，只有知道链表头指针才能遍历整个链表，所以返回值是指向新链表的指针。
4.具体实现； 取整个递归过程中，某一层(只需要一层，而不需要完全搞清楚整个递归栈是如何运作的)递归的实现即是具体实现。

其中递归式，就是用来把大问题化解为小问题的。
具体实现要取整个递归过程中的某一层递归，取设计其实现。例如这一题：(取第一层递归)假设我们有两链表L1: 1->3->5->7 L2: 2->4->6->8；
因为要求升序，所以合并1->3->5->7和2->4->6->8，相当先合并3->5->7和2->4->6->8并返回新合并链表的头指针newlist(由递归的正确性，我们可以得知newlist链表就是2->3->4->5->6->7->8，而newlist是指向2的)，再使1->(指向)返回的头指针newlist，结果就是1->2->3->4->5->6->7->8

具体代码如下：

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL)
            return l2;//返回值永远是指向新链表的指针！
        if(l2 == NULL)
            return l1;
        if(l1->val < l2->val)
        {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
        else
        {
            l2->next = mergeTwoLists(l2->next, l1);
            return l2;
        }
    }

Leetcode #83 删除排序链表中重复的元素

题名：deleteDuplicates
描述：给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

具体描述请查看Leetcode相关网页：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/

方法一：

因为链表是sorted已排序的，所以可以用双指针法，然后遍历整个链表，较为简单不再叙述，上代码：

    ListNode* deleteDuplicates(ListNode* head) {
        ListNode *p = head, *q;
        if(p)   q = p->next;
        bool ndd = false;
        while(q != NULL)
        {
            if(p->val == q->val)
                ndd = true;
            else
            {
                if(ndd)
                {
                    p->next = q;
                    ndd = false;
                }
                p = q;
            }
            q = q->next;
        }
        if(ndd)
            p->next = q;
        return head;
    }

方法二：

可以用递归的方法，能减少代码量：
这里递归式就是要加一个判断。假设有p，q指针，当p->val != q->val时，再用递归，代码如下：

    ListNode* deleteDuplicates(ListNode* head) {
        if(!head)
            return head;
        ListNode *p = head, *q = head->next;
        while(q && p->val == q->val) //加一个判断
            q = q->next;
        ListNode *res = deleteDuplicates(q);
        head->next = res;
        return head;
    }

Leetcode #19 删除链表倒数第n个结点

题名：删除链表倒数第n个结点
描述：给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

具体描述请查看Leetcode相关网页：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/

方法一：

需要扫描2遍链表，第一遍是计算出链表总长度m，令ltf = m - n 再从头扫描到ltf处，删除该位置的结点即可。链表操作一般引入一个空头结点会比较方便。

代码如下：

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode hh(-1);//引入一个头结点；在栈空间中，退出该函数后会自动销毁；如果要new一个则在堆空间中，记得最后要自己释放该空间！
        hh.next = head;
        ListNode *p = head;
        int count = 0;
        while(p){
            count++;
            p = p->next;
        }
        p = head;
        ListNode *pre = &hh;
        int lft = count - n;
        while(lft--){
            pre = p;
            p = p->next;
        }
        pre->next = p->next;
        return hh.next;
    }

方法二：一次扫描

如何做到一次扫描就能删除倒数第n个结点呢？可以将扫描时得到的各节点的地址记录到数组中，因为数字索引是O(1)的，故而可以做到一次扫描就完成。
代码如下：

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        vector<ListNode *> vi;
        ListNode hh(-1);
        hh.next = head;
        vi.push_back(&hh);
        ListNode *p = head;
        while(p){
            vi.push_back(p);
            p = p->next;
        }
        vi[vi.size() - n - 1]->next = vi[vi.size() - n]->next;
        return hh.next;
    }

Leetcode #24 两两交换链表中的结点

题名：两两交换链表中的结点
描述：给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

具体描述请查看Leetcode相关网页：https://leetcode-cn.com/problems/swap-nodes-in-pairs/

方法：

同样的，引入一个空头结点将简化很多思想和操作。要考虑链表中元素个数为奇数个的情况，此时最后一个结点无需交换。
代码如下：

    ListNode* swapPairs(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode hh(-1);
        ListNode *p = head, *q = head->next, *f = &hh;
        while(p && q){
            //需要四个指针: f,p,q,next；用于完成交换
            ListNode *next = q->next;
            f->next = q;
            q->next = p;
            p->next = next;
            //更新f,p,q
            f = p;
            p = next;
            if(p)    q = p->next;//考虑p是空指针的情况
        }
        return hh.next;
    }

Leetcode #328 奇偶链表

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

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

具体描述请查看Leetcode相关网页：https://leetcode-cn.com/problems/odd-even-linked-list/

方法：

又是一题List + Simulation的题，按照题意进行模拟即可。我们分成奇偶两个链表同时进行。

    ListNode* oddEvenList(ListNode* head) {
        if(!head || !head->next)    return head;//如果是空链表或链表结点数小于2，不需要操作直接返回；
        ListNode *oddp = head, *evenp = head->next, *p = head, *op, *ep;//oddp和evenp分别指向奇偶链表的表头；op和ep用于移动；
        while(p && p->next){//因为是对奇偶链表同时进行，所以要往后多看一个结点是否为空
            op = p;
            ep = p->next;
            p = p->next->next;//p指向下一次while开始处
            if(ep->next){//如果ep的下一个结点也非空
                op->next = ep->next;//将结点插入奇数链表
                if(ep->next->next){//如果ep的下下个结点非空
                    ep->next = ep->next->next;//插入偶数链表
                }
            }      
        }
        if(!p)  op->next = evenp;//这里要分情况；如果输入链表结点个数为偶数个，那么从while出来p一定是NULL
        else//如果输入链表结点个数为奇数个，那么从while出来p->next一定是NULL，而p是非空
            op->next->next = evenp;//将奇数链表的最后一个结点的next指针指向偶数链表表头，以串联起奇偶链表；
        ep->next = NULL;//令偶链表，表尾指向NULL；
        return head;
    }