剑指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<)
         {
             g_InvalidInput=true;
             return 0.0;
         }
         unsigned int absExponent=(unsigned int)(exponent);
         if(exponent<)
             absExponent=(unsigned int)(-exponent);
         double result=PowerWithUnsignedExponent(base,absExponent);
         if(exponent<)
             result=1.0/result;
         return result;
     }

     double PowerWithUnsignedExponent(double base,unsigned int exponent)
     {
         double result=1.0;
         for(int i=;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 = ; i < array.size(); i++)
         {
             if(array[i] %  == )
                 res.push_back(array[i]);
         }
         for(int i = ; i < array.size(); i++)
         {
             if(array[i] %  == )
                 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==)
             return NULL;
         ListNode *pAhead=pListHead;
         ListNode *pBhind=NULL;
         for(unsigned int i=;i<k-;++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);
     }
 };