来自：https://blog.csdn.net/c406495762/article/details/79247243
目录
剑指Offer（十一）：二进制中1的个数
题目
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
1、思路
如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。
2、代码
C++:
class Solution {
public:
int NumberOf1(int n) {
int count = 0;
while(n){
++count;
n = (n - 1) & n;
}
return count;
}
};剑指Offer（十二）：数值的整数次方
题目
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
1、思路
当指数为负数的时候，可以先对指数求绝对值，然后算出次方的结果之后再取倒数。如果底数为0，则直接返回0。此时的次方在数学上是没有意义的。
除此之外，我们要注意：由于计算机表示小数（包括float和double型小数）都有误差，我们不能直接用等号（==）判断两个小数是否相等。如果两个小数的差的绝对值很小，比如小于0.0000001，就可以认为它们相等。
在计算次方的时候，除了简单的遍历，我们可以使用如下公式进行计算，来减少计算量：
2、代码
C++：
class Solution {
public:
double Power(double base, int exponent) {
if(equal(base, 0.0)){
return 0.0;
}
unsigned int absExponent = 0;
if(exponent > 0){
absExponent = (unsigned int)(exponent);
}
else{
absExponent = (unsigned int)(-exponent);
}
double result = PowerWithUnsignedExponent(base, absExponent);
if(exponent < 0){
result = 1.0 / result;
}
return result;
}
private:
bool equal(double num1, double num2){
if(num1 - num2 > -0.0000001 && (num1 - num2) < 0.0000001){
return true;
}
else{
return false;
}
}
double PowerWithUnsignedExponent(double base, unsigned int exponent){
if(exponent == 0){
return 1;
}
if(exponent == 1){
return base;
}
double result = PowerWithUnsignedExponent(base, exponent >> 1);
result *= result;
if(exponent & 0x1 == 1){
result *= base;
}
return result;
}
};
Python2.7：
python中等于没有误差，因此可以写出如下代码：
# -*- coding:utf-8 -*-
class Solution:
def Power(self, base, exponent):
# write code here
flag = 0
result = 1
if base == 0:
return False
if exponent < 0:
flag = 1
for i in range(abs(exponent)):
result *= base
if flag == 1:
result = 1 / result
return result剑指Offer（十九）：顺时针打印矩阵
题目
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵：
则依次打印出数组：1，2，3，4，8，12，16，15，14，13，9，5，6，7，11，10。
1、思路
将结果存入vector数组，从左到右，再从上到下，再从右到左，最后从下到上遍历。
2、代码
C++：
class Solution {
public:
vector<int> printMatrix(vector<vector<int> > matrix) {
int rows = matrix.size(); //行数
int cols = matrix[0].size(); //列数
vector<int> result;
if(rows == 0 && cols == 0){
return result;
}
int left = 0, right = cols - 1, top = 0, bottom = rows - 1;
while(left <= right && top <= bottom){
//从左到右
for(int i = left; i <= right; ++i){
result.push_back(matrix[top][i]);
}
//从上到下
for(int i = top + 1; i <= bottom; ++i){
result.push_back(matrix[i][right]);
}
//从右到左
if(top != bottom){
for(int i = right - 1; i >= left; --i){
result.push_back(matrix[bottom][i]);
}
}
//从下到上
if(left != right){
for(int i = bottom - 1; i > top; --i){
result.push_back(matrix[i][left]);
}
}
left++, top++, right--, bottom--;
}
return result;
}
};剑指Offer（二十九）：最小的K个数
题目
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
1、思路
最简单的方法就是先排序，然后在遍历输出最小的K个数，方法简单粗暴。
2、代码
C++：
class Solution {
public:
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
vector<int> result;
if(input.empty() || k > input.size()){
return result;
}
sort(input.begin(), input.end());
for(int i = 0; i < k; ++i){
result.push_back(input[i]);
}
return result;
}
};3、优化
上述算法的时间复杂度为O(n^2)，速度慢。另一种O(nlogk)的算法是基于堆排序的，特别适合处理海量数据。
我们可以先创建一个大小为k的数据容器来存储最小的k个数字，接下来我们每次从输入的n个整数中的n个整数中读入一个数。如果容器中已有的数字少于k个，则直接把这次读入的整数放入容器之中；如果容器已经有k个数字了，也就是容器满了，此时我们不能再插入新的数字而只能替换已有的数字。找出这已有的k个数中的最大值，然后拿这次待插入的整数和最大值进行比较。如果待插入的值比当前已有的最大值小，则用这个数替换当前已有的最大值；如果待插入的值比当前已有的最大值还要大，那么这个数不可能是最小的k个整数之一，于是我们可以抛弃这个整数。
因此当容器满了之后，我们要做3件事情：一是在k个整数中找到最大数；二是有可能在这个容器中删除最大数；三是有可能要插入一个新的数字。如果用一个二叉树来实现这个数据容器，那么我们在O(logk)时间内实现这三步操作。因此对于n个输入数字而言，总的时间效率就是O(nlogk)。
Ｃ++：
class Solution {
public:
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
vector<int> result;
int length = input.size();
if(length <= 0 || k <= 0 || k > length){
return result;
}
for(int i = 0; i < input.size(); i++){
if(result.size() < k){
result.push_back(input[i]);
}
else{
for(int j = k / 2; j >= 0; j--){
HeadAdjust(result, j, k);
}
for(int j = k - 1; j > 0; j--){
swap(result[0], result[j]);
HeadAdjust(result, 0, j);
}
if(result[k-1] > input[i]){
result[k-1] = input[i];
}
}
}
return result;
}
private:
void HeadAdjust(vector<int> &input, int parent, int length){
int temp = input[parent];
int child = 2 * parent + 1;
while(child < length){
if(child + 1 < length && input[child] < input[child+1]){
child++;
}
if(temp >= input[child]){
break;
}
input[parent] = input[child];
parent = child;
child = 2 * parent + 1;
}
input[parent] = temp;
}
};对于上述代码，我们还可以进一步优化，不是每次循环都需要重新排序的，只有在更新了容器的数据之后，才需要重新排序。
进一步优化：
class Solution {
public:
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
vector<int> result;
int length = input.size();
bool change = true;
if(length <= 0 || k <= 0 || k > length){
return result;
}
for(int i = 0; i < input.size(); i++){
if(result.size() < k){
result.push_back(input[i]);
}
else{
if(change == true){
for(int j = k / 2; j >= 0; j--){
HeadAdjust(result, j, k);
}
for(int j = k - 1; j > 0; j--){
swap(result[0], result[j]);
HeadAdjust(result, 0, j);
}
change = false;
}
if(result[k-1] > input[i]){
result[k-1] = input[i];
change = true;
}
}
}
return result;
}
private:
void HeadAdjust(vector<int> &input, int parent, int length){
int temp = input[parent];
int child = 2 * parent + 1;
while(child < length){
if(child + 1 < length && input[child] < input[child+1]){
child++;
}
if(temp >= input[child]){
break;
}
input[parent] = input[child];
parent = child;
child = 2 * parent + 1;
}
input[parent] = temp;
}
};剑指Offer（三十三）：丑数
题目
把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
1、思路
所谓的一个数m是另一个数n的因子，是指n能被m整除，也就是n%m==0。根据丑数的定义，丑数只能被2、3和5整除。根据丑数的定义，丑数应该是另一个丑数乘以2、3或者5的结果（1除外）。因此我们可以创建一个数组，里面的数字是排好序的丑数，每一个丑数都是前面的丑数乘以2、3或者5得到的。
这个思路的关键问题在于怎样保证数组里面的丑数是排好序的。对乘以2而言，肯定存在某一个丑数T2，排在它之前的每一个丑数乘以2得到的结果都会小于已有最大的丑数，在它之后的每一个丑数乘以乘以2得到的结果都会太大。我们只需要记下这个丑数的位置，同时每次生成新的丑数的时候，去更新这个T2。对乘以3和5而言，也存在着同样的T3和T5。（空间换时间）
C++：
class Solution {
public:
int GetUglyNumber_Solution(int index) {
if(index < 7){
return index;
}
vector<int> res(index);
for(int i = 0; i < 6; i++){
res[i] = i + 1;
}
int t2 = 3, t3 = 2, t5 = 1;
for(int i = 6; i < index; i++){
res[i] = min(res[t2] * 2, min(res[t3] * 3, res[t5] * 5));
while(res[i] >= res[t2] * 2){
t2++;
}
while(res[i] >= res[t3] * 3){
t3++;
}
while(res[i] >= res[t5] * 5){
t5++;
}
}
return res[index - 1];
}
};注意：1，2，3，4，5，6都是丑数。所以当index小于7的时候，直接返回index即可
剑指Offer（四十二）：和为S的两个数字
题目
输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述：
对应每个测试案例，输出两个数，小的先输出。
1、思路
对于一个数组，我们可以定义两个指针，一个从左往右遍历（pleft），另一个从右往左遍历（pright）。首先，我们比较第一个数字和最后一个数字的和curSum与给定数字sum，如果curSum < sum，那么我们就要加大输入值，所以，pleft向右移动一位，重复之前的计算；如果curSum > sum，那么我们就要减小输入值，所以，pright向左移动一位，重复之前的计算；如果相等，那么这两个数字就是我们要找的数字，直接输出即可。
这么做的好处是，也保证了乘积最小。
2、代码
C++：
class Solution {
public:
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
vector<int> result;
int length = array.size();
if(length < 1){
return result;
}
int pright = length - 1;
int pleft = 0;
while(pright > pleft){
int curSum = array[pleft] + array[pright];
if(curSum == sum){
result.push_back(array[pleft]);
result.push_back(array[pright]);
break;
}
else if(curSum < sum){
pleft++;
}
else{
pright--;
}
}
return result;
}
};
扫一扫
3331
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
