剑指offer第三章

剑指offer第三章

1.数值的整数次方

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

 1 class Solution {
 2 public:
 3     bool g_InvalidInput=false;
 4     double Power(double base, int exponent) 
 5     {
 6         g_InvalidInput=false;
 7         if(equal(base,0.0)&&exponent<0)
 8         {
 9             g_InvalidInput=true;
10             return 0.0;
11         }
12         unsigned int absExponent=(unsigned int)(exponent);
13         if(exponent<0)
14             absExponent=(unsigned int)(-exponent);
15         double result=PowerWithUnsignedExponent(base,absExponent);
16         if(exponent<0)
17             result=1.0/result;
18         return result;
19     }
20     
21     double PowerWithUnsignedExponent(double base,unsigned int exponent)
22     {
23         double result=1.0;
24         for(int i=1;i<=exponent;++i)
25             result*=base;
26         
27         return result;
28     }
29     bool equal(double num1,double num2)
30     {
31         if((num1-num2>-0.0000001)&&(num1-num2<0.0000001))
32             return true;
33         else
34             return false;
35     }
36 };

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

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
 1 class Solution {
 2 public:
 3     void reOrderArray(vector<int> &array) 
 4     {
 5         vector<int> res;
 6         for(int i = 0; i < array.size(); i++)
 7         {
 8             if(array[i] % 2 == 1)
 9                 res.push_back(array[i]);
10         }
11         for(int i = 0; i < array.size(); i++)
12         {
13             if(array[i] % 2 == 0)
14                 res.push_back(array[i]);
15         }
16         //array.swap(res);
17         array = res;
18     }
19 };

3.输入一个链表，输出该链表中倒数第k个结点

 1 /*
 2 struct ListNode {
 3     int val;
 4     struct ListNode *next;
 5     ListNode(int x) :
 6             val(x), next(NULL) {
 7     }
 8 };*/
 9 class Solution {
10 public:
11     ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) 
12     {
13         if(pListHead==NULL||k==0)
14             return NULL;
15         ListNode *pAhead=pListHead;
16         ListNode *pBhind=NULL;
17         for(unsigned int i=0;i<k-1;++i)
18         {
19             if(pAhead->next!=NULL)
20                 pAhead=pAhead->next;
21             else
22                 return NULL;
23         }
24         pBhind=pListHead;
25         
26         while(pAhead->next!=NULL)
27         {
28             pAhead=pAhead->next;
29             pBhind=pBhind->next;
30         }
31         return pBhind;
32     }
33 };

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

 1 /*
 2 struct ListNode {
 3     int val;
 4     struct ListNode *next;
 5     ListNode(int x) :
 6             val(x), next(NULL) {
 7     }
 8 };*/
 9 class Solution {
10 public:
11     ListNode* ReverseList(ListNode* pHead)
12     {
13         ListNode* pReversedHead=NULL;
14         ListNode* pNode=pHead;
15         ListNode* pPrev=NULL;
16         while(pNode!=NULL)
17         {
18             ListNode* pNext=pNode->next;
19             if(pNext==NULL)
20                 pReversedHead=pNode;
21             pNode->next=pPrev;
22             pPrev=pNode;
23             pNode=pNext;
24         }
25         return pReversedHead;
26     }
27 };

5.合并两个排序的链表

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

 1 /*
 2 struct ListNode {
 3     int val;
 4     struct ListNode *next;
 5     ListNode(int x) :
 6             val(x), next(NULL) {
 7     }
 8 };*/
 9 class Solution {
10 public:
11     ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
12     {
13         if(pHead1==NULL) //链表1为空，直接返回链表2
14             return pHead2;
15         else if(pHead2==NULL)//链表2为空，直接返回链表1
16             return pHead1;
17         ListNode* pMergedHead=NULL;
18         if(pHead1->val<pHead2->val)
19         {
20             pMergedHead=pHead1;
21             pMergedHead->next=Merge(pHead1->next,pHead2);//递归
22         }
23         else
24         {
25             pMergedHead=pHead2;
26             pMergedHead->next=Merge(pHead1,pHead2->next);//递归
27         }
28         return pMergedHead;
29     }
30 };

6.树的子结构

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

 1 /*
 2 struct TreeNode {
 3     int val;
 4     struct TreeNode *left;
 5     struct TreeNode *right;
 6     TreeNode(int x) :
 7             val(x), left(NULL), right(NULL) {
 8     }
 9 };*/
10 class Solution {
11 public:
12     bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
13     {
14         bool result=false;
15         //递归在A中查找与B根结点相同的结点
16         if(pRoot1!=NULL&&pRoot2!=NULL)//树A和树B不为空
17         {
18             if(pRoot1->val==pRoot2->val)//找到相等的结点，执行第二步
19                 result=DoesTree1HaveTree2(pRoot1,pRoot2);
20             if(!result)
21             {
22                 result=HasSubtree(pRoot1->left,pRoot2);//找左结点
23             }
24             if(!result)
25             {
26                 result=HasSubtree(pRoot1->right,pRoot2);//找右结点
27             }
28         }
29         return result;
30     }
31     bool DoesTree1HaveTree2(TreeNode* pRoot1, TreeNode* pRoot2)
32     {
33         if(pRoot2==NULL)//树B找到叶结点的左右，则返回真
34             return true;
35         if(pRoot1==NULL)//树A找到叶结点的左右，返回假
36             return false;
37         if(pRoot1->val!=pRoot2->val)//不等，返回假
38             return false;
39         //相等，递归判断左右结点是否相等
40         return DoesTree1HaveTree2(pRoot1->left,pRoot2->left)&&DoesTree1HaveTree2(pRoot1->right,pRoot2->right);
41     }
42 };

 

posted @ 2017-08-22 15:18  walanwalan  阅读(229)  评论(0)  编辑  收藏  举报