LeetCode练习题206、560、24

206. 反转链表

反转一个单链表。

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
反转链表

方法一：双指针迭代

//双指针迭代法
//每次迭代都将 cur 的 next 指向 pre
// pre 和 cur 后移一位
struct ListNode* reverseList(struct ListNode* head){
    struct ListNode *pre = NULL;
    struct ListNode *cur = head;
    while(cur != NULL) {
        head = head->next;  
        cur->next = pre;
        pre = cur;
        cur = head;
    }
    return pre;
}

方法二：递归

//递归
//当前结点为空或其下个结点为空时终止递归
struct ListNode* reverseList(struct ListNode* head){
    if(head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode *cur = reverseList(head->next);
    head->next->next = head; //改变结点方向
    head->next = NULL;  //防止循环
    return cur;   //返回最后一个结点
}

560. 和为K的子数组

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2
[1,1] 与 [1,1] 为两种不同的情况。

和为K的子数组

本来以为这道题很简单呢，一定要好好审题，连续的子数组只有一个数时也算是一种情况。

方法一：暴力破解

//暴力破解
//找出所有连续子数组之和
//时间复杂度为O(n^3)，超时
int subarraySum(int* nums, int numsSize, int k){
    int i, j;
    int count = 0;
    for(i = 0; i < numsSize; i++) {
        for(j = i ; j < numsSize; j++) {
            int sum = 0;
            for(int m = i; m <= j; m++) {
                sum = sum + nums[m];
            }
            if(sum == k) {
                count++;
            }
        }
    }
    return count;
}

方法二：优化

//优化，去掉重复的计算
//知道[i,j] 子数组的和，就能用O(1)推出 [i,j−1] 的和
//用sum变量保存上次的求和，去掉内层循环
int subarraySum(int* nums, int numsSize, int k){
    int i, j;
    int count = 0;
    for(i = 0; i < numsSize; i++) {
        int sum = 0;
        for(j = i ; j < numsSize; j++) {
            sum = sum + nums[j];
            if(sum == k) {
                count++;
            }
        }
    }
    return count;
}

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

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.

两两交换链表中的节点

//指针的指针pp指向当前结点的指针
//首先，pp指向头部，然后指向下一个字段
//指针a和指针b表示当前节点和下一个节点
//需要从 *pp == a -> b -> (b->next) 转换为 *pp == b -> a -> (b->next)
//然后将pp移动到下一对
struct ListNode* swapPairs(struct ListNode* head){
    struct ListNode **pp = &head;
    struct ListNode *a, *b;
    while ((a = *pp) && (b = a->next)) {
        a->next = b->next;
        b->next = a;
        *pp = b;
        pp = &(a->next);
    }
    return head;
}