leetcode 24、25

24 两两交换链表中的节点(swap-nodes-in-pairs)

比较简单，指针移动时要注意一些

/**
 * 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)
            return NULL;
        ListNode* ptr1=head;
        ListNode* ptr2=NULL;
        int flag = 0;
        while(ptr1)
        {
            if(!ptr1->next)
                break;
            if(!flag)
            {
                ptr2 = ptr1->next;
                head = ptr2;
                ptr1->next = ptr2->next;
                ptr2->next = ptr1;
                flag = 1;
            }
            else
            {
                ptr2->next = ptr1->next;
                ptr2 = ptr1->next;
                ptr1->next = ptr2->next;
                ptr2->next = ptr1;
            }
            ptr1 = ptr1->next;
            ptr2 = ptr2->next;
        }
        return head;
    }
};

25 k个一组翻转链表(reverse-nodes-in-k-group)

与24相似，不过更繁琐了一些

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode** ptr = new ListNode*[k];
        if(!head)
            return NULL;
        int flag = 0;
        while(1)
        {
            if(!flag)
            {
                ptr[0] = head;
                int i;
                for(i=1;i<k;i++)
                {
                    ptr[i] = ptr[i-1]->next;
                    if(!ptr[i])
                        break;
                }
                if(i!=k)
                    break;
                head = ptr[k-1];
                ptr[0]->next = ptr[k-1]->next;
                for(int i=k-1;i>0;i--)
                    ptr[i]->next = ptr[i-1];
                flag = 1;
            }
            else
            {
                ptr[k-1]->next = ptr[k-2]->next;
                ptr[k-1] = ptr[k-2]->next;
                ptr[0]->next = ptr[k-1]->next;
                for(int i=k-1;i>0;i--)
                    ptr[i]->next = ptr[i-1];
            }
            ptr[k-1] = ptr[0];
            ptr[0] = ptr[0]->next;
            if(!ptr[0]||!ptr[0]->next)
                break;
            int i;
            for(i=1;i<k-1;i++)
            {
                ptr[i] = ptr[i-1]->next;
                if(!ptr[i] || !ptr[i]->next)
                    break;
            }
            if(i!=k-1)
                break;
        }
        return head;
    }
};