Leetcode上的各种“Reverse”

A. 单链表整体的逆转

题目链接：https://leetcode.com/problems/reverse-linked-list/

其实做法挺简单的，就是将每个节点的next指针指向原来链表中的上一个就好了，注意对NULL的处理。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *last = NULL, *now = head;

        while (now != NULL) {
            ListNode* nextOne = now->next;
            now->next = last;
            last = now;
            now = nextOne;
        }

        return last;
    }
};

B. 单链表的部分逆转

即旋转链表第m个节点到第n个节点之间的部分，逆转部分跟A的原理一样，不过要处理好左右，以及NULL的情况。
原题链接：https://leetcode.com/problems/reverse-linked-list-ii/

#include <stdio.h>
#include <assert.h>

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

    void append(int x) {
        assert(this != NULL);
        ListNode* now = this;
        while (now->next != NULL)
            now = now->next;
        now->next = new ListNode(x);
    }

    void print() {
        ListNode* now = this;
        while (now != NULL) {
            printf("%d ", now->val);
            now = now->next;
        }
        printf("\n");
    }
};

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if (m == n)
            return head;

        ListNode *left = NULL, *right = NULL;
        ListNode *left_pre = NULL, *right_next = NULL;
        ListNode *now = head, *last = NULL;

        for (int i = 1; now != NULL; ++i) {
            if (i == m-1)
                left_pre = now;
            else if (i == m) 
                left = last = now;
            else if (i == n)
                right = now;
            else if (i > n) {
                right_next = now;
                break;
            }

            // case i in (m, n], reverse it
            if (i > m) {
                ListNode* nextOne = now->next;
                now->next = last;
                last = now;
                now = nextOne;
                continue;
            }

            now = now->next;
        }

        if (left_pre == NULL)
            head = left_pre = right;
        else
            left_pre->next = right;

        left->next = right_next;

        return head;
    }
};


int main() {
    Solution s;

    ListNode* head = new ListNode(1);
    for (int i = 2; i <= 10; ++i)
        head->append(i);

    printf("between 2 and 9:\n");
    head = s.reverseBetween(head, 2, 9);
    head->print();
    head = s.reverseBetween(head, 2, 9);
    head->print();

    printf("\ninclude the head:\n");
    head = s.reverseBetween(head, 1, 9);
    head->print();
    head = s.reverseBetween(head, 1, 9);
    head->print();

    printf("\nreverse the total list:\n");
    head = s.reverseBetween(head, 1, 10);
    head->print();
    head = s.reverseBetween(head, 1, 10);
    head->print();


    printf("\nreverse one element:\n");
    head = s.reverseBetween(head, 1, 1);
    head->print();
    head = s.reverseBetween(head, 1, 1);
    head->print();

    return 0;
}

C. 二进制的反转

原题：https://leetcode.com/problems/reverse-bits/
给定一个无符号整数，要求将其二进制形式翻转一下，比如010111将变成111010，主要是位操作，掩码的基础知识，倒没什么特殊的技巧。

#include <stdio.h>
#include <assert.h>


typedef unsigned int uint32_t;

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        uint32_t ans = 0, mask = 1u;
        for (int i = 0; i < 32; ++i) {
            ans = ans << 1;
            if ((n & mask) != 0)
                ans |= 1u;
            mask = mask << 1;
        }

        return ans;
    }
};


int main() {
    Solution s;

    assert(s.reverseBits(0u) == 0u);
    assert(s.reverseBits(1u) == 2147483648u);
    assert(s.reverseBits(43261596u) == 964176192u);

    return 0;
}

D. 反转int数字

原题：https://leetcode.com/problems/reverse-integer/
这道题主要是要考虑如何判断是否会溢出，查阅网上资料后，觉得“未雨绸缪”法比较可取：

#include <stdio.h>
#include <assert.h>
using namespace std;


class Solution {
public:
    int reverse(int x) {
        int My_INT_MAX = (1u << 31) - 1, My_INT_MIN = -(1u << 31);
        bool neg = false;
        if (x == 0)
            return 0;
        if (x < 0) {
            if (x == My_INT_MIN)
                return 0;
            neg = true;
            x = -x;
        }

        int ans = 0;
        while (x > 0) {
            if (ans > My_INT_MAX / 10)
                return 0;
            ans *= 10;
            int key = x % 10;
            if (ans > My_INT_MAX - key)
                return 0;
            ans += key;
            x /= 10;
        }

        if (neg)
            return -ans;
        return ans;
    }
};


int main() {
    Solution s;

    assert(s.reverse(0) == 0);
    assert(s.reverse(-1) == -1);
    assert(s.reverse(-123) == -321);
    assert(s.reverse(234) == 432);
    assert(s.reverse(1234567809) == 0);
    assert(s.reverse(-2147483648) == 0);
    assert(s.reverse(2147483647) == 0);

    return 0;
}

E. 反转句子中的单词

原题：https://leetcode.com/problems/reverse-words-in-a-string/
即把the sky is blue变成blue is sky the
这个问题本身不难，难的是，能否做到O(1)的空间开销？
答案是可以的哈哈，第一次自己解决这样“精巧”的题目，之前稍微思维有点绕的题目都得看题解才能知道，否则就是各种暴力咕~~(╯﹏╰)b。
我的思路是：先将整个字符串按字符反转，比如the sky is blue变成eulb si yks eht，这样子有什么用呢？其实跟华容道这个游戏有点相似，你先把要“运输”的东西运送到目的地，然后再“转个身”，就好啦，具体的转身在这里就是——对每个单词（按照空格将其分开），内部再反转一次，就会变成：blue is sky the，具体实现代码如下：

#include <stdio.h>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <assert.h>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cmath>
using namespace std;


class Solution {
public:
    // need in-place and O(1) space to solve
    void reverseWords(string& s) {
        // first, you should get enough space to reverse each word
        // but notice that each word is exactly equal to itself in size!!!!!!
        // this is the most important property to solve this problem in O(1) space
        if (s.empty() || s == " ") {
            s = "";
            return;
        }

        int start = -1, len = s.size();
        reverseHelper(s, 0, len-1);

        for (int i = 0; i < len; ++i) {
            if (start == -1 && s[i] != ' ')
                start = i;
            else if (start != -1 && (s[i] == ' ' || i == len-1)) {
                int tail = i - 1;
                if (i == len-1 && s[i] != ' ')
                    tail = i;
                reverseHelper(s, start, tail);
                // printf("i=%d, s=%s, start=%d, tail=%d\n", i, s.data(), start, tail);
                start = -1;
            }
        }
    }

    void reverseHelper(string& s, int beg, int end) {
        for (int i = beg, j = end; i < j; ++i, --j)
            swap(s[i], s[j]);
    }
};


int main() {
    Solution s;

    string str("hello jacket");
    printf("Original str=%s\n", str.data());
    s.reverseWords(str);
    printf("After reversing, str=%s\n", str.data());

    return 0;
}

F. 在双向链表中删除一个值（并返回删除的个数）

这个是题外话了，无关reverse的主题，不过也是个有趣的问题，细节需要处理好——比如删除的值如果是在链表的头部，那该怎么办？代码感觉还是有点复杂了，可以再简化一下：

#include <stdio.h>

struct DList
{
    int val;
    DList *prev, *next;
    DList(int v): val(v), prev(NULL), next(NULL) {}
};

DList* delHelper(DList* pos) {
    DList* next = pos->next;
    DList* prev = pos->prev;
    if (prev != NULL)
        prev->next = next;
    if (next != NULL)
        next->prev = prev;
    // delete pos;  // if necessary

    return next;
}

int delVal(DList*& head, int val) {
    int cnt = 0;

    DList* now = head;
    bool first = true;
    while (now != NULL) {
        if (now->val == val) {
            now = delHelper(now);
            ++cnt;
        }
        else {
            if (first) {
                first = false;
                head = now;
            }
            now = now->next;
        }
    }

    // 如果全部都被删掉了，那么head自然就是NULL了
    if (first)
        head = NULL;

    return cnt;
}

void joint(DList* a, DList* b) {
    a->next = b;
    b->prev = a;
}

void print(DList* head) {
    DList* now = head;
    bool first = true;
    while (now != NULL) {
        if (first) {
            first = false;
            printf("%d", now->val);
        }
        else
            printf(" -> %d", now->val);
        now = now->next;
    }
    printf("\n");
}

int main() {
    DList* list[10];
    for (int i = 0; i < 10; ++i)
        list[i] = new DList(i/2);

    for (int i = 0; i < 9; ++i)
        joint(list[i], list[i+1]);

    DList* head = list[0];
    print(head);

    delVal(head, 0);
    print(head);

    delVal(head, 3);
    delVal(head, 4);
    print(head);

    return 0;
}