20200728

725.分隔链表

（1）向上取整

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
struct ListNode** splitListToParts(struct ListNode* root, int k, int* returnSize){
    // if(root==NULL) return root;   //不能要这个，如果是个空链表，不能返回一个空链表
    // 计算链表的长度
    double length=0;  // 必须要double才能正确，为什么呢？
    struct ListNode *p=root;
    while(p){
        p=p->next;
        length++;
    }
    // 定义返回值
    struct ListNode** output = (struct ListNode**)malloc(sizeof(struct ListNode) * k);
    *returnSize = k;

    struct ListNode* q=root,*tmp=NULL;
    int i=0;
    for(i=0;k>0;i++,k--){
        output[i]=root;
        q=root;
        // 每部分的大小
        double size=ceil(length/k);
        length-=size;
        while(--size && q){
            q=q->next;
        }   
        tmp=NULL;   
        if(q){
            tmp=q->next;
            q->next=NULL;
        }
        root=tmp;
    }

    return output;
}

（2）先分成k份，向下取整，再把余下的均分到前面的几组，每组多一个

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
struct ListNode** splitListToParts(struct ListNode* root, int k, int* returnSize){
    // if(root==NULL) return root;   //不能要这个，如果是个空链表，不能返回一个空链表
    // 计算链表的长度
    int length=0;  // 必须要double才能正确，为什么呢？
    struct ListNode *p=root;
    while(p){
        p=p->next;
        length++;
    }
    // 定义返回值
    struct ListNode** output = (struct ListNode**)malloc(sizeof(struct ListNode) * k);
    *returnSize = k;

    struct ListNode* q=root,*tmp=NULL;
    int i=0;
    int avgsize=length/k; //先均分到每一组
    int rest=length%k; //剩下的均分到前面几组
    for(i=0;i<k;i++){
        output[i]=q;
        // 每部分的大小
        int size=(rest-->0?1:0)+avgsize;//一定要有>0的判断
        for(int j=0; j<size-1; j++) q=q->next;
        tmp=NULL;
        if(q){
            tmp=q->next;
            q->next=NULL;
        }
        q=tmp;

    }
    return output;
}

61.旋转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* rotateRight(struct ListNode* head, int k){
    if(head==NULL) return head;
    int length=0;
    
    struct ListNode* dummy=(struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->next=head;
    struct ListNode* p=head,*q=dummy;
    // 计算链表的长度
    while(p){
        p=p->next;
        length++;
    }
    k=k%length;
    if(k==0) return head;
    //两个指针，找到倒数第k个节点和最后一个节点
    p=dummy;
    while(k--){
        q=q->next;
    }
    while(q->next){
        q=q->next;//找到最后一个节点
        p=p->next;//找到倒数第k个节点的前一个节点
    }

    struct ListNode* newhead=p->next;
    q->next=head;
    p->next=NULL;

    return newhead;
    
}

817.链表组件

（1）双层循环

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


int numComponents(struct ListNode* head, int* G, int GSize){
    // 找没有在G中的元素
    if(head==NULL || GSize==0) return 0;
    int num=0;
    int flag[10001]={0};
    for(int i=0;head!=NULL;i++){
        for(int j=0;j<GSize;j++){
            if(head->val==G[j]){
                flag[i]=1;
                if(i==0){
                    num++;
                }
                else if(flag[i]==1 && flag[i-1]==0){
                    num++;
                }
                
                break;
            }
        }
        head=head->next;
    }
    return num;
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


int numComponents(struct ListNode* head, int* G, int GSize){
    // 标记数组法
    if(head==NULL || GSize==0) return 0;
    int num=0;
    int flag[10001]={0};
    for(int i=0;i<GSize;i++) flag[G[i]]=1;
    while(head){
        if(flag[head->val]){
            num++;
            while(head && flag[head->val]){
                head=head->next;
            }
        }
        if(head) head=head->next;
    }
    return num;
}