数据结构-链表

链表

• 链表和数组均属于线性数据结构
• STL
  
  • List（双端链表）
  • forward_list（单链表）
  • vector（动态数组）

/**struct ListNode{    int val;    ListNode *next;    ListNode(int x):val(x),next=NULL{}}; **/

基本操作

删除结点

删除除去尾结点以外的指定结点

void DeleteNode(ListNode* node){    node->val=node->next->val;    node->next=node->next->next;}

删除具有相同元素的结点，返回删除后的链表

ListNode *deleteNodes(ListNode *head, int val){    ListNode *newh=new ListNode(0);    newh->next=head;    ListNode *newL=newh;    while(newh && newh->next){        if(newh->next->val==x)        newh=newh->next->next;        else newh=newh->next;    }    return newL->next;}

删除链表中的倒数第N个结点

ListNode *removeNthNode(ListNode *head, int N){    ListNode *fast=head;    ListNode *slow=head;    while(N--)        fast=fast->next;    //删除结点为头结点情况    if (fast==NULL) return head->next;    while(fast->next){        slow=slow->next;        fast=fast->next;    }    slow->next=slow->next->next;    return head;}

删除排序链表的重复元素I

ListNode *removeDuplicate(ListNode *head){    ListNode *cur=head;    ListNode *tail=head;    while(tail){        if(cur->val!=tail->val){            cur->next=tail;            cur=cur->next;            tail=cur;        }        else{            tail=tail->next;            cur->next=NULL;        }    }    return head;}

删除排序链表中的重复元素II

ListNode *removeDuplicateII(ListNode *head){    ListNode *new_head=NULL;    ListNode *tail=NULL,pre=NULL,*curr=head;    while(curr){        ListNode *next=curr->next;        if((!pre || pre->val!=curr->val) &&           (!next|| next->val!=cur->val){             if(!new_head) new_head=tail=curr;             else {                tail->next=curr;                tail=curr;             }             tail->next=NULL;         }         pre=curr;         curr=next;    }    return new_head;}

翻转链表

翻转单链表-迭代

ListNode *reverseList(ListNode* head){        ListNode* node=new ListNode(0);        node->next=head;        ListNode *curr=head;        if(head!=NULL) {            ListNode* next=curr->next;            while(next){                curr->next=next->next;                next->next=node->next;                node->next=next;                next=curr->next;            }        }        return node->next;}

翻转链表-递归

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

翻转链表II

ListNode *reverseListII(ListNode *head, int m, int n){    int k=n-m;    ListNode *node=new ListNode(0);    node->next=head;    ListNode *pre=node;    while(--m) pre=pre->next;    ListNode *cur=pre->next;    ListNode *move=NULL;    while(k--){        move=cur->next;        cur->next=move->next;        move->next=pre->next;        pre->next=tmp;    }    return node->next;}

旋转链表

ListNode *rotatList(ListNode *head, int k){    int len=length(head);    if(len<=1 || k%len==0) return head;    k=len-k%len;    ListNode *fast=head;    while(--k) fast=fast->next;    ListNode *nhead=fast->next;    fast->next=NULL;    fast=nhead;    while(fast->next) fast=fast->next;    fast->next=head;    return nhead;}

链表排序

插入排序算法排序链表

ListNode *insertionSortList(ListNode *head){    if(!head || !head->next) return head;    ListNode *node=new ListNode(0);    node->next=head;    ListNode *pre=node;    ListNode *cur=head;    while(cur){        if(cur->next && cur->next->val <cur->val){            while(pre->next && pre->next->val<cur->next->val)             pre=pre->next;            ListNode *tmp=pre->next;            pre->next=cur->next;            cur->next=cur->next->next;            pre->next->next=tmp;            pre=node;        }        else cur=cur->next;    }    return node->next;} 

归并排序单链表

ListNode *sortList(ListNode *head){    int len=length(head);    if(len<=1) return head;    ListNode dummy(0);    dummy.next=head;    ListNode *left,*right,*tail,*cur;    for(int step=1;step<len;step<<=1){        tail=&dummy;        cur=dummy.next;        while(cur){            left=cur;            right=split(left,step);            cur=split(right,step);            tail=merge(left,right,tail);        }    }    return dummy.next;}int length(ListNode *head){    int len=0;    ListNode *p=head;    while(p){        len++;        p=p->next;    }    return len;}ListNode *split(ListNode *head,int step){    for(int i=1;head && i<step;i++)    head = head->next;    if(!head) return head;    ListNode *second=head->next;    head->next=NULL;    return second;}ListNode *merge(ListNode *left,ListNode *right,ListNode *tail){    ListNode *cur=tail;    while(left && right){        if(left->val < right->val){            cur->next=left;            left=left->next;        }else{            cur->next=right->next;            right=right->next;        }        cur=cur->next;    }    cur->next=left?left:right;    while(cur) cur=cur->next;    return cur;}

带环链表

带环链表I

bool hasCircle(ListNode *head){    ListNode *p1=head;    ListNode *p2=head;    while(p1 && p1->next){        p1=p1->next->next;        p2=p2->next;        if(p1==p2) return true;    }    return false;}

带环链表II

ListNode *detectCycle(ListNode *head){    ListNode *slow=head;    ListNode *fast=head;    ListNode *entry=NULL;    while(fast && fast->next){        fast=fast->next->next;        slow=slow->next;        if(slow==fast){            entry=head;            while(entry!=slow){                entry=entry->next;                slow=slow->next;            }            break;        }    }    return entry;}

单链表有关算法

两数之和

ListNode *TwoNum(ListNode *l1,ListNode *l2){        ListNode *l=new ListNode(0);        ListNode *head=l;        int carry =0, val=0;        while(l1 && l2){            val=(l1->val+l2->val+carry)%10;            carry=(l1->val+l2->val+carry)/10;            l->next=new ListNode(val);            l1=l1->next;            l2=l2->next;            l=l->next;        }        while(l1){            val=(l1->val+carry)%10;            carry=(l1->val+carry)/10;            l->next=new ListNode(val);            l1=l1->next;            l=l->next;        }        while(l2){            val=(l2->val+carry)%10;            carry=(l2->val+carry)/10;            l->next=new ListNode(val);            l2=l2->next;            l=l->next;        }        if(carry>0) l->next=new ListNode(carry);                return head->next;}

链表结点的操作

合并两个有序链表

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {        ListNode node(0),*p=&node;        while(l1 && l2){            if(l1->val >l2->val){                p->next=l2;                l2=l2->next;            }else{                p->next=l1;                l1=l1->next;            }            p=p->next;        }        if(l1)        p->next=l1;        else if(l2)        p->next=l2;        return node.next;    }

链表划分

    ListNode *partition(ListNode *head, int x) {        ListNode *p=head;        ListNode *h1=new ListNode(0);        ListNode *h2=new ListNode(0);        ListNode *p1=h1;        ListNode *p2=h2;        while(p){            if(p->val < x){                p1->next=p;                p1=p1->next;            }else{                p2->next=p;                p2=p2->next;            }            p=p->next;        }        p2->next=NULL;        p1->next=h2->next;        return h1->next;    }

回文链表

bool isPalindrome(ListNode *head){            if(!head || !head->next) return true;    ListNode *fast=head->next;    ListNode *slow=head;    while(fast && fast->next){        slow=slow->next;        fast=fast->next->next;    }    ListNode *last=slow->next;    while(last && last->next){        ListNode *tmp=last->next;        last->next=tmp->next;        tmp->next=slow->next;        slow->next=tmp;    }    last=slow->next;    slow->next=NULL;    ListNode *pre=head;    while(last && pre){        if(last->val!=pre->val) return false;        pre=pre->next;        last=last->next;    }    return true;}

两两交换链表中的结点

    ListNode* swapPairs(ListNode* head) {        if (head == NULL || head->next == NULL)            return head;        ListNode *dumb = new ListNode(0);        dumb->next = head;        ListNode *p1 = dumb;        ListNode *p2 = p1->next;        while (p2 != NULL && p2->next != NULL)        {            p1->next = p2->next;            p2->next = p2->next->next;            p1->next->next = p2;            p1 = p2;            p2 = p1->next;        }        return dumb->next;    }

Odd Even Linked List

ListNode* oddEvenList(ListNode* head) {    if(!head || !head->next) return head;    ListNode *cur=head->next;    ListNode *pre=head;    while(cur && cur->next){        ListNode *tmp=cur->next;        cur->next=tmp->next;        tmp->next=pre->next;        pre->next=tmp;        cur=cur->next;        pre=pre->next;    }    return head;}

两个单链表的交叉点

ListNode *intersection(ListNode *l1, ListNode *l2){    int len1=length(l1);    int len2=length(l2);    ListNode *p1=l1,*p2=l2;    int len=abs(len1-len2);    while(len1>len2){        len--;        p1=p1->next;     }    while(len1<len2){        len--;        p2=p2->next;    }    while(p1 && p2){        if(p1==p2) return l1;        p1=p1->next;        p2=p2->next;    }    return NULL;}

重排链表

    void reorderList(ListNode *head) {        // write your code here        if(!head || !head->next) return;        ListNode *p1=head;        ListNode *p2=head->next;        while(p2 && p2->next){            p1=p1->next;            p2=p2->next->next;        }        p2=reverseList(p1->next);        p1->next=NULL;        p1=head;        while(p1 && p2){            ListNode *temp1=p1->next;            ListNode *temp2=p2->next;            p1->next=p2;            p2->next=temp1;            p1=temp1;            p2=temp2;        }    }

复制带随机指针的链表

/** * Definition for singly-linked list with a random pointer. * struct RandomListNode { *     int label; *     RandomListNode *next, *random; *     RandomListNode(int x) : label(x), next(NULL), random(NULL) {} * }; */RandomListNode *copyRandomList(RandomListNode *head) {}

Reverse Nodes in k-group