算法-链表常用算法

常见算法：

1.链表逆序

2.链表求交点

3.链表求环

4.链表划分

5.复杂链表的复制

6-a.2个排序链表归并

6-b.k个排序链表归并

---

 链表定义：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

1.链表逆序

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *next=NULL;
        ListNode *new_head=NULL;
        while(head){
            next=head->next;
            head->next=new_head;
            new_head=head;
            head=next;
        }
        return new_head;
    }
};

new_head是新链表的头指针，next是为了记录下一个要反转的结点指针。

---

2.链表求交点

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        std::set<ListNode*> node_set;
        while(headA){
            node_set.insert(headA);
        }
        while(headB){
            if(node_set.find(headB)!=node_set.end()){
                return headB;
            }
        }
        return NULL;
    }
}

用stl 的set，时间复杂度nlogn，判定超时

int get_length(ListNode *head){
    int len=0;
    while(head){
        len++;
        head=head->next;
    }
    return len;
}
ListNode * get_same_node(int long_len,int short_len,ListNode *head){
    int delta=long_len-short_len;
    while(delta--){
        head=head->next;
    }
    return head;
}
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int len_A=get_length(headA);
        int len_B=get_length(headB);
        if(len_A>len_B){
            headA=get_same_node(len_A,len_B,headA);
        }else{
            headB=get_same_node(len_B,len_A,headB);
        }
        while(headA){
            if(headA==headB){
                return headA;
            }
            headA=headA->next;
            headB=headB->next;
            
        }
        return NULL;
    }
};

先求出两个链表长度，然后对齐指针。时间复杂度O（n）

---

 3.链表求环

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *fast=head;
        ListNode *slow=head;
        while(fast && fast->next){
            fast=fast->next->next;
            slow=slow->next;
            if(fast==slow) return true;
        }
        return false;
    }
};

快慢指针。

---

4.划分链表

class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode moreNode(0),lessNode(0);
        ListNode *more=&moreNode,*less=&lessNode;
        while(head){
            if(head->val < x){
                less->next=head;
                less=head; 
            }else{
                more->next=head;
                more=head;
            }
            head=head->next;
        }   
        less->next=moreNode.next;
        more->next=NULL;//注意尾指针清空！！！
        return lessNode.next;
    }
};

利用两个头节点挂上多于x和少于x的节点，最后修改指针，注意尾指针需要清空。

---

5.复杂链表的复制

class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if(head==NULL) return NULL;
        unordered_map<RandomListNode*,RandomListNode*> m;
        RandomListNode headNode(0);
        RandomListNode *cur=&headNode;
        RandomListNode *old_cur=head;
        while(old_cur){
            RandomListNode *temp=new RandomListNode(old_cur->label);
            cur->next=temp;
            m.insert({old_cur,temp});
            cur=cur->next;
            old_cur=old_cur->next;
        }
        cur->next=NULL;
        cur=headNode.next;
        old_cur=head;
        while(cur){
            cur->random=m[old_cur->random];
            cur=cur->next;
            old_cur=old_cur->next;
        }
        return headNode.next;
    }
};

old_cur为原链表的遍历指针，cur为新链表的遍历指针

---

 6-a.2个排序链表的归并

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode head(0);
        ListNode *p=&head;
        while(l1 && l2){
            if(l1->val <= l2->val){
                p->next=l1;
                l1=l1->next;
            }else{
                p->next=l2;
                l2=l2->next;
            }
            p=p->next;
        }
        if(l1==NULL) p->next=l2;
        if(l2==NULL) p->next=l1;
         return head.next;    
            
    }
       
};

 6-b.k个排序链表合并

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int len=lists.size();
        if(len==0) return NULL;
        if(len==1) return lists[0];
        if(len==2) return mergeTwoLists(lists[0],lists[1]);
        int mid=len/2;
        vector<ListNode *> sub_list1,sub_list2;
        for(int i;i<mid;i++){
            sub_list1.push_back(lists[i]);
        }
        for(int i=mid;i<len;i++){
            sub_list2.push_back(lists[i]);
        }
        ListNode *l1=mergeKLists(sub_list1);
        ListNode *l2=mergeKLists(sub_list2);
        return mergeTwoLists(l1,l2);
        
    }
};

mergeTwoLists函数是上面的。时间复杂度O(nklogk).

---

其他算法题型：

1.删除指定节点　

class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val=node->next->val;
        node->next=node->next->next;
    }
};

给定的是要删除的节点的指针，要删除该节点，由于无法获取前面节点的next，无法通过修改该next指向后面的节点。

这里将该节点的值用其后面节点的值替换，再删除后面的节点，达到等效的作用。

2.获取中间节点

　　描述：给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

class solution{
    public:
        ListNode *getMiddleNode(ListNode *head){
            ListNode *fast=head;
            ListNode *slow=head;
            while(fast != NULL && fast->next != NULL){
                fast=fast->next->next;
                slow=slow->next;
            }
            return slow;
        }
}

快慢指针法。

另一种是将节点指针输入到数组，再利用数组的随机访问特性。而随机访问正是链表的弱点。