1
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路：本题最初想简单的求模算出等于1的位数，但是发现负数不行。其实简单的做法应该是与1相与，如果为1，则原来为1，循环移位判断。但注意，要左移，要是右移，对于负数会一直在高位补1，导致结果不准确。
class Solution {
public:
int NumberOf1(int n) {
int count=0;
int flag=1;
while(flag!=0){
if(flag&n){
count++;
}
flag=flag<<1;
}
return count;
}
};
2
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
递归最简单了。。。迭代比较麻烦。
class Solution {
public:
double Power(double base, int exponent) {
if(exponent == 0) return 1;
if(base == 0) return 0;
if(exponent == 1)
return base;
else if(exponent == -1)
return 1/base;
return Power(base,exponent/2) * Power(base,exponent/2) * Power(base,exponent%2);
}
};
3
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
因为要求保证相对位置，所以只能相邻的交换，不能用快排这种不稳定的算法。
//两个思路吧，第一个思路：类似冒泡算法，前偶后奇数就交换：
class Solution {
public:
void reOrderArray(vector<int> &array) {
for (int i = 0; i < array.size();i++)
{
for (int j = array.size() - 1; j>i;j--)
{
if (array[j] % 2 == 1 && array[j - 1]%2 == 0) //前偶后奇交换
{
swap(array[j], array[j-1]);
}
}
}
}
};
//第二个思路：再创建一个数组
class Solution{
public:
void reOrderArray(vector<int> &array) {
vector<int> array_temp;
vector<int>::iterator ib1, ie1;
ib1 = array.begin();
for (; ib1 != array.end();){ //遇见偶数，就保存到新数组，同时从原数组中删除
if (*ib1 % 2 == 0) {
array_temp.push_back(*ib1);
ib1 = array.erase(ib1);
}
else{
ib1++;
}
}
vector<int>::iterator ib2, ie2;
ib2 = array_temp.begin();
ie2 = array_temp.end();
for (; ib2 != ie2; ib2++) //将新数组的数添加到老数组
{
array.push_back(*ib2);
}
}
};
4
输入一个链表，输出该链表中倒数第k个结点。
本题土办法就是先遍历一遍链表，找到一共多少个，倒数第K个就是正数第count-k+1个，从头再遍历一遍，注意k=0和k>count的情况的处理，都返回NULL；
但是有个非常好的思路2.用两个指针，1个跑了K-1个时，第2 个再开跑，则1跑到底时，第2个指针指针所指就是要找的倒数第k个。
思路1：
class Solution {
public:
ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
if(k==0)
return NULL;
int count=0;
ListNode* p=pListHead;
while(p!=NULL){
count++;
p=p->next;
}
if(k>count)
return NULL;
int find=count-k+1;
int x=1;
p=pListHead;
while(x<find){
p=p->next;
x++;
}
return p;
}
};
思路二
| 时间复杂度O(n),一次遍历即可 public class Solution { public ListNode FindKthToTail(ListNode head,int k) { ListNode pre=null,p=null; //两个指针都指向头结点 p=head; pre=head; //记录k值 int a=k; //记录节点的个数 int count=0; //p指针先跑，并且记录节点数，当p指针跑了k-1个节点后，pre指针开始跑， //当p指针跑到最后时，pre所指指针就是倒数第k个节点 while(p!=null){ p=p.next; count++; if(k<1){ pre=pre.next; } k--; } //如果节点个数小于所求的倒数第k个节点，则返回空 if(count<a) return null; return pre;
} } |
5
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
class Solution {
public:
ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
{
ListNode* result = NULL;
ListNode* current = NULL;
if(pHead1 == NULL)
return pHead2;
if(pHead2 == NULL)
return pHead1;
/*
if(pHead1->val <= pHead2->val){
result = pHead1;
result->next = Merge(pHead1->next, pHead2);
} else {
result = pHead2;
result->next = Merge(pHead1, pHead2->next);
}
*/
while(pHead1 != NULL && pHead2 != NULL){
if(pHead1->val <= pHead2->val){
if(result == NULL){
current = result = pHead1;
} else {
current->next = pHead1;
current = current->next;
}
pHead1 = pHead1->next;
} else {
if(result == NULL){
current = result = pHead2;
} else {
current->next = pHead2;
current = current->next;
}
pHead2 = pHead2->next;
}
}
if(pHead1 == NULL){
current->next = pHead2;
}
if(pHead2 == NULL){
current->next = pHead1;
}
return result;
}
};
6
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
本题要注意，B可能在A的左子树或者A，或者A的右子树中，注意比较方法。
class Solution {
public:
bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
{
if(pRoot2 == NULL || pRoot1 == NULL )
return false;
return isSubtree(pRoot1, pRoot2)|| HasSubtree(pRoot1->left,pRoot2) || HasSubtree(pRoot1->right,pRoot2);
}
bool isSubtree(TreeNode* pRoot1 , TreeNode* pRoot2){
if(pRoot2 == NULL)
return true;
if(pRoot1 == NULL)
return false;
return pRoot1->val == pRoot2->val && isSubtree(pRoot1->left,pRoot2->left) && isSubtree(pRoot1->right,pRoot2->right);
}
};
7
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。
class Solution {
public:
stack<int> stack1,stack2;
void push(int value) {
stack1.push(value);
if(stack2.empty())
stack2.push(value);
else if(value<=stack2.top())
{
stack2.push(value);
}
}
void pop() {
if(stack1.top()==stack2.top())
stack2.pop();
stack1.pop();
}
int top() {
return stack1.top();
}
int min() {
return stack2.top();
}
};
