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();
}
};