剑指offer(11-20)编程题

1. 二进制中1的个数
2. 数值的整数次方
3. 调整数组顺序使奇数位于偶数前面
4. 链表中倒数第k个结点
5. 反转链表
6. 合并两个排序的链表
7. 树的子结构
8. 二叉树的镜像
9. 顺时针打印矩阵
10. 包含min函数的栈

11.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

class Solution {
public: int NumberOf1(int n) { int count = 0; while(n){ count++; n = n & (n-1); } return count; } };

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

class Solution {
public: double Power(double base, int exponent) { if(exponent == 0) return 1; if(exponent == 1) return base; int sign = 1; if(exponent < 0) { sign = -1; exponent = - exponent; } double res; res = Power(base,exponent >> 1); res *= res; if(exponent >> 1 & 1){ res *= base; } if(sign == -1){ res = 1.0 / res; } return res; } };

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

class Solution {
public: void reOrderArray(vector<int> &array) { int n = array.size(); int pEven = 0; //第一个偶数的位置 for (int i = 0; i < n; i++) { if (array[i] % 2 == 0) { pEven = i; break; } } for (int i = pEven+1; i < n; i++) { //发现奇数，从第一个偶数开始，后移 if (array[i] % 2 == 1) { int temp = array[i]; for (int j = i; j >= pEven; j--) { array[j] = array[j - 1]; } array[pEven] = temp; pEven++; } } } };

 14.输入一个链表，输出该链表中倒数第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){ ListNode* p = pListHead; ListNode* q = p; while(k--){ if(p){ p = p->next; }else{ return nullptr; } } while(p){ if(p){ p = p->next; q = q->next; } } return q; } };

15.输入一个链表，反转链表后，输出链表的全部元素。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public: ListNode* ReverseList(ListNode* pHead) { if(pHead == nullptr) return pHead; ListNode* fakeHead = new ListNode(-1); ListNode* p = pHead; while (p) { ListNode* fakeHead_next = fakeHead->next; ListNode* p_next = p->next; fakeHead->next = p; p->next = fakeHead_next; p = p_next; } pHead = fakeHead->next; return pHead; } };

 16.输入两个单调递增的链表，输出两个链表合成后的链表，固然咱们须要合成后的链表知足单调不减规则。

class Solution {
public: ListNode* Merge(ListNode* pHead1, ListNode* pHead2){ ListNode* fakeHead = new ListNode(-1); ListNode* p = fakeHead; ListNode* p1 = pHead1; ListNode* p2 = pHead2; while(p1 && p2){ if(p1->val <= p2->val){ p->next = p1; p1 = p1->next; }else{ p->next = p2; p2= p2->next; } p = p->next; } if(p1) p->next = p1; if(p2) p->next =p2; return fakeHead->next; } };

 17.输入两棵二叉树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 {
private: bool doHasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) { if (pRoot2 == nullptr) return true; if (pRoot1 == nullptr) return false; return ((pRoot1->val == pRoot2->val) && doHasSubtree(pRoot1->left, pRoot2->left) && doHasSubtree(pRoot1->right, pRoot2->right)) || doHasSubtree(pRoot1->left, pRoot2) || doHasSubtree(pRoot1->right, pRoot2); } public: bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) { if (pRoot2 == nullptr) //空树不是任意一个子树的子结构 return false; return doHasSubtree(pRoot1,pRoot2); } };

 18.操做给定的二叉树，将其变换为源二叉树的镜像。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public: void Mirror(TreeNode* pRoot) { if(pRoot == nullptr) return; TreeNode* temp = pRoot->left; pRoot->left = pRoot->right; pRoot->right = temp; Mirror(pRoot->left); Mirror(pRoot->right); } };

 19.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每个数字，例如，若是输入以下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

class Solution {
private: void printMatrix(vector<vector<int>>& matrix, vector<int>& res, int circle) { int endRow = matrix.size() - 1 - circle; int endCol = matrix[0].size() - 1 - circle; //从左到右 for (int i = circle; i <= endCol; i++) { res.push_back(matrix[circle][i]); } //从上往下 for (int i = circle + 1; i <= endRow; i++) { res.push_back(matrix[i][endCol]); } //从右往左 if (circle < endCol && circle < endRow) { for (int i = endCol - 1; i >= circle; i--) { res.push_back(matrix[endRow][i]); } } //从下往上 if (circle < endCol && circle < endRow) { for (int i = endRow - 1; i > circle; i--) { res.push_back(matrix[i][circle]); } } } public: vector<int> printMatrix(vector<vector<int>>& matrix) { vector<int> res; if (matrix.empty()) return res; int rows = matrix.size(); int cols = matrix[0].size(); int circle = 0; while (circle * 2 < rows && circle * 2 < cols) { printMatrix(matrix, res, circle); circle++; } return res; } };

 20.定义栈的数据结构，请在该类型中实现一个可以获得栈最小元素的min函数。

#include<cassert>
class Solution {
private: stack<int> m_data; stack<int> m_minVal; public: void push(int value) { m_data.push(value); if (m_minVal.empty() || value < m_minVal.top()) { m_minVal.push(value); } else { m_minVal.push(m_minVal.top()); } } void pop() { assert(m_data.size() > 0); m_data.pop(); m_minVal.pop(); } int top() { assert(m_data.size() > 0); return m_data.top(); } int min() { assert(m_minVal.size() > 0); return m_minVal.top(); } };