文章目录
1.二维数组中的查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
bool Find(int target, vector<vector<int> > array) {
bool found = false;
if(!array.empty()){
int rows = array.size(), row = 0;
int columns = array[0].size(), column = columns -1;
while(row<rows && column>=0){
if(array[row][column] == target){
found = true;
break;
}else if(array[row][column] > target)
--column;
else
++row;
}
}
return found;
}
2.数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
[1].预备知识：set的基本用法
set容器用来存储同一数据类型的数据类型，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。应该注意的是set中元素的值不能直接被改变。C++ STL中标准关联容器set, multiset, map, multimap底层实现基于红黑树。对于解答本题来说可以借助set的find和count成员函数得以轻松实现，如解法一：
count Count elements with a specific value (public member function )
find Get iterator to element (public member function )
[2].Code
/*解法一：时间复杂度O(n),O(n)*/
bool duplicate(int numbers[], int length, int* duplication) {
if(numbers == nullptr || length <=0)
return false;
for(int i=0;i<length;i++){
if(numbers[i]<0 || numbers[i]>=length)
return false;
}
set<int>arr;
for(int i=0;i<length;i++){
if(arr.find(numbers[i]) != arr.end()){
*duplication = numbers[i];
return true;
}
arr.insert(numbers[i]);
}
return false;
}
/*解法二：时间复杂度O(n),O(1)*/
bool duplicate(int numbers[], int length, int* duplication) {
...
for(int i=0;i<length;i++){
while(numbers[i]!=i){
if(numbers[i]==numbers[numbers[i]]){
*duplication = numbers[i];
return true;
}
int tmp = numbers[i];
numbers[i] = numbers[tmp];
numbers[tmp] = tmp;
}
}
...
3. 构建乘积数组
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。
vector<int> multiply(const vector<int>& A) {
vector<int> B(A.size(),0);
B[0] = 1;
for(int i=1;i<A.size();i++){
B[i] = B[i-1]*A[i-1];
}
int tmp = 1;
for(int i=A.size()-2;i>=0;--i){
tmp = tmp * A[i+1];
B[i] *= tmp;
}
return B;
}
4. 斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。n<=39
int Fibonacci(int n) {
int result = 0;
int a = 1,b = 0; //假设f(-1)=1,f(0)=0
for(int i=1;i<=n;++i){
result = a+b;
a = b;
b = result;
}
return result;
}
5. 旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
class Solution {
public:
int minFromportion(vector<int> &rotateArray,int head,int tail){
int result = rotateArray[head];
for(int i=head+1;i<=tail;++i){
if(result>rotateArray[i])
result = rotateArray[i];
}
return result;
}
int minNumberInRotateArray(vector<int> rotateArray) {
int result = 0;
if(!rotateArray.empty()){
int head = 0;
int tail = rotateArray.size()-1;
int midindex = head;
while(rotateArray[head]>=rotateArray[tail]){
if(tail-head == 1)
break;
midindex = head + ((tail-head)>>1) ;
if(rotateArray[head]==rotateArray[tail] && rotateArray[midindex]==rotateArray[head])
return minFromportion(rotateArray,head,tail);
if(rotateArray[midindex]>=rotateArray[head])
head = midindex;
else if(rotateArray[midindex]<=rotateArray[tail])
tail = midindex;
}
result = rotateArray[tail] ;
}
return result;
}
};
6. 调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
void reOrderArray(vector<int> &array) {
if(!array.empty()){
int head1= 0;
int head2= 0;
int tail = array.size();
while(head1< tail){
while(head1<tail && (array[head1]&1))
++head1;
head2 = head1+1;
while(head2<tail && !(array[head2]&1))
++head2;
if(head2<tail){
int tmp = array[head2];
// memmove(&array[head1+1],&array[head1],head2-head1);
for(;head2>head1;array[head2]=array[head2-1],--head2);
array[head1] = tmp;
}else
break;
}
}
}
注意：由于vector的底层实现是基于动态实现的故不能用现成的memmove函数
7. 顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 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 {
public:
void printMatrixInCircle(vector<vector<int> >& matrix,vector<int>& queue,int rows,int columns,int start){
int endX = columns-1-start;
int endY = rows-1-start;
for(int i=start;i<=endX;++i){
queue.push_back(matrix[start][i]);
}
if(endY-1 >= start){
for(int i=start+1;i<=endY;++i)
queue.push_back(matrix[i][endX]);
}
if(endY-1 >= start && endX-1 >= start){
for(int i=endX-1;i>=start;--i)
queue.push_back(matrix[endY][i]);
}
if(endY-1 > start && endX-1 >= start){
for(int i=endY-1;i>start;--i)
queue.push_back(matrix[i][start]);
}
}
vector<int> printMatrix(vector<vector<int> > matrix) {
vector<int> queue;
if(!matrix.empty()){
int start = 0;
int rows = matrix.size();
int columns = matrix[0].size();
while(rows>start*2 && columns>start*2){
printMatrixInCircle(matrix,queue,rows,columns,start);
++start;
}
}
return queue;
}
};
8.数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
class Solution {
public:
bool CheckMoreThanhalf(vector<int> &numbers,int result){
size_t counts = 0;
for(size_t i=0;i<numbers.size();++i){
if(numbers[i]==result)
++counts;
}
if(counts*2 <= numbers.size())
return false;
else
return true;
}
/*法一：借助数组规律得出的算法，时间复杂度O(n)*/
int MoreThanHalfNum_Solution(vector<int> numbers) {
int pre = 0;
if(!numbers.empty()){
pre = numbers[0];
int cons = 1;
for(int i=1;i<numbers.size();++i){
if(pre == numbers[i])
++cons;
else if(cons == 0){
pre = numbers[i];
cons = 1;
}
else
--cons;
}
if(!CheckMoreThanhalf(numbers,pre))
pre = 0;
}
return pre;
}
/*基于快排partition函数的搞法，时间复杂度O(n)*/
int partition(vector<int> &numbers,int start,int end){
int index = start;
if(start!=end) index = start + rand()%(end-start);
swap(numbers[index],numbers[end]);
int small = start-1;
for(index=start;index<end;++index){
if(numbers[index]<numbers[end]){
++small;
if(small!=index)
swap(numbers[small],numbers[index]);
}
}
++small;
swap(numbers[small],numbers[end]);
return small;
}
int MoreThanHalfNum_Solution(vector<int> numbers) {
int pre = 0;
if(!numbers.empty()){
int middle = numbers.size();
middle = middle>>1;
int start = 0;
int end = numbers.size()-1;
int index = partition(numbers,start,end);
while(index != middle){
if(index < middle){
start = index+1;
index = partition(numbers,start,end);
}
else{
end = index-1;
index = partition(numbers,start,end);
}
}
pre = numbers[index];
if(!CheckMoreThanhalf(numbers,pre))
pre = 0;
}
return pre;
}
};
9.最小的K个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
/*解法一：和上题类似，使用partition函数，时间复杂度：O(n)*/
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
vector<int> ret;
if(k>0&&input.size()>=k&&!input.empty()){
int start = 0;
int end = input.size()-1;
int index = partition(input,start,end);
while(index != k-1){
if(index < k-1){
start = index+1;
index = partition(input,start,end);
}
else{
end = index-1;
index = partition(input,start,end);
}
}
for(index=0;index<k;++index){
ret.push_back(input[index]);
}
}
return ret;
}
/*解法二：借助da顶堆完成*/
void heapify(vector<int>& result,int root){
while(true){
int maxPos = root;
if(root*2<result.size()&&result[root*2]>result[root]) maxPos = root*2;
if(root*2+1<result.size()&&result[root*2+1]>result[maxPos]) maxPos = maxPos+1;
if(maxPos == root) break;
swap(result[maxPos],result[root]);
root = maxPos;
}
}
vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
vector<int> result ;
if(k<=0 || k > input.size() || input.empty()) return result;
result.push_back(0);
for(int index = 1; index < k+1 ; index++){
result.push_back(input[index-1]);
for(int i=index;i/2>0 && result[i/2]<result[i];i/=2){
swap(result[i/2],result[i]);
}
}
for(int i=k;i<input.size();++i){
if(result[1]>input[i]){
result[1] = input[i];
heapify(result,1);
}
}
return vector<int>(result.begin()+1,result.end());
}
为什么说快排不如堆排序？
- 堆排序数据访问的方式没有快速排序友好。快速排序对于元素是局部顺序访问，而堆排序则是跳跃式访问，对CPU缓存不友好。
- 对于同样的数据在排序过程中，堆排序算法的数据交换次数要多于快速排序
- 在本题中之所以要写出做法2是为了在处理海量数据时提供一种措施，因为不可能一次把所有数据都push到内存里面。
10. 连续子数组的最大和
例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和
int FindGreatestSumOfSubArray(vector<int> array) {
int ret=-1;
if(!array.empty()){
int sum=array[0];
ret=sum;
for(int i=1;i<array.size();++i){
if(sum<0)
sum = array[i];
else
sum +=array[i];
if(sum > ret)
ret = sum;
}
}
return ret;
}
11.把数组排成最小的数
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
class Solution {
public:
static bool compare(string &str1,string &str2){
string strCombine1 = str1+str2;
string strCombine2 = str2+str1;
return strCombine1<strCombine2;
}
string PrintMinNumber(vector<int> numbers) {
string res;
if(!numbers.empty()){
vector<string>strNumber(numbers.size());
for(int i=0;i<numbers.size();++i){
strNumber[i] = to_string(numbers[i]);
}
sort(strNumber.begin(),strNumber.end(),compare);
for(auto c:strNumber){
res += c;
}
}
return res;
}
};
12. 数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007,牛客上类型有毒…
class Solution {
public:
long long InversePairsCore(vector<int> &data,int start,int end){
if(start == end )
return 0;
int length = (end-start)>>1;
long long left = InversePairsCore(data,start,start+length);
long long right = InversePairsCore(data,start+length+1,end);
int i = start+length;
int j = end-start-length-1;
int copyfd = end;
long long count = 0;
vector<int> tmp(data.begin()+i+1,data.begin()+end+1);
while(i>=start && j>=0){
if(data[i]>tmp[j]){
count += j+1;
data[copyfd--] = data[i--];
}else{
data[copyfd--] = tmp[j--];
}
}
for(;i>=start;--i){
data[copyfd--] = data[i];
}
for(;j>=0;--j){
data[copyfd--] = tmp[j];
}
return left+right+count;
}
int InversePairs(vector<int> data) {
long long count = 0;
if(!data.empty()){
count = InversePairsCore(data,0,data.size()-1);
count %= 1000000007;
}
return count;
}
};
13. 数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数。
class Solution {
public:
int GetFirstK(vector<int>& data,int k,int start,int end){
if(start>end)
return -1;
int midindex = (start+end)/2;
int middata = data[midindex];
if(middata == k){
if((midindex>0&&data[midindex-1]!=k) || midindex==0)
return midindex;
else
end = midindex-1;
}else if(middata > k){
end = midindex-1;
}else{
start = midindex+1;
}
return GetFirstK(data,k,start,end);
}
int GetLastK(vector<int>&data,int k,int start,int end){
if(start>end)
return -1;
int midindex = (start+end)/2;
int middata = data[midindex];
if(middata == k){
if((midindex<data.size()-1&&data[midindex+1]!=k) || midindex==data.size()-1)
return midindex;
else
start = midindex+1;
}else if(middata>k){
end = midindex-1;
}else
start = midindex+1;
return GetLastK(data,k,start,end);
}
int GetNumberOfK(vector<int> data ,int k) {
int left = 0;
int right = 0;
if(!data.empty()){
left = GetFirstK(data,k,0,data.size()-1);
right = GetLastK(data,k,0,data.size()-1);
if(left>-1 && right>-1)
return right-left+1;
}
return right-left;
}
};
程序员迷惑行为，上面两个函数可以用STL中的lower_bound()与upper_bound()函数替代，然而我上面求midindex若是使用midindex=start+(end-start)>>1求得的话为什么会超时，迷惑？调整为上面所示则正常了
14. 0~n-1中缺少的数字
显然可以使用二分的思想，若中间值和下标值相等则在后面，令left=mid+1即可，反正则判断是否已经找到：
int GetMissingNumber(vector<int> data){
int res = -1;
if(!data.empty()){
int left = 0, right = data.size()-1;
while(left<=right){
int middle = (right+left)>>1;
if(data[middle]!=middle){
if(mmiddle==0||data[middle-1]==middle-1)
{res=middle; break;}
else right = middle-1;
}
else
left = middle+1;
}
return res;
}
}
15.数组中下标和数值相等的元素。
前提是递增数组中找下标和数值相等的元素，显然可以使用二分的思想，若data[(start+end)>>1]大于(start+end)>>1则在前面找，反之，若data[(start+end)>>1]小于(start+end)>>1则在后面找，直至找到为止。
16.数组中只出现一次的数字
一个整型数组里除了两个数字之外，其他的数字都出现了两次。写程序找出这两个只出现一次的数字。
class Solution {
public:
int FirstIs1(int result){
int bit = 0;
while(((result&1)==0)&&(bit<8*sizeof(int))){
bit++;
result = result>>1;
}
return bit;
}
bool IsBit1(int num,int bit){
num = num>>bit;
return (num&1);
}
void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
if(data.size()>=2){
int resultEOR = 0;
for(auto number:data)
resultEOR ^= number;
int bitIs1 = FirstIs1(resultEOR);
*num1 = *num2 = 0;
for(int number:data){
if(IsBit1(number,bitIs1))
*num1 ^= number;
else
*num2 ^= number;
}
}
}
};
程序员迷惑行为，C语言运算符优先级，醉了…，懂了加括号的重要性
17. 和为S的两个数字
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
vector<int> ret;
if(!array.empty()){
int left =0,right = array.size()-1;
while((array[left]+array[right])!=sum && left < right){
if((array[left]+array[right])>sum)
--right;
else
++left;
}
if(left<right){
ret.push_back(array[left]);
ret.push_back(array[right]);
}
}
return ret;
}
18. 和为S的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
vector<vector<int> > FindContinuousSequence(int sum) {
vector<vector<int>> res;
if(sum<3)
return res;
int small=1, big=2;
int mid=(sum+1)>>1;
int value=small+big;
int index=0;
while(mid>small){
if(value == sum){
res.push_back(vector<int>());
for(int i=small;i<=big;++i)
res[index].push_back(i);
++index; value += ++big;
}
while(value!=sum && mid>small){
if(value>sum){
value -=small;
++small;
}
else{
++big;
value +=big;
}
}
}
return res;
}
19.求1+2+3+…+n
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
class Temp{
public:
Temp(){++N; Sum+=N; }
static void reset(){N=0;Sum=0;}
static int GetSum(){return Sum;}
private:
static int N;
static int Sum;
};
int Temp::N = 0;
int Temp::Sum = 0;
class Solution {
public:
int Sum_Solution(int n) {
Temp::reset();
Temp *a=new Temp[n];
delete []a;
a=nullptr;
return Temp::GetSum();
}
};
哈，有四种解法，分别是借助构造函数，虚函数，函数指针，类模板完成。此处借助构造函数基于循环的原理实现题目要求。
20.不用加减乘除做加法
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
int Add(int num1, int num2)
{
int sum , carry;
do{
sum = num1^num2;
carry = (num1&num2)<<1;
num1 = sum;
num2 = carry;
}while(num2);
return num1;
}
