数组

一、数组与指针

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;
}

方法三：如果一个数出现的次数在一半以上，那么它出现的次数比其它的数出现的次数的和还要多。我们可以定义一个标识某元素result出现次数的变量times，如果后面出现

的元素与该元素不同，那么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);
}

方法二：怎么找一个最大数组呢？无非就是确定左下标和右下标，让其中的元素之和最大。怎么确定左下标呢，先设一个变量记录综合sum，我们从第一个元素开始开始递归相

加，在加到元素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;
}

延伸：输入一个整数s，打印所有和为s的连续正数序列（至少有两个数）。

用两个数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--;
        }
    }
}

功能拓展，我们来看以下几个问题，如果我们是把负数都放到数组前面，整数放到数组后面，或者把能被3整除的数放到数组前面，不能被3整除的数放到数组后面，那么我们该如何做呢，我们只需要改变函数中的判断逻辑即可。那有没有办法将这部分判断逻辑提取出来成为一个单独的部分呢？

代码如下：

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;
}