C++/java中的链表及常见题目汇总

一、链表

　  链表实现了零碎数据的有效组织，比如说，我们用malloc申请内存，内存足够，而由于内存碎片太多，没有连续内存，只能以申请失败而告终。而用链表这种数据结构来组织数据，可以解决此类问题。

　  链表中至少有两个域，一个域用于数据元素的存储，一个域指向其他单元的指针。

        

 

 

链表可以分为单向链表和双向链表。

1. 单向链表

　　单向链表（单链表）是链表的一种，其特点是链表的连接方式是单向的，对俩表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称结点列表。因为链表是由一个个结点组装起来的，其中每个结点都有指针成员变量中的下一个结点

　　由于STL中有可以直接使用的库list，但是为了更清楚链表的构成，我们尝试自己实现一个链表，包括如下内容

• 链表的创建
  • 头插法
  • 尾插法
• 链表的查找
• 链表的删除

 

• 链表的创建
  • 尾插法

　　　　　　相较与头插法，尾插法是更简单的，其就是每次在链表的尾部插入数据　　

　　　　      　　

　　　　　　链表中的内存结构如下

　　　　 　              　

 

 尾插法参考代码如下

Node* createListTail()
{
    Node* head = new Node;
    if (head == nullptr)
        return nullptr;
    head->next = nullptr;
    Node* t = head;
    Node* cur;
    int nodeData;
    scanf_s("%d", &nodeData);
    while (nodeData)
    {
        cur = new Node;
        cur->data = nodeData;
        t->next = cur;
        t = cur;
        scanf_s("%d", &nodeData);
    }
    t->next = nullptr;
    return head;
}

 

•  头插法

　　头插法即每次在链表的头部插入数据。

               

 

头插法参考代码

Node* createListHead()
{
    Node* head = new Node;
    if (nullptr == head)
        return nullptr;
    head->next = nullptr;
    Node* t = head;
    Node* cur;
    int nodeData;
    scanf_s("%d", &nodeData);
    while (nodeData)
    {
        cur = new Node;
        if (nullptr == cur)
            exit(-1);
        cur->data = nodeData;
        cur->next = head->next;
        head->next = cur;
        scanf_s("%d", &nodeData);
    }
    return head;

}

 

•  链表的查找

　　遍历整个链表，如果链表的值等于查找的值，直接返回，否则返回空指针。

Node* searchList(Node* head, int findData)
{
    while (head)
    {
        if (head->data == findData)
            return head;
        head = head->next;
    }
    return nullptr;
}

 

• 链表的删除

　　要删除链表中的值，首先我们需要找到待删除链表的前驱节点，然后前驱节点的下一个指针指向待删除结点的下一个指针。但是这样会有O(n)的时间代价，因此我们寻求一个更好的方法。

　　可以将待删除节点下一个结点的数值复制到待删除结点中，删除待删除结点的下一个结点即可

void deleteListNode(Node* head, Node* del)
{
    if (del->next == nullptr)
    {
        while (head->next!=del)
        {
            head = head->next;
        }
        head->next = del->next;
        delete del;
        del = nullptr;
    }
    else
    {
        Node* t = del->next;
        del->data = del->next->data;
        del->next = del->next->next;
        delete t;
    }
}

 

2. 常见题目及汇总

1. 反转链表
2. 反转链表2
   1. 合并两个链表
3. 回文链表
4. 删除重复项：对比数组删除重复项和链表删除重复项
   1. 删除数组中的重复项
   2. 删除链表中的重复项
   3. 删除链表中的重复项2
   4. 移除重复节点
   5. 删除链表中的节点
   6. 删除链表中的节点2
   7. 删除链表中的节点3
   8. 从链表中删去总和值为零的连续节点
5. 两两交换链表中的节点　　
6. 链表的中间节点
7. 复杂链表的复制
8. 奇偶链表
9. 归并排序
   1. 归并排序数组
   2. 利用归并排序求数组中的逆序对
   3. 合并两个有序链表
   4. 归并排序链表　　
10. 两数相加：考虑进位的情况
    1. 两数相加1
    2. 两数相加2　　
11. 两个链表的第一个公共节点
12. 分割链表
    1. 分隔链表2　　
13. 环形链表
    1. 判断链表是否有环
    2. 找出链表中环的入口节点　
14. 倒数第k个结点：
    1. 链表中倒数第k个结点
    2. 删除链表中倒数第k个结点　　
15. 涉及两个链表的操作
    1. 重排链表　　
16. 二进制链表转化为整数　
17. 链表中下一个更大节点
18. 二叉树中的列表
19. 对链表进行插入排序
20. 　

 

1. 反转链表

• 题目描述

　　

 

•  问题分析

　　为了正确的反转一个链表，需要调整链表中指针的方向，我们可以借助图形直观的进行分析。下图中，h,i,j是3个相邻的节点，假设经过若干操作，我们已经bah交接点之前的指针调整完毕，这些节点的next指针都指向前面一个节点，接下来我们把i的next指针指向h，此时链表结构如图所示

        

 

　　不难注意到，节点i的next指针指向了其前一个节点，导致无法在链表中遍历到节点j，为了避免链表在节点i处断开，需要在调整节点i的next之前，把节点j保存下来。

　　三个指针，一个指向其前驱节点，一个指向当前节点，一个指向当前节点的下一个结点

 

 

 

 

•  C++参考代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==nullptr)
            return nullptr;
        ListNode* pNode=head;
        ListNode* reverseHead=nullptr;
        ListNode* prev=nullptr;
        while(pNode)
        {
            ListNode* next=pNode->next;
            if(pNode->next==nullptr)
                reverseHead=pNode;
            pNode->next=prev;
            prev=pNode;
            pNode=next;
        }
        return reverseHead;
    }
};

 

• JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null)
            return null;
        ListNode prev=null;
        ListNode pNode=head;
        ListNode preverseHead=null;
        while(true)
        {
            if(pNode==null)
                break;
            ListNode pNext=pNode.next;
            if(pNext==null)
                preverseHead=pNode;
            pNode.next=prev;
            prev=pNode;
            pNode=pNext;
        }
        return preverseHead;
    }
}

 

 

2. 反转链表2

• 题目描述

　　

 

•  问题分析

　　要实现链表之间部分逆转，我们需要分为两步：

　　　　第一步：实现m和n之间的链表逆转

　　　　第二步：逆转两个节点之间的部分

　　由于可能涉及到链表头的操作，因此对于此类问题，我们一般会引入一个哑指针

　　具体步骤如下图：

　　　　

 

• JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        if(head==null)
            return null;
        /*
            要实现链表的部分反转，四个节点
            a指向m的前一个节点
            b指向节点m
            c指向n的后一个节点
            d指向节点n

            两步实现部分反转
            1. 首先将m和n之间的节点反转
            2. 然后将节点m和节点n反转
        */
        //首先找到结点a,b,c,d
        //由于可能涉及到头结点的操作，因此引入一个哑指针
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode a=dummy;
        for(int i=0;i<m-1;++i)
            a=a.next;
        ListNode b=a.next;
        ListNode d=dummy;
        for(int i=0;i<n;++i)
            d=d.next;
        ListNode c=d.next;
        //首先反转m和n之间的节点
        ListNode prev=a;
        ListNode pNode=prev.next;
        for(int i=m;i<=n;++i)
        {
            ListNode pNext=pNode.next;
            pNode.next=prev;
            prev=pNode;
            pNode=pNext;
        }
        //然后实现节点m和节点n的反转
        a.next=d;
        b.next=c;
        return dummy.next;
    }
}

 

• C++代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        //实现一部分反转本质思想和实现整个链表的反转类似，其主要分为两步：首先反转需要反转的内部，然后在将反转后的链表按照我们需要的连接
        //由于可能涉及到头结点的操作，因此我们需要利用哑节点
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode* dummy=new ListNode;
        dummy->next=head;
        ListNode* a=dummy;
        ListNode* d=dummy;
        //首先令节点a指向m的前一个节点
        for(int i=0;i<m-1;++i)
            a=a->next;
        //然后令节点d指向n指向的节点
        for(int i=0;i<n;++i)
            d=d->next;
        ListNode* b=a->next;
        ListNode* c=d->next;
        //反转m到n之间的链表
        for(auto prev=b,cur=b->next;cur!=c;)
        {
            ListNode* next=cur->next;
            cur->next=prev;
            prev=cur;
            cur=next;
        }
        a->next=d;
        b->next=c;
        return dummy->next;
    }
};

 

2.1 合并链表

• 题目描述

　　

 

•  问题分析

　　

 

• • 首先找到l1中待删除部分的第一个节点的前一个节点和待删除部分最后一个节点的后一个节点
  • 找到链表l2的头结点e和尾结点f
  • 要删除链表l1中的a-b部分，然后l2接在被删除节点的位置，因此m的下一个结点指向e， f的下一个结点指向q即可

 

• JAVA代码参考

　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
        //由于可能涉及到头结点的操作，因此引入一个哑指针
        ListNode dummy=new ListNode(-1);
        dummy.next=list1;
        //用4个结点m,n,p,q,e,f
        /*
            m代表第一个待删除结点的前一个节点
            n代表第一个待删除的节点
            p代表最后一个待删除的节点
            q代表最后一个待删除的节点的后一个节点

            e代表list2的第一个节点
            f代表list2的最后一个节点
        */
        //首先找到m,n节点
        ListNode m=dummy;
        for(int i=0;i<a;++i)
        {
            m=m.next;
        }
        ListNode n=m.next;

        //然后找到p,q节点
        ListNode p=dummy;
        for(int i=0;i<=b;++i)
        {
            p=p.next;
        }
        ListNode q=p.next;
        //然后找到e结点
        ListNode e=list2;
        ListNode f=list2;
        while(f.next!=null)
        {
            f=f.next;
        }
        m.next=e;
        f.next=q;
        return dummy.next;
    }
}

 

 

3. 回文链表

• 题目描述

　　

•  题目分析

　    这道题本质上和之前做过的回文字符串是类似的，不同之处在于，对于单向链表，其尾结点没有指向前面的前驱结点，因此直接两个指针位于链表头和链表尾是不成立的。

   　因此，判断回文链表需要将链表的后半部分反转，才能实现和回文字符串类似的操作

　　具体步骤如下

　　　　第一步：找到链表的中间节点：利用快指针和慢指针，快指针每次走两步，慢指针每次走一步，当快指针到达尾结点时，慢指针到达终点

　　　　第二步：以慢指针为反转头结点对链表的后半部分进行反转

　　　　第三步：类似于回文字符串，依次进行判断

• C++代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        //要判断链表是否是回文的，其和判断回文字符串是类似的，区别在于链表是没有前驱节点的，因此首先是需要将链表后半部分反转
        //第一步：找到链表的中间节点，可以使用快指针和慢指针来进行实现
        if(head==nullptr||head->next==nullptr)
            return true;
        ListNode* fast=head;
        ListNode* slow=head;
        while(fast&&fast->next)
        {
            slow=slow->next;
            fast=fast->next->next;
        }
        //此时slow指向的节点是中间节点，反转slow以后的链表
        ListNode* prev=slow;
        ListNode* cur=slow->next;
        while(cur!=nullptr)
        {
            ListNode* next=cur->next;
            cur->next=prev;
            prev=cur;
            cur=next;
        }
        //反转之后，令slow->next指向空指针，利用两个指针指向链表头和链表尾
        slow->next=nullptr;
        while(head&&prev)
        {
            if(head->val!=prev->val)
                return false;
            head=head->next;
            prev=prev->next;
        }
        return true;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        /*
            要判断一个链表是否是回文链表，可以分为以下几步
            1. 找到链表的中点
                要找到链表的中点，可以采用快慢指针，快指针每次走两步，慢指针每次走一步，快指针走到尾部时，慢指针到达中点
            2. 从中点到链表尾部部分反转链表
            3. 一个指针在尾部，一个指针在头部逐一对比
        */
        if(head==null||head.next==null)
            return true;
        //首先快指针和慢指针，快指针每次走两步，慢指针每次走一步
        ListNode fast=head;
        ListNode slow=head;
        while(true)
        {
            if(fast!=null&&fast.next!=null)
            {
                fast=fast.next.next;
                slow=slow.next;
            }
            else
                break;
        }
        //此时slow处于中点位置。为了便于最后判断，将slow的next指针指向空
        
        //从中点到链表尾部反转链表
        ListNode prev=slow;
        ListNode pNode=prev.next;
        while(true)
        {
            if(pNode==null)
                break;
            ListNode pNext=pNode.next;
            pNode.next=prev;
            prev=pNode;
            pNode=pNext;
        }
        slow.next=null;
        while(true)
        {
            if(head==null||prev==null)
                break;
            if(head.val!=prev.val)
                return false;
            head=head.next;
            prev=prev.next;
        }
        return true;
    }
}

 

 

4. 删除重复项：对比删除排序数组中的重复项和删除排序链表中的重复项

　　4.1 删除排序数组中的重复项

• 题目描述

　　

• 问题分析

　　我们可以使用两个指针，一个指针指向已重新组织的元素，一个指针指向未处理的元素

• 代码参考

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.empty())
            return 0;
        int slow=0;
        int fast=0;
        int len=nums.size();
        for(fast=0;fast<len;++fast)
        {
            if(nums[slow]!=nums[fast])
            {
                nums[++slow]=nums[fast];
            }
        }
        return slow+1;
    }
};

 

　　4.2 删除排序链表中的重复项

• 题目描述

　　

 

•  问题分析

　　为了删除排序链表中的重复项，思路同删除排序数组中的重复项，也是利用双指针：快指针和慢指针，快指针遍历整个链表，慢指针指向待操作的元素，如果快指针指向的元素节点不等于慢指针，则直接将慢指针下一个结点指向快指针，然后同时移动快指针和慢指针。否则只移动快指针

•  C++代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode* slow=head;
        ListNode* fast=head->next;
        ListNode* phead=slow;
        while(fast!=nullptr)
        {
            if(slow->val!=fast->val)
            {
                slow->next=fast;
                fast=fast->next;
                slow=slow->next;
            }
            else
                fast=fast->next;
        }
        slow->next=nullptr;
        return phead;
    }
};

•  JAVA代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null)
            return null;
        ListNode slow=head;
        ListNode fast=head;
        while(true)
        {
            if(fast==null)
                break;
            if(fast.val!=slow.val)
            {
                slow.next=fast;
                slow=slow.next;
            }
            fast=fast.next;
        }
        slow.next=null;
        return head;
    }
}

 

 

4.3  删除链表中的重复节点2

• 题目描述

　　

 

•  问题分析

　　要删除链表中所有含重复数字的节点，需要考虑头结点是否含重复数字

• 代码参考

　　递归版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode* next=head->next;
        if(head->val==next->val)
        {
            while(next&&head->val==next->val)
                next=next->next;
            return deleteDuplicates(next);
        }
        else
        {
            head->next=deleteDuplicates(head->next);
            return head;
        }
        return nullptr;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        //采用递归的方法来实现
        if(head==null||head.next==null)
            return head;
        ListNode next=head.next;
        if(head.val==next.val)
        {
            while(true)
            {
                if(next==null||head.val!=next.val)
                    break;
                next=next.next;
            }
            return deleteDuplicates(next);
        }
        else
        {
            head.next=deleteDuplicates(head.next);
            return head;
        }
    }
}

 

4.4 移除重复节点

• 题目描述

　　

 

•  问题分析

　　在本题中，我们需要移除未排序链表中的重复节点，保留最开始出现的节点。我们可以采用哈希表的形式来实现

　　我们对给定的链表进行一次遍历，并用一个哈希集合(HashSet/unordered_set)来存储所有出现过的节点。由于在大部分语言中，对给定的链表元素直接进行相等比较，实际上是对两个链表元素的地址(而不是值)进行比较。因此，我们在哈希集合中存储链表元素的值，方便直接用等号进行比较

　　具体地，我们从链表的头结点head开始遍历，遍历的指针记为pos，由于头结点一定不会被删除，因此可以枚举待溢出节点的所有前驱节点

　　如果当前移动到的链表节点在哈希集合中未出现过，则直接在哈希集合中添加该元素，遍历指针pos向后移动；如果当前移动的链表节点在哈希集合中出现过，则直接删除该结点

• C++代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeDuplicateNodes(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
            return head;
        unordered_set<int> occurred={head->val};
        ListNode* pos=head;
        while(pos->next!=nullptr)
        {
            ListNode* cur=pos->next;
            //如果哈希集中没有当前链表的值，则直接将当前链表的值插入
            if(!occurred.count(cur->val))
            {
                occurred.insert(cur->val);
                pos=pos->next;
            }
            else
            {
                pos->next=pos->next->next;
            }
        }
        pos->next=nullptr;
        return head;
    }
};

• JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeDuplicateNodes(ListNode head) {
        if(head==null||head.next==null)
            return head;
        //由于第一个节点肯定不会被移除，因此直接将第一个节点移入HashSet
        //从头到尾遍历链表，将链表的前驱节点移入哈希集，如果哈希集中有该结点，则将该结点移除
        Set<Integer> occurred=new HashSet<Integer>();
        occurred.add(head.val);
        ListNode pos=head;
        while(pos.next!=null)
        {
            ListNode cur=pos.next;
            if(occurred.add(cur.val))
            {
                pos=pos.next;
            }
            else
                pos.next=pos.next.next;
        }
        pos.next=null;
        return head;
    }
}

 

4.4. 删除链表中的节点

• 题目描述

      

 

•  问题分析

　　删除值为val的节点可以分为两步：定位节点，修改引用

　　1. 定位节点： 由于删除链表中节点需要用到待删除链表的前驱节点，因此使用双指针，由于可能涉及到头结点的操作，因此引入哑指针

      

 

　　遍历整个数组，直到del->val==val时跳出，即可定位目标节点

　　2. 修改引用，prev->next=del->next

• C++代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if(head==nullptr)
            return nullptr;
        ListNode* dummy=new ListNode(-1);
        dummy->next=head;
        ListNode* prev=dummy;
        ListNode* pdel=head;
        while(pdel->next&&pdel->val!=val)
        {
           prev=pdel;
           pdel=pdel->next;
        }
        prev->next=pdel->next;
        return dummy->next;
    }
};

• JAVA代码参考1

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head==null||head.next==null)
            return head;
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        //找到待删除节点的前驱结点
        ListNode prev=dummy;
        ListNode pdel=head;
        while(pdel.next!=null&&pdel.val!=val)
        {
            prev=pdel;
            pdel=pdel.next;
        }
        prev.next=pdel.next;
        return dummy.next;
    }
}

 

•  JAVA代码参考2

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head==null||head.next==null)
            return head;
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode pHead=head;
        while(pHead!=null)
        {
            /*
                两种情况，第一种情况，当val位于链表的尾结点时，则需要一个一个的去找到结点
            */
            
            if(pHead.val==val)
            {
                //如果val位于链表的尾结点，则需要首先遍历到val的前一个节点
                if(pHead.next==null)
                {
                    dummy.next=pHead.next;
                }
                else
                {
                    pHead.val=pHead.next.val;
                    pHead.next=pHead.next.next;
                }
            }
            pHead=pHead.next;
            dummy=dummy.next;
        }
        return head;
    }
}

• JAVA代码参考3

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head==null)
            return null;
        ListNode dummy=new ListNode(-1);
        dummy.next=head;
        ListNode prev=dummy;
        while(prev!=null)
        {
            if(prev.next.val==val)
            {
                prev.next=prev.next.next;
                break;
            }
            prev=prev.next;
        }
        return dummy.next;
    }
}

 

 

 4.5 移除链表中的节点2

• 题目描述

　　

 

•  问题分析

　　这道题和上一道题的区别是：可能移除的节点不止一个，因此必须从头遍历到尾，其余思路相同的

• 代码参考

　　

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head==nullptr)
            return nullptr;
        ListNode* dummy=new ListNode(-1);
        dummy->next=head;
        ListNode* prev=dummy;
        ListNode* pdel=head;
        while(pdel!=nullptr)
        {
            if(pdel->val==val)
            {
                prev->next=pdel->next;
                pdel=prev->next;
            }
            else
            {
                prev=pdel;
                pdel=pdel->next;
            }
        }
        return dummy->next;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head==null)
            return null;
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode prev=dummy;
        ListNode pdel=head;
        while(pdel!=null)
        {
            //如果找到值为val的节点
            if(pdel.val==val)
            {
                prev.next=pdel.next;
                pdel=prev.next;
            }
            else
            {
                prev=pdel;
                pdel=pdel.next;
            }
        }
        return dummy.next;
    }
}

•  JAVA代码参考2

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head==null)
            return null;
        ListNode dummy=new ListNode(-1);
        dummy.next=head;
        ListNode prev=dummy;
        while(prev!=null&&prev.next!=null)
        {
            if(prev.next.val==val)
            {
                prev.next=prev.next.next;
            }
            else
                prev=prev.next;
        }
        return dummy.next;
    }
}

 

 

4.6 删除链表中的节点3

• 题目描述

　　

 

•  题目分析

　　由于删除的是非尾结点，并且只给定了一个节点，因此要实现节点的删除，我们可以采用如下的方法

   

 

•  代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        if(node==nullptr)
            return;
        node->val=node->next->val;
        node->next=node->next->next;
    }
};

•  JAVA代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val=node.next.val;
        node.next=node.next.next;
    }
}

 

4.8 从链表中删去总和值为零的连续节点

• 题目描述

　　

 

•  问题分析
  • 首先生成一带表头的链表，再利用三个指针进行操作
  • h作为一个前驱节点，方便进行删除操作
  • p, q作为两个前后指针，记录连续和为0的节点的起始位置
  • p总从h的下一个结点开始移动，q总从p的下一个结点开始移动
  • 当出现sum(p, q)=0时，将p至q的节点进行删除，h.next=q.next
  • 注意
    • 当某次进行了删除操作之后，p直接从h的后一个节点开始遍历，而不是将h向后移动，否则无法处理1->2->3->-3->-2->-1的情况
• JAVA代码参考

　　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeZeroSumSublists(ListNode head) {
        //要实现删除链表中总和值为0的连续节点，可以采用如下方法
        /*
            首先利用三个指针，h,p,q，当h.next指针不为0时，开始遍历，如果出现sum=0，则删除中间节点，此时h不用移
        */
        if(head==null)
            return null;
        else if(head.next==null)
        {
            //如果head的值为0，则直接删除
            if(head.val==0)
                return null;
            else
                return head;
        }
        //首先创建头结点
        ListNode dummy=new ListNode(-1);
        dummy.next=head;
        ListNode h=dummy;
        boolean flag=true;
        while(h.next!=null)
        {
            flag=true;
            ListNode p=h.next;
            if(p.val==0)
            {
                h.next=p.next;
                continue;
            }
            ListNode q=p.next;
            int sum=p.val;
            while(q!=null)
            {
                sum+=q.val;
                if(sum==0)
                {
                    h.next=q.next;
                    flag=false;
                    break;
                }
                else
                    q=q.next;
            }
            if(flag)
                h=h.next;
        }
        return dummy.next;
    }
}

 

 

5. 两两交换链表中的节点

• 题目描述

　　

 

•  问题分析

　　即让节点顺序进行两两交换，具体思路如下：

         

• 代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode* dummy=new ListNode;
        dummy->next=head;
        for(auto prev=dummy;prev->next&&prev->next->next;)
        {
            auto small=prev->next,big=small->next;
            prev->next=big;
            small->next=big->next;
            big->next=small;
            prev=small;
        }
       
        return dummy->next;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if((head==null)||(head.next==null))
            return head;
        //要涉及到头结点的操作，因此引入哑节点
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        for(ListNode prev=dummy;prev.next!=null&&prev.next.next!=null;)
        {
            ListNode pcur=prev.next;
            ListNode pnext=prev.next.next;
            prev.next=pnext;
            pcur.next=pnext.next;
            pnext.next=pcur;
            prev=pcur;
        }
        return dummy.next;
    }
}

 

6. 链表的中间节点

• 题目描述

       

 

•  问题分析

　　为了找到中间节点，我们可以用两个指针：快指针和慢指针，快指针每次走两步，慢指针每次走一步，当快指针到达尾结点时，慢指针刚好到达中间节点

• 代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        //两个指针，一个快指针，一个慢指针，快指针每次走两步，慢指针每次走一步，当快指针走到链表尾的时候，慢指针到达终点
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode* fast=head;
        ListNode* slow=head;
        while(fast!=nullptr&&fast->next!=nullptr)
        {
            slow=slow->next;
            fast=fast->next->next;
        }
        return slow;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {
        if(head==null||head.next==null)
            return head;
        //使用快指针和，慢指针，快指针每次走两步，慢指针每次走一步，快指针为空时即找到中间节点
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null)
        {
            fast=fast.next.next;
            slow=slow.next;
        }
        return slow;
    }
}

 

 

7. 复制链表的复制

• 题目描述

      

 

• 问题分析

　　要实现复杂链表的复制，主要分为三个步骤：

　　step1: 将链表中的每个结点进行复制，并将复制后的节点连接到复制前的节点之后

     

 

 

 

　　step2: 设置链表中每个复制后节点的random指针指向。如果复制前的节点为N，复制后的节点为N'，节点N的random指针指向节点S，则N'的random指针指向节点S'，S'是节点S的下一个结点

　　

　　step3: 将长链表分成两个短链表，一个链表是复制之前的，一个链表是复制之后的

 

 

 

 

 

•  代码参考

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    //复杂链表的复制，主要分为三步
    //第一步，复制每一个节点，并将其连接到复制节点的下一个结点
    void clonedNode(RandomListNode* pHead)
    {
        if(pHead==nullptr)
            return;
        RandomListNode* pNode=pHead;
        while(pNode)
        {
            RandomListNode* pclonedNode=new RandomListNode(0);
            pclonedNode->label=pNode->label;
            pclonedNode->next=pNode->next;
            pNode->next=pclonedNode;
            pNode=pclonedNode->next;
        }
    }
    //第二步，设置每一个复制节点的random指针，原始节点N，其random指针指向S，复制节点N'，其random指针指向s'，则s'是s的下一个结点
    void setRandom(RandomListNode* pHead)
    {
        if(pHead==nullptr)
            return;
        RandomListNode* pNode=pHead;
        while(pNode)
        {
            RandomListNode* pclonedNode=pNode->next;
            if(pNode->random)
                pclonedNode->random=pNode->random->next;
            pNode=pclonedNode->next;
        }
    }
    //第三步，将长链表分解成两个短链表
    RandomListNode* reconnect(RandomListNode* pHead)
    {
        if(pHead==nullptr)
            return nullptr;
        RandomListNode* pNode=pHead;
        RandomListNode* pclonedHead=nullptr;
        RandomListNode* pclonedNode=nullptr;
        //首先设置头结点
        if(pNode)
        {
            pclonedHead=pclonedNode=pNode->next;
            pNode->next=pclonedNode->next;
            pNode=pNode->next;
        }
        while(pNode)
        {
            pclonedNode->next=pNode->next;
            pclonedNode=pclonedNode->next;
            pNode->next=pclonedNode->next;
            pNode=pNode->next;
        }
        return pclonedHead;
    }
    RandomListNode* Clone(RandomListNode* pHead)
    {
        clonedNode(pHead);
        setRandom(pHead);
        return reconnect(pHead);
    }
};

 

8. 奇偶链表

• 题目描述

　　

 

•  问题分析

　　要实现将所有奇数节点和偶数节点排列在一起，和复制复制链表中的第三步，将长链表分解成两个短链表类似。因此我们采用的方法是先将链表分解成奇数链表和偶数链表，然后再将偶数链表连接到奇数链表的后面，具体操作步骤如下：

 

•  代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head==nullptr||head->next==nullptr||head->next->next==nullptr)
            return head;
        //odd为奇数，even为偶数
        ListNode* even=head->next;
        ListNode* evenHead=even;
        ListNode* odd=head;
        while(even&&even->next)
        {
            odd->next=even->next;
            odd=odd->next;
            even->next=odd->next;
            even=even->next;
        }
        odd->next=evenHead;
        return head;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode oddEvenList(ListNode head) {
        if(head==null||head.next==null)
            return head;
        //注意这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性
        //因此可以类似复制复杂链表第三步：将长链表分解成两个短链表
        ListNode odd=head;
        ListNode even=head.next;
        ListNode evenHead=even;
        while(even!=null&&even.next!=null)
        {
            odd.next=even.next;
            odd=odd.next;
            even.next=odd.next;
            even=even.next;
        }
        odd.next=evenHead;
        return head;
    }
}

 

8. 归并排序

8.1 归并排序数组

• 题目描述

　　在O(nlogn)时间复杂度和常数级空间复杂度下，对数组进行排序

• 问题分析

　　由于需要空间复杂度在常数级，因此不能使用迭代，归并排序，即先分裂，再合并数组，具体如下

　　

• 代码参考

void Merge(int* p, int* p1, int startIdx, int midIdx, int endIdx)
{
    int i = startIdx, j = midIdx + 1, k = startIdx;
    while (i <= midIdx && j <= endIdx)
    {
        if (p[i] < p[j])
        {
            p1[k++] = p[i++];
        }
        else
            p1[k++] = p[j++];
    }
    while (i <= midIdx)
    {
        p1[k++] = p[i++];
    }
    while (j<=endIdx)
    {
        p1[k++] = p[j++];
    }
    while (startIdx <= endIdx)
    {
        p[startIdx] = p1[startIdx];
        ++startIdx;
    }
}

void MergeSort(int* p, int* p1, int startIdx, int endIdx)
{
    int midIdx;
    if (startIdx < endIdx)
    {
        midIdx = (startIdx + endIdx) / 2;
        MergeSort(p, p1, startIdx, midIdx);
        MergeSort(p, p1, midIdx + 1, endIdx);
        Merge(p, p1, startIdx, midIdx,endIdx);

    }
}

 

8.2 归并排序数组求逆序对

• 题目描述

　　

 

 

•  问题分析

　　可以用两个指针p1,p2分别指向链表的头部，利用归并排序的方法，如果p1<p2,则不存在逆序对，如果p1>p2，则p1后的所有元素都>p2，每次比较的时候，我们都把较小的数字复制到新的数组中去

• 代码参考

class Solution {
public:
    //采用归并排序的方法
    long long num=0;
    void Merge(vector<int>& data,vector<int>& temp,int startIdx,int midIdx,int endIdx)
    {
        int i=startIdx,j=midIdx+1,k=startIdx;
        while(i<=midIdx&&j<=endIdx)
        {
            if(data[i]<data[j])
            {
                temp[k++]=data[i++];
            }
            else
            {
                temp[k++]=data[j++];
                num+=midIdx-i+1;
            }
        }
        while(i<=midIdx)
        {
            temp[k++]=data[i++];
        }
        while(j<=endIdx)
        {
            temp[k++]=data[j++];
        }
        while(startIdx<=endIdx)
        {
            data[startIdx]=temp[startIdx];
            ++startIdx;
        }
    }
    
    void MergeSort(vector<int>& data,vector<int>& temp,int startIdx,int endIdx)
    {
        int midIdx;
        if(startIdx<endIdx)
        {
            midIdx=(startIdx+endIdx)/2;
            MergeSort(data, temp, startIdx, midIdx);
            MergeSort(data, temp, midIdx+1, endIdx);
            Merge(data,temp,startIdx,midIdx,endIdx);
        }
    }
    int InversePairs(vector<int> data) {
        if(data.empty())
            return 0;
        vector<int> temp=data;
        int startIdx=0;
        int endIdx=data.size()-1;
        MergeSort(data, temp, startIdx, endIdx);
        return num%1000000007;
    }
};

 

8.3(1) 合并两个有序链表

• 题目描述

　　

 

•  问题分析

　　方法一：递归操作

　　如果链表1为空，则排序之后的链表就是链表2；

　　如果链表2为空，则排序之后的链表就是链表1；

　　如果链表1并且链表2都不为空，则采用递归操作

• 代码参考

　　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        //采用递归的方式
        ListNode head=null;
        //如果链表1为空，则直接返回链表2即可
        if(l1==null)
            return l2;
        //如果链表2为空，则最终结果就是链表1
        else if(l2==null)
            return l1;
        else
        {
            if(l1.val<l2.val)
            {
                head=l1;
                head.next=mergeTwoLists(l1.next,l2);
            }
            else
            {
                head=l2;
                head.next=mergeTwoLists(l1,l2.next);
            }
        }
        return head;
    }
}

 

 

8.3 归并排序链表

• 题目描述

　　

 

 

•  问题分析　　

　　通过递归实现链表的归并排序，主要分为割裂和合并两个环节

• • 割裂

　　　　　　找到当前链表的中点，并从中点中断裂开（以便在下次递归时，链表片段拥有正确的边界）

　　　　　　　　找到中点的方法为：双指针，一个快指针，一个慢指针，快指针每次走两步，慢指针每次走一步，快指针到达尾结点时，慢指针到达终点

　　　　　　　　找到中点后，执行slow->next=nullptr将链表切断

• • 合并

　　　　　　将两个链表合并。转换为一个排序链表

　　　　　　双指针法合并，建立哑节点dummy

　　　　　　设置两个指针left和right分别指向两个链表的头部，比较两指针处大小，由小大大加入链表

　　　　

• 代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //首先是割裂
    ListNode* Merge(ListNode* head1,ListNode* head2)
    {
        ListNode* dummy=new ListNode(-1);
        ListNode* tail=dummy;
        while(head1&&head2)
        {
            if(head1->val<head2->val)
            {
                tail->next=head1;
                tail=head1;
                head1=head1->next;
            }
            else
            {
                tail->next=head2;
                tail=head2;
                head2=head2->next;
            }
        }
        tail->next=head1!=nullptr?head1:head2;
        return dummy->next;
    }
    ListNode* sortList(ListNode* head) {
        if(head==nullptr||head->next==nullptr)
            return head;
        //首先需要找到中间节点
        ListNode* fast=head;
        ListNode* slow=head;
        ListNode* prev=new ListNode(-1);
        while(fast&&fast->next)
        {
            fast=fast->next->next;
            prev=slow;
            slow=slow->next;
        }
        if(prev->next!=nullptr)
            prev->next=nullptr;
        //然后开始合并，slow即为中间节点
        ListNode* left=sortList(head);
        ListNode* right=sortList(slow);
        return Merge(left,right);
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    //归并排序链表和归并排序数组一样，分为两步：割裂和合并
    /*
        首先是割裂
            ·找到当前链表的中点，从链表的中点裂开(以便在下次递归时，链表片段拥有正确的边界)
                找到中点的方法：双指针法，一个快指针一个慢指针，快指针每次走两步，慢指针每次走一步，当快指针到达链表尾部时，慢指针到达中点，slow.next=null将中点割裂
        然后是合并
            将两个链表合并，转换为一个排序链表，采用双指针法进行合并
    */
    //合并
    ListNode Merge(ListNode head1,ListNode head2)
    {
        ListNode dummy=new ListNode(-1);
        ListNode tail=dummy;
        while(head1!=null&&head2!=null)
        {
            if(head1.val<head2.val)
            {
                tail.next=head1;
                tail=head1;
                head1=head1.next;
            }
            else
            {
                tail.next=head2;
                tail=head2;
                head2=head2.next;
            }
        }
        tail.next=(head1!=null)?head1:head2;
        return dummy.next;
    }

    public ListNode sortList(ListNode head) {
        //首先将链表从中间割裂成两个链表
        if(head==null||head.next==null)
            return head;
        //首先找到中间节点
        //找到中间节点的方法：一个快指针一个慢指针，快指针每次走两步，慢指针每次走一步，快指针到尾结点时，慢指针到达终点
        ListNode fast=head;
        ListNode slow=head;
        ListNode prev=new ListNode(-1);
        while(fast!=null&&fast.next!=null)
        {
            prev=slow;
            slow=slow.next;
            fast=fast.next.next;
        }
        //此时slow到达终点部分
        if(prev.next!=null)
            prev.next=null;
        //此时head是第一个链表的头，slow是第二个链表的头
        //先分裂
        ListNode left=sortList(head);
        ListNode right=sortList(slow);
        return Merge(left,right);
    }
}

 

• JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    /*
        要实现链表归并排序，先割裂，再合并
        割裂
            找到链表的中点
                找到中点的方式：双指针法，快指针和慢指针，快指针每次走两步，慢指针每次走一步，当快指针到达尾结点时，慢指针到达中点位置
            将链表从中点断裂开
                从中点断裂开的方式：令中点.next=null
        合并
            将两个链表进行合并
            设置两个指针left和righr分别指向两个链表的头部，依次加入
    */
    //链表的合并即为两个有序链表的归并排序
    public ListNode merge(ListNode l1,ListNode l2)
    {
        ListNode phead=null;
        if(l1==null)
            return l2;
        else if(l2==null)
            return l1;
        else
        {
            if(l1.val<l2.val)
            {
                phead=l1;
                phead.next=merge(l1.next,l2);
            }
            else
            {
                phead=l2;
                phead.next=merge(l1,l2.next);
            }
        }
        return phead;
    }
    public ListNode sortList(ListNode head) {
        if(head==null||head.next==null)
            return head;
        //首先找到链表的中点
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null&&fast.next.next!=null)
        {
            slow=slow.next;
            fast=fast.next.next;
        }
        //此时slow位于中点位置，如果是偶数个链表，则slow位于前半部分链表的最后一个节点
        ListNode head2=slow.next;
        //割裂链表
        slow.next=null;
        //设置两个指针left和right,依次加入
        ListNode left=sortList(head);
        ListNode right=sortList(head2);
        return merge(left,right);
    }
}

 

 

9. 两数相加

9.1 两数相加1

• 题目描述

　　

 

•  问题分析

　　将两个链表看成是相同长度的进行遍历，如果一个链表短则在前面补0，如987+23=987+023=1010

　　每一位计算的同时需要考虑上一位的进位问题，而当前位计算结束后同样需要更新进位值

　　如果两个链表全部遍历完毕后，进位值为1，则在新链表最前方添加1

　　小技巧，对于链表问题，如果返回结果为头结点时，通常需要使用哑指针，哑指针的下一个极点指向真正的头结点head，使用哑指针的目的在于链表初始化时无可用节点值，而且链表的构造过程需要指针移动，进而会导致头结点丢失，无法返回结果。

图解：

      

• 代码参考

　　

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* dummy=new ListNode;
        ListNode* cur=dummy;
        ListNode* p=l1;
        ListNode* q=l2;
        int carry=0;
        while(p!=nullptr||q!=nullptr)
        {
            int x=((p!=nullptr)?p->val:0);
            int y=((q!=nullptr)?q->val:0);
            int sum=x+y+carry;
            carry=sum/10;
            cur->next=new ListNode(sum%10);
            cur=cur->next;
            if(p!=nullptr)
                p=p->next;
            if(q!=nullptr)
                q=q->next;
        }
        if(carry==1)
            cur->next=new ListNode(carry);
        return dummy->next;
    }
};

 

9.2 两数相加2

• 题目描述

　　

 

•  题目分析

　　这道题和上一道题地区别在于，上道题是逆序，这道题是正序，但是正序存在一个问题，如321+32=353，刚开始的第一位是从0开始的，补零是很复杂的，因此我们还是思考将其变成逆序来处理

• • 方法一：先翻转链表，然后再和逆序一样处理
  • 方法二：借助栈来对其进行处理，先将两个链表进入两个栈，此时就编程逆序的了，然后同逆序解决方法
• 代码参考
  • 方法一：代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head)
    {
        if(head==nullptr||head->next==nullptr)
            return head;
        ListNode* reverseHead=nullptr;
        ListNode* pNode=head;
        ListNode* prev=nullptr;
        while(pNode)
        {
            ListNode* next=pNode->next;
            if(pNode->next==nullptr)
                reverseHead=pNode;
            pNode->next=prev;
            prev=pNode;
            pNode=next;
        }
        return reverseHead;

    }
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* dummy=new ListNode(0);
        ListNode* cur=dummy;
        ListNode* p=reverseList(l1);
        ListNode* q=reverseList(l2);
        int carry=0;
        while(p!=nullptr||q!=nullptr)
        {
            int x=(p!=nullptr)?p->val:0;
            int y=(q!=nullptr)?q->val:0;
            int sum=x+y+carry;
            carry=sum/10;
            cur->next=new ListNode(sum%10);
            cur=cur->next;
            if(p!=nullptr)
                p=p->next;
            if(q!=nullptr)
                q=q->next;
        }
        if(carry==1)
            cur->next=new ListNode(carry);
        return reverseList(dummy->next);
    }
};

　　JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    //这道题和两数相加的差别在于：数的最高位位于链表开始位置，之前的最高位位于链表末尾，是逆置的
    //因此我们可以首先将链表逆置，逆置相加后再将相加后的链表逆置
    //将链表逆置
    public ListNode reverseList(ListNode head)
    {
        if(head==null||head.next==null)
            return head;
        ListNode prev=null;
        ListNode pNode=head;
        ListNode preverseHead=null;
        while(pNode!=null)
        {
            ListNode pNext=pNode.next;
            if(pNext==null)
                preverseHead=pNode;
            pNode.next=prev;
            prev=pNode;
            pNode=pNext;
        }
        return preverseHead;
    }
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //首先将l1和l2逆置
        ListNode p1=reverseList(l1);
        ListNode q1=reverseList(l2);
        ListNode p=p1;
        ListNode q=q1;
        ListNode dummy=new ListNode(-1);
        ListNode cur=dummy;
        int carry=0;
        while(p!=null||q!=null)
        {
            int x=(p==null)?0:p.val;
            int y=(q==null)?0:q.val;
            int sum=x+y+carry;
            carry=sum/10;
            cur.next=new ListNode(sum%10);
            cur=cur.next;
            if(p!=null) 
                p=p.next;
            if(q!=null)
                q=q.next;
        }
        if(carry==1)
            cur.next=new ListNode(carry);
        ListNode phead=dummy.next;
        return reverseList(phead);
    }
}

 

 

• • 方法二：借助栈C++代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        stack<int> s1;
        stack<int> s2;
        while(l1!=nullptr)
        {
            s1.push(l1->val);
            l1=l1->next;
        }
        while(l2!=nullptr)
        {
            s2.push(l2->val);
            l2=l2->next;
        }
        int carry=0;
        ListNode* head=nullptr;
        //使用头插法
        while(!s1.empty()||!s2.empty()||carry>0)
        {
            int x=(s1.empty()?0:s1.top());
            int y=(s2.empty()?0:s2.top());
            int sum=x+y+carry;
            carry=sum/10;
            //使用尾插法
            ListNode* cur=new ListNode(sum%10);
            cur->next=head;
            head=cur;
            if(!s1.empty())
                s1.pop();
            if(!s2.empty())
                s2.pop();
        }
        
        return head;
    }
};

• •  方法二：JAVA代码参考

　　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //第二种方式，输入链表不能修改，可以借助栈来实现
        Stack<Integer> s1=new Stack<Integer>();
        Stack<Integer> s2=new Stack<Integer>();
        //首先将链表1入第一个栈
        while(l1!=null)
        {
            s1.push(l1.val);
            l1=l1.next;
        }
        //然后将链表2入第二个栈
        while(l2!=null)
        {
            s2.push(l2.val);
            l2=l2.next;
        }
        int carry=0;
        ListNode head=null;
        while(!s1.isEmpty()||!s2.isEmpty())
        {
            int x=s1.isEmpty()?0:s1.peek();
            int y=s2.isEmpty()?0:s2.peek();
            int sum=x+y+carry;
            carry=sum/10;
            ListNode cur=new ListNode(sum%10);
            cur.next=head;
            head=cur;
            cur=cur.next;
            if(!s1.empty())
                s1.pop();
            if(!s2.empty())
                s2.pop();
        }
        if(carry==1)
        {
            ListNode cur=new ListNode(carry);
            cur.next=head;
            head=cur;
        }
        return head;
    }
}

 

 

10. 两个链表的第一个公共节点

• 题目描述

　　

 

•  问题分析

　　由于是单向链表的节点，每个节点只有一个next指针，因此从第一个公共节点开始，之后他们所有的节点都是重合的。

　　为了找到两个链表的公共节点，我们采用如下方法

　　　　首先遍历两个链表得到他们的长度，就能知道哪个链表比较长，以及长的链表比短的链表多几个节点。

　　　　然后让唱的链表先走链表长度差这么多步，接着同时在两个链表上遍历，找到的第一个相同节点就是他们的第一个公共节点

• 代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int lenofList(ListNode* head)
    {
        int len=0;
        while(head)
        {
            ++len;
            head=head->next;
        }
        return len;
    }
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* plong=headA;
        ListNode* pshort=headB;
        int len1=lenofList(plong);
        int len2=lenofList(pshort);
        int distance=len1-len2;
        if(distance<0)
        {
            plong=headB;
            pshort=headA;
            distance=len2-len1;
        }
        for(int i=0;i<distance;++i)
        {
            plong=plong->next;
        }
        while(plong&&pshort)
        {
            if(pshort==plong)
                return pshort;
            plong=plong->next;
            pshort=pshort->next;
        }
        return nullptr;
    }
};

•  JAVA代码参考

　　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public int lenoflist(ListNode head)
    {
        int len=0;
        while(head!=null)
        {
            ++len;
            head=head.next;
        }
        return len;
    }
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        /*
            1. 若链表长度相等，直接逐一判断即可
            2. 若链表长度不同，则先让长链表走两个链表长度的差值，然后逐一对比即可
        */
        //首先分别求链表的长度
       
        ListNode longList=headA;
        ListNode shortList=headB;
         int len1=lenoflist(longList);
        int len2=lenoflist(shortList);
        //求出两个链表的差值
        int distance=len1-len2;
        if(len1<len2)
        {
            
            longList=headB;
            shortList=headA;
            distance=len2-len1;
        }
        //让长链表先走distance步
        for(int i=0;i<distance;++i)
        {
            longList=longList.next;
        }
        while(longList!=null&&shortList!=null)
        {
            //注意应该是比较链表相等，而不应该是比较值相等
            if(longList==shortList)
                return longList;
            longList=longList.next;
            shortList=shortList.next;
        }
        return null;
    }
}

 

 

12. 分割链表

• 题目描述

　　

 

•  问题分析

　　使用双指针法，使用两个指针before和after来追踪上述链表，两个指针分别用于创建两个链表，然后将这两个链表连接即可获得新的链表。

　　1. 首先初始化两个指针before和after，在实现中，由于可能涉及到头指针，我们在before链表和after链表中使用两个哑指针

　　

　　

• 代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //使用两个链表，before,after来存储，一个链表存储大于x的，一个链表存储小于x的
    /*
    before链表和after链表中使用两个哑指针
    大于x的存放在after,小于x的存放在before
    */
    ListNode* partition(ListNode* head, int x) {
        if(head==nullptr)
            return nullptr;
        ListNode* dummy_before=new ListNode(0);
        ListNode* before=dummy_before;
        ListNode* dummy_after=new ListNode(0);
        ListNode* after=dummy_after;
        while(head!=nullptr)
        {
            if(head->val<x)
            {
                before->next=head;
                before=before->next;
            }
            else
            {
                after->next=head;
                after=after->next;
            }
            head=head->next;
        }
        after->next=nullptr;
        before->next=dummy_after->next;
        return dummy_before->next;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {
        //要实现小于x的节点都在大于或等于x的节点之前，我们可以采用如下方式
        /*
            创建两个链表，before和after，遍历整个链表，小于x的连接在before后面，大于x的连接在after后面
        */
        if(head==null)
            return null;
        ListNode dummy_before=new ListNode(0);
        ListNode before=dummy_before;
        ListNode dummy_after=new ListNode(0);
        ListNode after=dummy_after;
        //遍历原始链表，比x大的节点连接到after后，比x小的节点连接到before后
        while(head!=null)
        {
            if(head.val<x)
            {
                before.next=new ListNode(head.val);
                before=before.next;
            }
            else
            {
                after.next=new ListNode(head.val);
                after=after.next;
            }
            head=head.next;
        }
        before.next=dummy_after.next;
        return dummy_before.next;
    }
}

 

12.1 分隔链表

• 题目描述

       

 

•  题目分析

　　由于只需要将链表分隔成k段，每部分的长度尽可能相等，任意两部分的长度差距不超过1，算法如下

　　1. 首先求得链表的长度

　　2. 链表数组中每个元素中，链表最少有len/k个元素，如果len%k有余数，则有len%k个元素中链表长度要多1

　　3. 对于0-len%k-1索引上的元素，其链表长度为len/k+1

　　　对于len%k-k-1索引上的元素，其链表长度为len/k

• C++代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //求得链表的长度
    int lenoflist(ListNode* head)
    {
        int len=0;
        while(head)
        {
            ++len;
            head=head->next;
        }
        return len;
    }
    vector<ListNode*> splitListToParts(ListNode* root, int k) {
        vector<ListNode*> arr;
        //首先求得链表的长度
        int len=lenoflist(root);
        //然后求得每个链表元素中链表最少长度
        int minSize=len/k;
        //然后求有几个链表元素长度要多1
        int moreEleNumber=len%k;
        //由于长度更多的元素应该在前面，因此首先将多一个的元素入数组
        ListNode* head=root;
        //首先是前面更多元素的数据入数组
        for(int i=0;i<moreEleNumber;++i)
        {
            ListNode* dummy=new ListNode(-1);
            ListNode* cur=dummy;
            for(int j=0;j<minSize+1;++j)
            {
                cur->next=new ListNode(head->val);
                cur=cur->next;
                if(head!=nullptr)
                    head=head->next;
            }
            arr.push_back(dummy->next);
        }
        //然后是后面少一个元素的数据入数组
        for(int i=moreEleNumber;i<k;++i)
        {
            ListNode* dummy=new ListNode(-1);
            ListNode* cur=dummy;
            for(int j=0;j<minSize;++j)
            {
                cur->next=new ListNode(head->val);
                cur=cur->next;
                if(head!=nullptr)
                    head=head->next;
            }
            arr.push_back(dummy->next);
        }
        return arr;
    }
};

• JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    //求出链表的长度
    public int lenoflist(ListNode head)
    {
        int len=0;
        while(head!=null)
        {
            ++len;
            head=head.next;
        }
        return len;
    }
    public ListNode[] splitListToParts(ListNode root, int k) {
        //首先求出链表的长度
        int len=lenoflist(root);
        //求出每个链表的最少长度
        int minSize=len/k;
        //由于多余的数组就放在前面，因此用moreSizeNumber来表示有几个数组是要多一个元素的
        int moreSizeNumber=len%k;
        ListNode head=root;
        ListNode [] array=new ListNode[k];
        
        for(int i=0;i<moreSizeNumber;++i)
        { 
            ListNode dummy=new ListNode(-1);
            ListNode phead=dummy;
            for(int j=0;j<minSize+1;++j)
            {
                phead.next=new ListNode(head.val);
                phead=phead.next;
                if(head!=null)
                    head=head.next;
            }
            array[i]=dummy.next;
        }
        for(int i=moreSizeNumber;i<k;++i)
        {
            ListNode dummy=new ListNode(-1);
            ListNode phead=dummy;
            for(int j=0;j<minSize;++j)
            {
                phead.next=new ListNode(head.val);
                phead=phead.next;
                if(head!=null)
                    head=head.next;
            }
            array[i]=dummy.next;
        }
        return array;
    }
}

 

 

13. 环形链表

13.1 判断链表是否有环

• 题目描述

　　

 

 

•  问题分析

　　要判断链表是否有环，我们可以采用双指针法：快指针和慢指针，快指针每次走两步，慢指针每次走一步，如果两指针相遇，则链表是有环的，否则是没有环的。

•  代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        //int pos=0;
        if(head==NULL||head->next==NULL||head->next->next==NULL)
            return false;
        ListNode *fast=head->next->next;
        ListNode *slow=head->next;
        while(slow!=fast)
        {
            if(fast->next!=NULL&&fast->next->next!=NULL)
            {
                fast=fast->next->next;
                slow=slow->next;
            }
            else
                return false;
        }
        return true;
        
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        //要判断链表是否有环，可以使用快指针和慢指针，快指针每次走两步，慢指针每次走一步，如果链表是没有环的，则快指针会首先走空指针处，如果链表是没有环的，则快指针和慢指针必然会相遇，相遇点在环的入口节点处。
        if(head==null||head.next==null||head.next.next==null)
            return false;
        ListNode fast=head.next.next;
        ListNode slow=head.next;
        while(fast!=null&&fast.next!=null&&fast.next.next!=null)
        {
            if(slow==fast)
                return true;
            slow=slow.next;
            fast=fast.next.next;
        }
        return false;
    }
}

 

 

13.2 找出链表中环的入口节点　　

• 题目描述

　　

 

•  问题分析

　　要找到链表中环的入口节点，只需要三步

　　　　第一步：判断链表是否有环，判断方法：两个指针：快指针和慢指针，快指针每次走两步，慢指针每次走一步，如果快慢指针相遇，则链表有环

　　　　第二步：求出链表中环的长度

　　　　第三步：两个指针指向头结点，一个指针先走环的长度这么多步，然后两个指针同时移动，相遇点即为环的入节点

• 代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //判断环的入口节点，主要分为三步
        //首先判断链表是否有环
        if(head==nullptr||head->next==nullptr||head->next==nullptr)
            return nullptr;
        //判断是否有环的方法：快慢指针，快指针每次走两步，慢指针每次走一步，如果相遇，则其是有环的
        ListNode* slow=head->next;
        ListNode* fast=head->next->next;
        while(fast!=slow)
        {
            if(fast&&fast->next&&fast->next->next)
            {
                slow=slow->next;
                fast=fast->next->next;
            }
            else
                return nullptr;
        }
        //第二步：计算环的长度
        int len=1;
        slow=slow->next;
        while(slow!=fast)
        {
            ++len;
            slow=slow->next;
        }
        //第三步：令一个指针先走环的长度这么多步，然后同时移动快慢指针，相遇点即为入口节点
        slow=head;
        fast=head;
        for(int i=0;i<len;++i)
        {
            slow=slow->next;
        }
        while(slow!=fast)
        {
            slow=slow->next;
            fast=fast->next;
        }
        return slow;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null||head.next==null||head.next.next==null)
            return null;
        //分为三步：
        //首先判断链表是否有环，判断方法：快指针和慢指针，快指针每次走两步，慢指针每次走一步，若有环，则快指针和慢指针必将相遇
        ListNode slow=head.next;
        ListNode fast=head.next.next;
        while(fast!=slow)
        {
            if(fast!=null&&fast.next!=null&&fast.next.next!=null)
            {
                fast=fast.next.next;
                slow=slow.next;
            }
            else
                return null;
        }
        //如果走到此步，则证明链表必定是有环的，因此我们需要求出环的长度。用len来确定环的长度
        int len=1;
        slow=slow.next;
        while(slow!=fast)
        {
            ++len;
            slow=slow.next;
        }
        //第三步，求出环的长度之后，两个指针都指向头结点，一个指针先走环的长度步，然后两个指针同时往前走，相遇点即为入口节点
        slow=head;
        fast=head;
        for(int i=0;i<len;++i)
        {
            slow=slow.next;
        }
        while(slow!=fast)
        {
            slow=slow.next;
            fast=fast.next;
        }
        return fast;

    }
}

 

 

 

14. 链表中倒数第k个结点

　　14.1 链表中倒数第k个结点

• 题目描述

　　　

 

•  问题分析

　　要找到倒数第k个结点，我们可以采用双指针法，两个指针刚开始都指向链表头结点，一个指针p先走K步，此时指针p,q之间的间距为k，当指针p到达链表尾时，指针q刚好达到倒数第k个结点

• 代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        if(head==nullptr||k<0)
            return nullptr;
        ListNode* p=head;
        ListNode* q=head;
        int i=0;
        while(p!=nullptr)
        {
            if(i<k)
            {
                ++i;
                p=p->next;
            }
            else
            {
                p=p->next;
                q=q->next;
            }
        }
        return i<k?nullptr:q;
    }
};

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        //要找到倒数第k个结点，可以采用双指针方法
        //两个指针，刚开始都指向头结点，一个指针先走k步，因此两个指针之间相隔k步
        //当快指针到达链表末尾的时候，慢节点刚好到达链表倒数第k个结点
        if(head==null||k<0)
            return null;
        ListNode slow=head;
        ListNode fast=head;
        for(int i=0;i<k;++i)
            fast=fast.next;
        while(fast!=null)
        {
            slow=slow.next;
            fast=fast.next;
        }
        return slow;
    }
}

 

　　14.2 删除链表中倒数第k个结点

• 题目描述

　　

 

•  问题分析

　　这道题类似倒数第k个结点，但是设计删除就要找到倒数第k个结点的前驱节点，由于可能涉及到头结点的操作，引入一个哑节点。

• 代码参考

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head==nullptr||n<0)
            return nullptr;
        ListNode* dummy=new ListNode(-1);
        dummy->next=head;
        ListNode* p=dummy;
        ListNode* q=dummy;
        int i=0;
        while(p!=nullptr)
        {
            if(i<n+1)
            {
                p=p->next;
                ++i;
            }
            else
            {
                p=p->next;
                q=q->next;
            }
        }
        q->next=q->next->next;
        return dummy->next;
    }
};

•  第二种问题分析方式

　　由于第一道题我们已经知道怎么找到链表的倒数第k个链表，这道题只是需要将其前一个链表删除而已，因此需要找到需要删除的链表的前一个节点，因此引入哑节点：

　　使用双指针方法：刚开始两个指针slow, fast都指向头结点，一个链表fast先向前走k步，此时链表fast和链表slow距离为k步，因此当链表fast到达尾结点时，链表slow到达倒数第k个结点，引入哑节点指向head的前驱节点，同时prev指向哑节点，当fast到达尾结点时，prev到达slow的前驱节点，此时实现删除即可

        

 

•  JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //这道题是之前链表的升级，需要将倒数第k个结点删除，因此需要找到第k个结点的前驱结点
        if(head==null||n<0)
            return null;
        ListNode dummy=new ListNode(-1);
        dummy.next=head;
        ListNode prev=dummy;
        ListNode fast=head;
        ListNode slow=head;
        for(int i=0;i<n;++i)
            fast=fast.next;
        while(fast!=null)
        {
            fast=fast.next;
            slow=slow.next;
            prev=prev.next;
        }
        prev.next=prev.next.next;
        return dummy.next;
    }
}

 

15. 涉及两个链表的操作

15.1 重排链表

• 题目描述

　　

 

 

•  问题分析

　　注意到目标链表及为将原链表的左半端和反转后的右半端合并后的结果，因此我们的任务可以分为三步

1. 找到原始链表的中点

　　　　实现方式：快慢指针，快指针每次走两步，慢指针每次走一步，快指针到达尾结点时，慢指针到达中点

1. 将原链表的右半端翻转
2. 将原链表的两端进行合并　　

• 代码参考

　　　　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    //首先实现链表的翻转
    public ListNode reverseList(ListNode head)
    {
        ListNode prev=null;
        ListNode pNode=head;
        ListNode preverseHead=null;
        while(pNode!=null)
        {
            ListNode pNext=pNode.next;
            pNode.next=prev;
            prev=pNode;
            pNode=pNext;
        }
        return prev;
    }
    //找到原始链表的中点
    public ListNode midNode(ListNode head)
    {
        //一个快指针一个慢指针，快指针每次走两步，慢指针每次走一步，快指针到达终点时，慢指针达到中点
        ListNode fast=head;
        ListNode slow=head;
        while(fast.next!=null&&fast.next.next!=null)
        {
            fast=fast.next.next;
            slow=slow.next;
        }
        return slow;
    }
    public void mergeList(ListNode l1,ListNode l2)
    {
        ListNode l1_temp;
        ListNode l2_temp;
        while(l1!=null&&l2!=null)
        {
            l1_temp=l1.next;
            l2_temp=l2.next;

            l1.next=l2;
            l1=l1_temp;

            l2.next=l1;
            l2=l2_temp;
        }
    }
    public void reorderList(ListNode head) {
        if(head==null)
            return;
        //首先找到原始链表的中点
        ListNode mid=midNode(head);
        ListNode l1=head;
        ListNode l2=mid.next;
        mid.next=null;
        l2=reverseList(l2);
        mergeList(l1,l2); 
    }
}

 

　16. 二进制链表转换为整数

• 题目描述

　　

 

•  问题分析

　　由于链表冲击感高位到低位存放了数字的二进制表示，因此我们可以使用二进制转十进制的方法，在遍历一遍链表的同时得到数字的十进制值

• 代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int getDecimalValue(ListNode head) {
        if(head==null)
            return 0;
        int sum=0;
        ListNode phead=head;
        while(phead!=null)
        {
            sum=sum*2+phead.val;
            phead=phead.next;
        }
        return sum;
    }
}

 

17. 链表中下一个更大节点

• 题目描述

　　

 

•  问题分析

　　这道题可以采用单调栈来实现，从头到尾遍历整个链表

• • 若栈为空，则将元素直接入栈
  • 若栈不为空且待插入元素>栈顶元素，则将栈顶元素出栈，直到栈顶元素>待插入元素，且出栈元素下标值所对应的位置为待插入元素的大小
  • 若栈不为空且待插入元素<栈顶元素，则将待插入元素入栈

　　由于其可能涉及到下标值的计算，因此直接将下标值入栈即可

• JAVA代码参考

　　　　　　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int lenoflist(ListNode head)
    {
        int len=0;
        while(head!=null)
        {
            ++len;
            head=head.next;
        }
        return len;
    }
    public int[] nextLargerNodes(ListNode head) {
        //使用最小栈来实现
        int len=lenoflist(head);
        int[] nextMaxNumber=new int[len];
        //首先从头到尾遍历整个链表
        /*
            若当前栈为空，则直接将元素入栈
            若待插入元素>栈顶元素，则将栈顶元素出栈，知道待插入元素<栈顶元素，将待插入元素入栈
            若待插入元素<栈顶元素，则将待插入元素入栈

            由于涉及到后续赋值问题，因此入栈的是当前元素的下标值
        */
        //由于要将当前元素的下标值入栈，因此将链表转换为数组
        int [] index=new int[len];
        int i=0;
        //首先将当前链表转换为数组
        while(head!=null)
        {
            index[i]=head.val;
            head=head.next;
            ++i;
        }
        //创建一个栈
        Stack<Integer> s=new Stack<>();
        for(i=0;i<len;++i)
        {
            //当栈不为空且待插入元素大于栈顶元素，则将栈顶元素弹出
            while(!s.empty()&&index[i]>index[s.peek()])
            {
                nextMaxNumber[s.peek()]=index[i];
                s.pop();
            }
            s.push(i);
        }
        return nextMaxNumber;
    }
}

 

18. 二叉树中的列表

• 题目描述

　　

 

•  问题分析

　　枚举二叉树中的每个节点为起点往下的路径是否有与链表相匹配的路径。为了判断是否匹配，我们设计一个递归函数dfs(rt, head)，其中rt表示当前匹配到的二叉树节点，head表示当前匹配到的链表节点，整个函数返回 布尔值表示是否有一条该结点往下的路径与head节点开始的链表匹配，如匹配返回true,否则返回false，一共有四种情况

1. 链表已经全部匹配完(链表为空)，返回true
2. 二叉树访问到了空节点，返回false
3. 当前二叉树节点值和链表结点值不相同，返回false
4. 如果以上三种情况不满足，说明部分匹配，需要继续调用递归匹配。所以先调用函数dfs(rt.left, head.next)，如果返回的结果是fasle，说明没有找到相匹配的路径，继续在右子树中寻找匹配，调用函数dfs(rt.right, head.next)

• JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    /*
        为了判断是否匹配设计一个递归函数dfs(rt,head)，rt表示当前匹配到的二叉树节点，head表示当前匹配到的链表节点，整个函数返回布尔值表示是否有一条该结点往下的路径与head节点开始的链表匹配，如果匹配返回true，否则返回fasle
        有如下四种情况
        1. 链表已经全部匹配完，返回true
        2. 二叉树访问到了空节点，匹配失败，返回false
        3. 当前匹配的二叉树上节点的值与链表节点的值不相等，返回false
        4. 前三种情况都不满足，证明匹配成功一部分，继续递归匹配，dfs(rt.left,head.next)，如果返回结果为fasle，说明没有匹配成功，继续再右子树中匹配dfs(rt.right,head.next)
    */
    public boolean dfs(TreeNode rt,ListNode head)
    {
        //1. 链表已经全部匹配完，此时链表为空，返回true
        if(head==null)
            return true;
        //2. 二叉树访问到了空节点，匹配失败，返回fasle
        if(rt==null)
            return false;
        //3. 当前二叉树的值和链表的值不相等
        if(rt.val!=head.val)
            return false;
        return dfs(rt.left,head.next)||dfs(rt.right,head.next);
    }
    public boolean isSubPath(ListNode head, TreeNode root) {
        if(root==null)
            return false;
        return dfs(root,head)||isSubPath(head,root.left)||isSubPath(head,root.right);
    }
}

 

 

19. 对链表进行插入排序

• 题目描述

　　

 

•  问题分析

　　从前往后找插入点

　　插入排序的基本思想是：维护一个有序序列，初始时有序序列只有一个元素，每次将一个新的元素插入到有序序列中，将有序序列的长度加1，直到全部元素都加入到有序序列中。

　　如果是数组的插入排序，则数组的前面部分是有序序列，每次找到有序序列后面的第一个元素(待插入元素)的插入位置，将有序序列中的插入位置后面的元素都往后移动一位，然后将待插入元素插入插入位置　　

　　对于链表而言，插入元素时只要更新相邻节点的指针即可，不需要像数组一样将插入位置后面的元素往后移动

　　对于单链表进行插入排序的具体过程如下：

1. 由于可能涉及到链表头结点的下一个结点，因此首先判断链表是否为空或者其是否为单结点链表
2. 由于可能涉及到将后面的元素插入到头结点之前，因此需要创建一个哑指针dummy
3. 维护一个链表已排序部分的最后一个节点LastSortedNode，初始时LastSortedNode指向头结点
4. 维护cur为待插入的元素，初始时cur=head.next
5. 比较LastSortedNode.val和cur.val
   1. 如果LastSortedNode.val<cur.val，则直接将LastSortedNode后移一个位置，cur变成新的LastSortedNode
   2. 否则，从链表的头结点开始往后遍历链表中的节点，寻找插入cur的位置，令prev为插入cur的前一个节点，进行如下操作，完成对cur的插入

　　　　　　LastSortedNode.next = cur.next
　　　　　　cur.next = prev.next
　　　　　　prev.next = cur

　　6. 令cur=LastSortedNode,此时cur为下一个待插入的元素

　　7. 重复5-6，直到cur为空，排序结束

• JAVA代码参考

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode insertionSortList(ListNode head) {
        //由于可能涉及到head.next的操作，因此首先进行空指针判断
        if(head==null||head.next==null)
            return head;
        //由于可能涉及到头指针的操作，因此创建一个哑指针
        ListNode dummy=new ListNode(-1);
        dummy.next=head;
        //创建一个链表指针，其指向排序后链表的最后一个节点，初始时，其是在head处
        ListNode LastSortedNode=head;
        //创建一个链表指针指向最后一个排序节点的下一个结点
        ListNode cur=head.next;
        while(cur!=null)
        {
            ListNode prev=dummy;
            //如果当前cur.val>lastsortedNode.val，则lastsortedNode往后移动
            if(LastSortedNode.val<=cur.val)
            {
                LastSortedNode=LastSortedNode.next;
            }
            else
            {
                //否则，需要进行插入排序
                while(prev.next.val<=cur.val)
                    prev=prev.next;
                LastSortedNode.next=cur.next;
                cur.next=prev.next;
                prev.next=cur;
            }
            cur=LastSortedNode.next;
        }
        return dummy.next;
    }   
}

 

isEmpty