剑指offer第三章

剑指offer第三章

1.数值的整数次方

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

class Solution {
public:
    bool g_InvalidInput=false;
    double Power(double base, int exponent) 
    {
        g_InvalidInput=false;
        if(equal(base,0.0)&&exponent<0)
        {
            g_InvalidInput=true;
            return 0.0;
        }
        unsigned int absExponent=(unsigned int)(exponent);
        if(exponent<0)
            absExponent=(unsigned int)(-exponent);
        double result=PowerWithUnsignedExponent(base,absExponent);
        if(exponent<0)
            result=1.0/result;
        return result;
    }
    
    double PowerWithUnsignedExponent(double base,unsigned int exponent)
    {
        double result=1.0;
        for(int i=1;i<=exponent;++i)
            result*=base;
        
        return result;
    }
    bool equal(double num1,double num2)
    {
        if((num1-num2>-0.0000001)&&(num1-num2<0.0000001))
            return true;
        else
            return false;
    }
};

2.调整数组顺序使奇数位于偶数前面，并保持奇数和奇数，偶数和偶数相对位置不变

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

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.swap(res);
        array = res;
    }
};

3.输入一个链表，输出该链表中倒数第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==NULL||k==0)
            return NULL;
        ListNode *pAhead=pListHead;
        ListNode *pBhind=NULL;
        for(unsigned int i=0;i<k-1;++i)
        {
            if(pAhead->next!=NULL)
                pAhead=pAhead->next;
            else
                return NULL;
        }
        pBhind=pListHead;
        
        while(pAhead->next!=NULL)
        {
            pAhead=pAhead->next;
            pBhind=pBhind->next;
        }
        return pBhind;
    }
};

4.输入一个链表，反转链表后，输出链表的所有元素。

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

5.合并两个排序的链表

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

/*
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==NULL) //链表1为空，直接返回链表2
            return pHead2;
        else if(pHead2==NULL)//链表2为空，直接返回链表1
            return pHead1;
        ListNode* pMergedHead=NULL;
        if(pHead1->val<pHead2->val)
        {
            pMergedHead=pHead1;
            pMergedHead->next=Merge(pHead1->next,pHead2);//递归
        }
        else
        {
            pMergedHead=pHead2;
            pMergedHead->next=Merge(pHead1,pHead2->next);//递归
        }
        return pMergedHead;
    }
};

6.树的子结构

输入两棵二叉树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 result=false;
        //递归在A中查找与B根结点相同的结点
        if(pRoot1!=NULL&&pRoot2!=NULL)//树A和树B不为空
        {
            if(pRoot1->val==pRoot2->val)//找到相等的结点，执行第二步
                result=DoesTree1HaveTree2(pRoot1,pRoot2);
            if(!result)
            {
                result=HasSubtree(pRoot1->left,pRoot2);//找左结点
            }
            if(!result)
            {
                result=HasSubtree(pRoot1->right,pRoot2);//找右结点
            }
        }
        return result;
    }
    bool DoesTree1HaveTree2(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(pRoot2==NULL)//树B找到叶结点的左右，则返回真
            return true;
        if(pRoot1==NULL)//树A找到叶结点的左右，返回假
            return false;
        if(pRoot1->val!=pRoot2->val)//不等，返回假
            return false;
        //相等，递归判断左右结点是否相等
        return DoesTree1HaveTree2(pRoot1->left,pRoot2->left)&&DoesTree1HaveTree2(pRoot1->right,pRoot2->right);
    }
};