数组

一、数组与指针

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













  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值