文章目錄
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;
}
