一、数组与指针
int data1[] = {1,2,3,4};
sizeof(data1) = 16;
int * data2;
sizeof(data2) = 4;
当数组作为参数传递时,它会退化为指针:
int getSize(int[] data3){
return sizeof(data3);
}
getSize(data1) = 4;
二、二维数组的查找
在一个二维数组中,每一行按照从左到右的顺序排序,每一列按照从上到下的顺序排序,如何判断某个数值是否出现在数组中?
思路:二维数组在内存中是顺序存储的,从上到下存储各行元素,同一行中按照从左到右的顺序存储,因此可以根据行号和列号计算出相对于首地址的偏移量,从而找到对应元素。我们可以从右上角元素开始分析,如果它大于要查找的值,则说明最后一列中的值肯定都比要查找的值大,可以将其剔除;如果它小于要查找的值,则说明第一行中的值肯定都比要查找的值小,可以将其剔除。这样行数处于增大的过程,列数处于减小的过程。边界值就是总行数和零。
代码如下:
bool find(int * matrix,int rows,int columns,int number){
if(matrix == null || rows < 0 || columns < 0)
throw exception("error");
int i = 0;
int j = columns - 1;
boolean flag = false;
while(i < rows && j >= 0 ){
if(matrix[i*columns+j] == number){}
flag = true;
break;
}
if(matrix[i*columns+j] > number)
j--;
else
i++;
}
return flag;
}
三、数组中出现次数超过一半的数字
方法一:将数组排序,然后统计每个数字出现的次数,时间复杂度为O(nlogn)。
方法二:数组中超过一半的数肯定是数组的中位数,利用快速排序的思想,先任意选一个数,利用partition函数确定它在排序数组中的下标,如果这个下标大于n/2,那么中位数
肯定在它的前面,反之在它的后面。这样通过递归找到下标为n/2的数即为中位数。
代码:
int MoreThanHalfNum(int * numbers,int length){
if(number == NULL || length < 0)
return 0;
//这里start和end是随着每次partition函数的执行而变动的,所以要单独定义出来
int middle = length >> 1;
int start = 0;
int end = length - 1;
int index = partition(numbers,start,end);
while(index != middle){
if(index < middle){
start = index + 1;
index = partition(numbers,start,length - 1);
}
else{
end = index + 1;
index = partition(numbers,start,end);
}
}
//这里要判断一下numbers[middle]在数组中出现的次数是否真的在一般以上
return numbers[middle];
}
int partition(int * numbers,int begin,int end){
int i = begin - 1;
int j = begin;
int value = numbers[end];
while(j < end){
if(numbers[k] < value){
i++;
switch(numbers[i],numbers[j]);
}
j++;
}
i++;
switch(numbers[i],numbers[end]);
return i;
}
的元素与该元素不同,那么times减一,反之加一。如果times为零了,那么就将下一个出现的元素至为result,最后result的值就是出现次数在一半以上的数。
代码(省略了前后的检验):
int MoreThanHalfNum(int * numbers,int length){
int result = numbers[0];
int times = 1;
for(int i = 1; i < length; i++){
if(times == 0){
result = numbers[i];
times = 1;
}
if(numbers[i] == result)
times++;
else
times--;
}
return result;
}
四、连续子数组的最大和
输入一个整型数组,数组里有正数也有负数,数组中一个或多个连续的多个数组组成一个子数组,求所有子数组的和的最大值。
方法一:分治法,一个数组中子数组的最大值有三种情况——这个子数组经过中间的数,子数组在中间的数之前,子数组在中间的数之后。因此我们可以这样做:
对于一个数组,我们先求出中间数左边子数组的最大子数组和、右边子数组的最大子数组和以及经过中间数的最大子数组和,其次找出这三个的最大值返回。求子树组的最大子
数组和应用递归。时间复杂度分析:设总的时间复杂度为T(n),因为它分为三部分,求左右子数组的最大子数组,时间复杂度为T(n/2),以及求经过中间元素的最大子数组,时
间复杂度为O(n),所以T(n) = 2T(n/2) + O(n),故总的时间复杂度为O(nlogn)。也可以这样想,求经过中间数的最大子数组的时间复杂度为O(N),求左右子数组的最大子数组均
为在规模为原数组一半的数组上求最大子数组,两者合起来的时间复杂度也为O(N)。要进行多少次这种遍历呢?logn次,所以总的复杂度为O(nlogn)。
代码:
int findMaxSubArray(int Arr[],int length){
return findMaxSubArray(Arr,0,length - 1);
}
int findMaxSubArray(int Arr[],int low,int high){
if(low == high)
return Arr[low];
int mid = low + (high - low) >> 1;
int MaxOfLeft = findMaxSubArray(Arr,low,mid);
int MaxOfRight = findMaxSubArray(Arr,mid+1,high);
int MaxCrossMid = findMaxCrossMid(Arr,low,mid,high);
int Max = MaxOfLeft >= MaxOfRight?MaxOfLeft:MaxOfRight;
Max = Max >= MaxCrossMid?Max:MaxCrossMid;
return Max;
}
int findMaxCrossMid(int Arr[],int low,int mid,int high){
int leftSum = Arr[mid];
int rightSum = 0;
//因为必须要包含mid元素,所以将leftSum和sum均初始化为Arr[mid],leftSum记录以Arr[mid]为最右元素的子数组的最大和
int sum = Arr[mid];
for(int i = mid - 1; i >= low; i--){
sum += Arr[i];
if(sum > leftSum)
leftSum = sum;
}
sum = 0;
//以rightSum 记录以Arr[mid+1]为最左元素的子数组的最大和
for(int i = mid + 1; i <= high; i++){
sum += Arr[i];
if(sum > rightSum)
rightSum = sum;
}
return (leftSum + rightSum);
}
加,在加到元素A[i]时,先把A[i]加上,如果得到的和sum为负数,那么下一次就把这个值舍弃,把A[i+1]作为第一个元素从新计算和,因为如果把sum加到A[i+1]上做为新的和那
么其值必然小于A[i+1],这样就确定了左下标i+1;怎么确定右下标呢?左下标定了,这不就相当于已知一个数组,求从第一个下标开始的所有子数组的和的最大值吗,依次遍历
即可。
bool isInvalidInput = false;
int findMaxSubArray(int * Arr,int length){
if(Arr == NULL || length < 0){
isInvalidInput = true;
return 0;
}
isInvalidInput = false;
int currSum = 0;
int greastSum = 0;
for(int i = 0; i < length; i++){
if(currSum > 0)
currSum += Arr[i];
else
currSum = Arr[i];
if(currSum > sum)
greastSum = currSum;
}
return greastSum;
}
五、数组中的逆序数
在数组中的两个数字如果前面一个大于后面的数字,则这两个数字组成一个逆序对。输入一个数组,求其逆序对的总和。如数组{7,5,6,4},其逆序对分别为
{7,5}、{7,6}、{7,4}、{5,5}、{6,4}。
解题思路:我们先将原数组分为两部分{7,5}和{6,4},再将这两部分分为{7}、{5}和{6}、{4}。然后合并{7}、{5}并计算逆序对数,因为7大于5,所以这里有一个逆序对,为了避免
在合并{7,5}和{6,4}时再将这对逆序对重复算进去,我们在将其合并时需要对其进行排序,即{5,7},同理{6}、{4}合并为{4,6}并且逆序对数加1。紧接着我们合并{5,7}和{4,6}并计
算其中的逆序对数,我们用一个辅助数组来存放合并的结果。首先我们看7和6,因为7大于6,所以7和{4,6}中的数字存在两个逆序对,将7放入辅助数组,紧接着我们看5和6,
因为6大于5,,所以{5}和{4,6}存在一个逆序对,将6放入辅助数组,依此类推,将5和4分别放入辅助数组并计算其中的逆序对数。合并的过程其实就是一个归并排序的过程,每
当向辅助数组放进一个数字,其逆序对数就是另外一个数组中比这个数小的数的个数。
代码:
int numberOfReversePair(char * array,int length){
if(array == NULL || length <= 0)
return 0;
int * temp = new int[length];
for(int i = 0; i < length; i++)
temp[i] = array[i];
delete[] temp;
return numberOfReversePair(array,temp,0,length - 1);
}
int numberOfReversePair(char * array,char * temp,int start,int end){
if(start == end){
return 0;
}
int length = end - start + 1;
int middle = length >> 1;
int left = numberOfReversePair(array,temp,start,start + middle);
int right = numberOfReversePair(array,temp,start + middle + 1,end);
int i = start + middle;
int j = end;
int index = end;
int count = 0;
while(i >= start && j >= start + middle + 1){
if(array[i] > array[j]){
temp[index--] = array[i--];
count + = j - start - middle;
}
else{
temp[index--] = array[j--];
}
}
while(i >= start){
temp[index--] = array[i--];
}
while(j >= start + middle + 1){
temp[index--] = array[j--];
}
return count + left + right;
}
六、数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数,如输入{1,2,3,3,3,4,5,}和数字3,输出3出现的次数3。
因为数组是排序的,所以我们可以用二分查找法先找出第一个3出现的位置和最后一个3出现的位置,然后求得其出现的次数。
int getFirstK(int * A,int k,int start,int end){
if(start < end)
return -1;
int mid = (start + end) >> 1;
if(A[mid] == k && (mid == start || A[mid - 1] != k))
return mid;
if(A[mid] > k)
end = mid - 1;
else
start = mid + 1;
getFirstK(A,k,start,end);
}
int getLastK(int * A,int k,int start,int end){
if(start < end)
return -1;
int mid = (start + end) >> 1;
if(A[mid] == k && (mid == end || A[mid + 1] != k))
return mid;
if(A[mid] > k)
end = mid - 1;
else
start = mid + 1;
getLastK(A,k,start,end);
}
int getNumberOfK(int * A,int k,int length){
int number = 0;
if(A != NULL && length > 0){
int start = 0;
int end = length - 1;
int firstK = getFirstK(A,k,start,end);
int lastK = getLastK(A,k,start,end);
if(firstK > -1 && lastK > -1)
number = lastK - firstK + 1;
}
return number;
}
七、一个整型数组中除了两个数字之外,其他的数字都出现了两次,请写出程序找出这个数组中只出现一次的数字。要求时间复杂度O(n),空间复杂度O(1)。
如输入数组{2,4,3,6,3,2,5,5},输出数字4和6。
先看一个简单的问题,如果一个数组中只有一个数字只出现一次,其它数字都出现两次,那么我们如何在时间复杂度O(n)和空间复杂度O(1)内找到这个只出现一次的数字?
两个相同的数字异或的结果为0,所以如果我们把数组中的数字依次异或,那么得到的最后的数字就是只出现一次的数字。
那么对于两个只出现一次的数字该怎么处理呢,我们把数组分成两部分,每部分均只包括一个出现一次的数字和一些出现两次的数字,那么分别对这两个数组求只出现一次的数
字就能找到原数组中只出现一次的两个数字。那么问题就在于,该怎么将原数组分成两个数组呢?原数组中每个元素分别异或后,得到的结果必不为0,因为这相当于两个不同
的数字异或的结果,我们找到这个结果的第一个非0位,设为第n位,那么这两个数字在第n位肯定不同,同理可以将原数组根据第n位是否为零分为两部分,那些出现两次的数
字肯定都在同一个数组中,这样对着两个数组依次异或就能找到这两个数字了。
代码:
void findNumbersAppearOnce(int[] data,int length,int * num1,int * num2){
if(data == NULL || length < 2)
return;
int resultOfXor = 0;
for(int i = 0; i < length; i++)
resultOfXor = resultOfXor ^ A[i];
unsigned int indexOf1 = findFirstBitIs1(resultOfXor);
*num1 = *num2 = 0;
for(int j = 0;j < length;j++){
if(IsBit1(data[j],indexOf1))
*num1 ^= data[j];
else
*num2 ^= data[j];
}
}
unsigned int findFirstBitIs1(int num){
int indexBit = 0;
while((num & 1) == 0 && (indexBit < 8 * sizeof(int))){
num = num >> 1;
indexBit++;
}
return indexBit;
}
bool IsBit1(int num,unsigned int indexBit){
num = num >> indexBit;
return (num & 1);
}
bool findNumbersAppearOnce(int * A,int length,int * nOne,int * nTwo){
if(A == NULL || length < 2)
return false;
int resultOfXor = 0;
for(int i = 0; i < length; i++)
resultOfXor = resultOfXor ^ A[i];
if(resultOfXor == 0)
return false;
int j = 1;
int positionOfOne = 0;
do{
int temp = resultOfXor & j;
positionOfOne++;
j << 1;
}while(temp == 0)
for(i = 0; i < length;i++){
if(A[i] & j)
nOne = nOne ^ A[i];
else
nTwo = nTwo ^ A[i];
}
return true;
}
八、和为s的两个数
输入一个整数数组和一个整数,从数组中找出两个数使其和为整数,找到一组就可以。
思路分析:我们选择两个数,小的为small,大的为big。如果两个数的和正好为s,那么我们就找到了要找的数字。如果两个数的和小于s,那么我们可以选择small后面的数
字,因为排在后边的数字更大一点。反之,我们选big前面的数字,因为排在前面的数字更小一点。然后再对新数字相加并比较和s的大小关系。
代码:
bool findTwoNumbers(int[] A,int length,int sum,int * num1,int * num2){
if(A == NULL || length < 1 || num1 == NULL || num2 == NULL)
return false;
int pSmall = 0;
int pBig = length - 1;
int flag = false;
while(pSmall < pBig){
if(A[pSmall] + A[pBig] == sum){
*num1 = A[pSmall];
*num2 = A[pBig];
flag = true;
break;
}else if(A[pSmall] + A[pBig] < sum){
pSmall++;
}else{
pBig--;
}
}
return flag;
}
用两个数small和big分别表示序列的最小和最大值,首先small初始化为1,big初始化为2,如果从small到big的序列的和大于s,我们可以从序列中去掉较小的值,也就是增大
small的值,反之,增大big的值。因为序列要最少两个数,而且是连续的,所有big最大不会超过输入数的一半,而且small要比big小才可以。
代码:
void printSequence(int num){
int small = 1;
int big = 2;
int bigMax = (num + 1)/2;
int sum = small + big;
while(small < big && big <= bigMax){
if(sum == num){
System.out.print("a sequence is: ");
for(int i = small;i < big;i++){
System.out.print(i + ",");
}
System.out.print(big + "\n");
big++;
sum += big;
}
else if(sum < num){
big++;
sum += big;
}else{
sum-=small;
small++;
}
}
}
再延伸:快速找出一个数组中的三个数,让这三个数之和等于一个给定的值。
void (int A[],int length,int &num1,int &num2,int &num3,int sum){
int i,j,k;
for(k = 0; k < length;k++){
int subSum = sum - A[k];
i = 0;
j = length - 1;
if(i == k)
i++;
if(j == k)
j--;
while(i < j){
int sumOfIandJ = A[i] + A[j];
if(sumOfIandJ == subSum){
num1 = A[i];
num2 = A[j];
num3 = A[k];
return;
}
else if(sumOfIandJ < subSum)
i++;
else
j--;
}
}
}
九、调整数字顺序使奇数位于偶数前面
输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有奇数位于数组的前半部分,所有偶数位于数组后半部分。
思路:定义两个指针pBegin和pEnd,初始化为指向数组第一个元素和最后一个元素,如果pBegin指向的元素为奇数那么将其继续后移直至找到一个偶数元素,同理移动pEnd直至找到一个奇数元素,然后交换两个元素的位置;重复上面的操作,直到pBegin > pEnd;
代码如下:
void reOrderOddEven(int * data,unsigned int length){
if(data == NULL || length == 0)
return;
int * pBegin = data;
int * pEnd = data + length - 1;
while(pBegin < pEnd){
//判断一个数是不是奇偶数的另一种方法,看最后一位是不是1,
//(*pBegin & 0x1 != 0)
while((*pBegin)/2 != 0 && pBegin < pEnd)
pBegin++;
while((*pEnd)/2 == 0)
pEnd--;
if(pBegin < pEnd){
int temp = *pBegin;
*pBegin = *pEnd;
*pEnd = temp;
pBegin++;
pEnd--;
}
}
}
代码如下:
void reOrderOddEven(int * data,unsigned int length){
reOrderOddEven(data,length,isOdd);
}
void reOrderOddEven(int * data,unsigned int length,bool (*fun)(int)){
if(data == NULL || length == 0)
return;
int * pBegin = data;
int * pEnd = data + length - 1;
while(pBegin < pEnd){
//判断一个数是不是奇偶数的另一种方法,看最后一位是不是1,
//(*pBegin & 0x1 != 0)
while(fun(*pBegin) && pBegin < pEnd)
pBegin++;
while(!fun(*pEnd) && pBegin < pEnd)
pEnd--;
if(pBegin < pEnd){
int temp = *pBegin;
*pBegin = *pEnd;
*pEnd = temp;
pBegin++;
pEnd--;
}
}
}
bool isOdd(int n){
return (n & 0x1) != 0;
}