剑指 第3章 高质量的代码（代码的完整性、鲁棒性）

数值的整数次方

题目：给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

思路：注意分情况：幂次大于0、小于0

class Solution {
public:
    double Power(double base, int exponent) {
        if (exponent == 0) return 1;
        else if(exponent > 0){
            int res = base;
            for (int i = 1; i < exponent; i++)
                res *= base;
            return res;
        }
        else return 1/Power(base, -exponent);
    }
};

调整数组顺序使奇数位于偶数前面

题目：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
思路：新建一个数组先把原数组中的奇数push进去再把偶数push进去，然后用新数组数据覆盖原数组即可
复杂度O(n)

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        vector<int> res;
        for (int i = 0; i < array.size(); i++)
            if (array[i] % 2 == 1) res.push_back(array[i]);
        for (int i = 0; i < array.size(); i++)
            if (array[i] % 2 == 0) res.push_back(array[i]);
        array = res;
    }
};

链表中倒数第k个节点

题目：输入一个链表，输出该链表中倒数第k个结点。

思路：注意鲁棒性

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if (pListHead == nullptr || k == 0) return nullptr;
        ListNode *p1 = pListHead, *p2 = pListHead;
        for (int i = 0; i < k - 1; i++){
            if (p1->next != nullptr) p1 = p1->next;
            else return nullptr;
        }
        while (p1->next != nullptr){
            p1 = p1->next;
            p2 = p2->next;
        }
        return p2;
    }
};

反转链表

题目：输入一个链表，反转链表后，输出新链表的表头。

思路：分析过程，需要定义三个指针，保存当前节点、当前节点的上一节点、当前节点的下一节点

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode *pReverseHead = nullptr, *pNode = pHead, *pPrev = nullptr;
        while (pNode != nullptr){
            ListNode *pNext = pNode->next;
            if (pNext == nullptr) pReverseHead = pNode;
            pNode->next = pPrev;
            pPrev = pNode;
            pNode = pNext;
        }
        return pReverseHead;
    }
};

合并两个排序的链表

题目：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

思路：

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2){
        if (pHead1 == nullptr) return pHead2;
        else if (pHead2 == nullptr) return pHead1;
        ListNode* pMergedHead = nullptr;
        if (pHead1->val < pHead2->val){
            pMergedHead = pHead1;
            pMergedHead->next = Merge(pHead1->next, pHead2);
        }
        else{
            pMergedHead = pHead2;
            pMergedHead->next = Merge(pHead1, pHead2->next);
        }
        return pMergedHead;
    }
};

树的子结构

题目：输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2){
        bool res = false;
        if (pRoot1 != nullptr && pRoot2 != nullptr){
            if (pRoot1->val == pRoot2->val) res = DoesTree1HasTree2(pRoot1, pRoot2);
            if (!res) res = HasSubtree(pRoot1->left, pRoot2);
            if (!res) res = HasSubtree(pRoot1->right, pRoot2);
        }
        return res;
    }
private:
    bool DoesTree1HasTree2(TreeNode* pRoot1, TreeNode* pRoot2){
        if (pRoot2 == nullptr) return true;
        if (pRoot1 == nullptr) return false;
        if (pRoot1->val != pRoot2->val) return false;
        return DoesTree1HasTree2(pRoot1->left, pRoot2->left) && DoesTree1HasTree2(pRoot1->right, pRoot2->right);
    }
};