剑指offer：数组

1、二维数组中的查找

题目描述：

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

解题思路：

根据题目描述我们可以得知：每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。有两种方法：从二维数组的右上角或者左下角开始查找。

方法一：从二维数组的右上角开始查找

如果该数字等于要查找的数字，则查找过程结束；如果该数字大于要查找的数字，则说明该列其他元素都大于要查找的数字，便可以删掉该列；如果该数字小于要查找的数字，则说明该行其他元素也都小于要查找的数字，便可以删掉该行。

每一次比较都可以剔除一行或者一列，进而缩小查找范围。

代码实现：

public class Solution {public boolean Find(int target, int [][] array) {if(array == null)return false;int r = array.length;int c = array[0].length;int i = 0,j = c-1;for(;i<r&&j>=0;){if(array[i][j] == target)return true;else if(array[i][j]<target)i++;elsej--;}return false;}
}

方法二：从二维数组的左下角开始查找

如果该数字等于要查找的数字，则查找过程结束；如果该数字大于要查找的数字，则说明该行其他元素都大于要查找的数字，便可以删掉该行；如果该数字小于要查找的数字，则说明该列其他元素也都小于要查找的数字，便可以删掉该列。

代码实现：

public class Solution {public boolean Find(int target, int [][] array) {if(array == null)return false;int r = array.length;int c = array[0].length;int i = r-1,j = 0; for(;i>=0&&j<c;){if(array[i][j] == target)return true;else if(array[i][j]>target)i--;elsej++;}return false;}
}

知识点：

在一维数组a[ ]中，a.length 方法的意思就是返回这个数组的长度。
比如a[ ] = {1,2,3,4,5}；则a.length = 5；

在二维数组b[ ][ ]的length方法代表着什么呢？
在二维数组中，如果直接调用b.length方法，返回的则是b数组的行数。
如果是b[0].length方法则返回的是第0行所代表的长度。

如果说每个一维数组的长度相同，那么b[0].length就是列数了。

2、旋转数组的最小数字

题目描述：

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。注意：给出的所有元素都大于0，若数组大小为0，请返回0。

解题思路：

1.你可以直接对数组进行遍历找到最小值(这肯定不是这道题目的意义啊)

2.使用二分的方法

方法一：直接对数组进行遍历

代码实现：


import java.util.ArrayList;
public class Solution {public int minNumberInRotateArray(int [] array) {int m = array[0];for(int sum:array){if(sum<m)m = sum;}return m;}
}

方法二：二分查找

详细思路：如果整个数组是有序的，那我们一定会想到用折半查找来实现。对于旋转数组，我们发现，它实际上可以划分为两个排序的子数组，而且前面数组的元素都不小于后面数组的元素，并且最小值正好就是这两个数组的分界线，由此，我们可以得出以下解决方法。

首先用两个指针b和e分别指向数组的第一个元素和最后一个元素，然后可以找到中间元素mid。对于这个中间元素，有以下两种情况：（1）该元素大于等于b指向的元素，此时最小的元素说明在mid的后面，可以把b=mid；（2）中间元素小于等于e指向的元素，那么最小元素在mid之前，可以e=mid。特别注意：这里不要+1或者-1，因为只有这样才能保证b始终在第一个数组，e始终在第二个数组。依次循环，当最后b和e相差1时，b指向第一个数组的最后一个，e指向第二个数组的第一个（即为我们要找的最小值）。

当然，还需要有特殊情况的判断：

1、将数组前0个元素移动到后面（相当于没有旋转，数组整体有序）。明显我们上面的分析没有包含这种情况，需要特殊处理，方法也很简单，将第一个元素和最后一个元素相比，若第一个元素小于最后一个元素，则说明最小值就是的第一个元素，可以直接返回。

2、首尾指针指向的数字和中间元素三者都相等时，无法判断中间元素位于哪个子数组，无法缩小问题规模。此时，只能退而求其次，进行顺序查找。

代码实现：

import java.util.ArrayList;
public class Solution {public int minNumberInRotateArray(int [] array) {int n = array.length;if(n==0)return 0;int b = 0,e = array.length-1;if(array[0]<array[n-1])return array[0];while(b<e){int mid = b+(e-b)/2;if(array[b] == array[mid]&&array[e] == array[mid])return minsort(array);if(array[mid]>=array[b])b = mid;else if(array[mid]<=array[e])e = mid;if(e-b == 1)return array[e];}return -1;}int minsort(int [] array){int m = array[0];for(int sum:array)if(sum<m)m = sum;return m;}
}

说明：

在这里没有使用到import java.util.ArrayList;

3、调整数组顺序使奇数位于偶数前面

题目描述：

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

解题思路：

对数组进行遍历，设置两个指针begin和end，begin指向当前第一个偶数，end从这个偶数之后开始查找，找到第一个奇数，此时为了相对位置不变，不能直接交换begin和end，而是将从begin到end-1的元素都依次向后移一个位置，将end指向的那个奇数放到begin的位置。然后再找下一个偶数，重复这一过程，最终就可以将奇数都放到偶数的前面，并且保证了相对位置的不变。

代码实现：

import java.util.*;public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param array int整型一维数组 * @return int整型一维数组*/public int[] reOrderArray (int [] array) {// write code hereint len = array.length;int begin = 0,end = 0;while(begin<len&&end<len){while(begin<len&&array[begin]%2!=0)begin++;end = begin+1;while(end<len&&array[end]%2==0)end++;if(end>=len)break;int temp = array[end];int i = 0;for(i = end;i>begin;i--){array[i] = array[i-1];}array[begin] = temp;begin++;   }return array;}
}

知识点：

如果不考虑奇数和奇数，偶数和偶数的相对位置，那么我们有一种双指针解法来求解，类似于快排，维护两个指针，第一个指针指向数组的第一个数字，第二个指针指向数组的最后一个数字。第一个指针向后移，第二个指针向前移，如果第一个指针指向偶数，第二个指针指向的是奇数，则交换着两个数字，接着继续移动直到两指针相遇。

4、顺时针打印矩阵

题目描述：

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X4矩阵： 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.

解题思路：

由于是按照从外到内的顺序依次打印，所以可以把矩阵想象成若干个圈，用一个循环来打印矩阵，每次打印矩阵中的一圈。

假设矩阵的行数是r，列数是c，则每次都是从左上角开始遍历，而我们注意到左上角行标和列标总是相同的，假设是start，那么循环继续的条件就是r>start * 2 && c > start * 2。

而对于每一圈的打印，很自然便可以想到遵循从左到右，从上到下，从右到左，从下到上的顺序。(其中，从右到左和从下到上需要判断)但是这里需要注意的是最后一圈的打印，由于矩阵并不一定是方阵，最后一圈有可能退化为只有一行，只有一列，甚至只有一个数，因此要注意进行判断，避免重复打印。

代码实现：

import java.util.ArrayList;
public class Solution {public ArrayList<Integer> printMatrix(int [][] matrix) {ArrayList<Integer> sum = new ArrayList<Integer>();int r = matrix.length;int c = matrix[0].length;if(r == 0)return sum;int start = 0;for(start = 0;r>start*2&&c>start*2;start++){int endx = r - start - 1;int endy = c - start - 1;for(int j = start;j<=endy;j++)sum.add(matrix[start][j]);for(int j = start+1;j<=endx;j++)sum.add(matrix[j][endy]);if(endx>start)for(int j = endy-1;j>=start;j--)sum.add(matrix[endx][j]);if(endy>start)for(int j = endx-1;j>start;j--)sum.add(matrix[j][start]);}return sum;}
}

知识点：(从0开始)

从左到右：

开始于[start,start]，结束于[start,c-start-1]

从上到下：

开始于[start+1,c-start-1],结束于[r-start-1,c-start-1]

从右到左：

开始于[r-start-1,c-start-2],结束于[r-start-1,start]

从下到上：

开始于[r-start-2,start],结束于[start+1,start]

5、数组中出现次数超过一半的数字

题目描述：

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如：输入如下所示的一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

解题思路：

数组中有一个数字出现的次数超过数组长度的一半，也就是说它出现的次数比其他所有数字出现的次数之和还要多。

因此，我们可以在遍历数组的时候设置两个值：一个是数组中的数res，另一个是出现次数times。

当遍历到下一个数字的时候，如果与result相同，则次数加1,不同则次数减1.

当次数变为0的时候说明该数字不可能为多数元素，将result设置为下一个数字，次数设为1。

这样，当遍历结束后，最后一次设置的result的值可能就是符合要求的值（如果有数字出现次数超过一半，则必为该元素，否则不存在），因此，判断该元素出现次数是否超过一半即可验证应该返回该元素还是返回0。

代码实现：

public class Solution {public int MoreThanHalfNum_Solution(int [] array) {if(array == null||array.length == 0)return 0;int len = array.length;int res = array[0];int times = 1;for(int i=1;i<len;i++){if(times == 0){res = array[i];times = 1;//continue;//有没有都可以跑过去}if(res == array[i])times++;elsetimes--;}times = 0;for(int i = 0;i<len;i++){if(array[i] == res)times++;if(times>=(len/2))return res;}return 0;}
}

注意：重要的不是次数而是找到那个数字。

6、连续子数组的最大和

题目描述：

在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？

例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)。

解题思路：

本题可以看做是一个多阶段决策找最优解的问题，因此可以用典型的动态规划思想来求解。用 res[ i ] 表示以第 i 个元素结尾的子数组的最大和，那么有以下递推公式：

res[ i ]=max(res[ i-1]+data[ i ],data[ i ]).

这个公式的含义是：当以第i-1个数字结尾的子数组中所有数字的和小于0时，把这个负数与第i个数累加，则得到的和比第i个数字本身还要小，所以这种情况下res[ i ]就是第i个数字本身。反之，如果以第i-1个数字结尾的子数组中所有数字的和大于0，则与第i个数字累加就得到以第i个数字结尾的子数组中所有数字的和。

代码实现：

public class Solution {public int FindGreatestSumOfSubArray(int[] array) {if(array == null||array.length == 0)return 0;int res = array[0];int data = res;for(int i = 1;i<array.length;i++){res = (res+array[i])>array[i]?(res+array[i]):array[i];if(res>data)data = res;}return data;}
}

知识点：

动态规划，用res[i]表示以第i个元素结尾的最大和

res[i]中最大者即为最大连续子序列的和

7、把数组排成最小的数

题目描述：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

解题思路：

本题实际上希望我们找到一个排序规则，数组根据这个排序规则进行重排之后可以连成一个最小的数字。要确定这样的排序规则，也就是对于两个数字m和n，通过一个规则确定哪个应排在前面。根据题目要求，我们可以发现，两个数字m和n能拼接成mn和nm，如果mn<nm，那m应该在前；如果nm<mn，那么n应该在前。因此，我们得到的排序规则如下：

若mn>nm，则m大于n

若mn<nm，则m小于n

若mn=nm，则m等于n

根据上述规则，我们需要先把数字转换成字符串再进行比较，因为需要拼接起来。比较完之后按顺序连接成一个字符串即可。

代码实现：

import java.util.*;public class Solution {class comparestr implements Comparator<String>{@Overridepublic int compare(String m,String n){String mn = m + n,nm = n + m;return mn.compareTo(nm);}}public String PrintMinNumber(int [] numbers) {String res = "";if(numbers == null || numbers.length == 0)return res;int len = numbers.length;    String[] sum = new String[len];for(int i=0;i<len;i++)sum[i] = String.valueOf(numbers[i]);comparestr c = new comparestr();Arrays.sort(sum,c);for(String n:sum)res+=n;return res;}
}

8、数组中的逆序对

题目描述：

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007。

解题思路：

首先将数组分隔成子数组，统计出子数组内部逆序对数目，然后再统计相邻子数组之间的逆序对数目，统计过程中还需要对数组进行排序，这实际上就是归并排序的过程。主要考虑的是合并两个有序序列时，计算逆序对数。对于两个有序升序序列，设置两个下标分别指向开始位置，每次比较两个指针对应的值，如果第一个序列当前值大于第二个序列当前值，则有第一个序列“当前长度”个逆序对。

代码实现：

public class Solution {int res = 0;public int InversePairs(int[] array) {if(array == null||array.length == 0)return 0;findnxd(array,0,array.length-1);return res%1000000007;}public void findnxd(int[] array,int begin,int end){if(begin<end){int mid = begin+(end-begin)/2;findnxd(array,begin,mid);findnxd(array,mid+1,end);merge(array,begin,mid,end);}return ;}public void merge(int[] array,int begin,int mid,int end){int i = begin,j = mid+1;int[] temp = new int[end-begin+1];int k = 0;while(i<=mid&&j<=end){if(array[i]<=array[j]){temp[k++] = array[i++];}else{temp[k++] = array[j++];res+=(mid-i+1);res%=1000000007;}}while(i<=mid)   temp[k++] = array[i++];while(j<=end)   temp[k++] = array[j++];for(int m=0;m<temp.length;m++)array[begin+m] = temp[m];return ;}
}

9、数字在升序数组中出现的次数

题目描述：

统计一个数字在排序数组(升序数组)中出现的次数。例如，输入排序数组{1,2,3,3,3,3,4,5}和数字3，由于数字3在该数组中出现了4次，所以函数返回4。

解题思路1：

首先，这道题目可以直接设置一个计数变量，然后遍历一遍数组元素，输出计数变量即可。

public class Solution {public int GetNumberOfK(int [] array , int k) {int t = 0;for(int i=0;i<array.length;i++)if(array[i] == k)t++;return t;}
}

但是这样做，啥技术含量都没有。

解题思路2：第一个k出现的位置和最后一个k出现的位置。

以第一个k出现的位置为例，利用二分查找算法可以直接对数组进行二分，而每次总是拿中间的数字和k做比较，如果中间的数字大于k，那么第一个k只有可能出现在左边，下一次直接在数组左半段继续进行二分查找；如果中间的数字小于k，则第一个k只有可能出现在右边，则在右半段再查找；如果中间的数字等于k，我们先判断它前面的一个数字是不是k，如果不是，那么这个中间的数字就是第一个出现的位置，反之，如果中间数字前面的数字是k，那么第一个k仍然在前半段，继续查找。

易错点：

int mid = begin+(end-begin)/2;需要在循环当中，每次重新定义。

代码实现：

public class Solution {public int GetNumberOfK(int [] array , int k) {int ffind = getindex1(array,k);int sfind = getindex2(array,k);if(ffind == -1||sfind == -1)return 0;return (sfind-ffind+1);}public int getindex1(int[] array,int k){int res = -1; int begin = 0,end = array.length-1;//int mid = begin+(end-begin)/2;if(array==null||array.length==0)return res;  while(begin<=end){int mid = begin+(end-begin)/2;if(array[mid]<k){begin = mid+1;}else if(array[mid]>k){end = mid-1;}else{mid = mid-1;if(mid<begin||array[mid]!=k)return mid+1;elseend = mid;}}return res;}public int getindex2(int[] array,int k){int res = -1;  int begin = 0,end = array.length-1;//int mid = begin+(end-begin)/2;if(array==null||array.length==0)return res;while(begin<=end){int mid = begin+(end-begin)/2;if(array[mid]<k){begin = mid+1;}else if(array[mid]>k){end = mid-1;}else{mid = mid+1;if(mid>end||array[mid]!=k)return mid-1;elsebegin = mid;}}return res;}
}

锦上添花：特判

if(array==null||array.length==0)

return res;

10、数组中只出现一次的数字

题目描述：

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度为O(n)，空间复杂度为O(1)。

解题思路：

如果数组中只有一个数字出现一次，其他都出现两次。那么我们应该可以想到异或运算。异或运算有一个比较好的性质是：相同为0，相异为1。也就是说，任何一个数字异或它自己都等于0，而0异或任何数都等于那个数。因此，我们从头到尾依次异或数组中的每个数字，那么最终结果刚好是那个只出现一次的数字，重复的数字在异或过程中被抵消了。这是一种比较巧妙的思路，然而，本题只出现一次的数字有两个，简单的异或无法解决。但是，借助这种思路，我们可以进一步分析，如果我们能把数组分成两个子数组，使每个子数组包含一个只出现一次的数字，而其他数字成对出现，那么我们通过上述解法就可以找到两个元素。

也就是说：

我们首先仍然从前向后依次异或数组中的数字，那么得到的结果是两个只出现一次的数字的异或结果，其他成对出现的数字被抵消了。由于这两个数字不同，所以异或结果肯定不为0，也就是这个异或结果一定至少有一位是1，我们在结果中找到第一个为1的位的位置，记为第n位。接下来，以第n位是不是1为标准，将数组分为两个子数组，第一个数组中第n位都是1，第二个数组中第n位都是0。这样，便实现了我们的目标。最后，两个子数组分别异或则可以找到只出现一次的数字。

public class Solution {public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {if(array==null||array.length<2)return ;int res=0;for(int num:array) //数组中的元素先依次异或，相同为0，则得到的是两个只出现一次的数的异或结果res ^= num;int index=0; //找到其第一个为1的位for(;index<32;index++){if(((res>>index) & 1)==1)break;}num1[0]=0;num2[0]=0;for(int num:array){ //按照该位是0还是1将数组分成两部分,分别异或if(((num>>index)&1)==1)num1[0] ^= num;elsenum2[0] ^= num;}}
}

举个例子：

比如说：{2,4,3,6,3,2,5,5} 我们依次对数组中的每个数字做异或运行之后，得到的结果用二进制表示是0010。异或得到结果中的倒数第二位是1，于是我们根据数字的倒数第二位是不是1分为两个子数组。第一个子数组{2,3,6,3,2}中所有数字的倒数第二位都是1，而第二个子数组{4,5,5}中所有数字的倒数第二位都是0。接下来只要分别两个子数组求异或，就能找到第一个子数组中只出现一次的数字是6，而第二个子数组中只出现一次的数字是4。

补充一下：(牛客网输出改编版)

import java.util.*;public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param array int整型一维数组 * @return int整型一维数组*/public int[] FindNumsAppearOnce (int[] array) {// write code hereint[] num = new int[2];if(array == null||array.length<2)return num;int res = 0;for(int sum:array)res^=sum;int index = 0;for(;index<32;index++)if(((res>>index)&1)==1)break;num[0] = 0;num[1] = 0;for(int sum:array){if(((sum>>index)&1)==1)num[0]^=sum;elsenum[1]^=sum;}Arrays.sort(num);return num;}
}

11、数组中重复的数字

题目描述：

在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

解题思路：

当然，我们可以先去把数组从小到大排序一下，然后相邻的两个比较一下，如果相等，直接退出循环，返回该值即可。

import java.util.*;public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param numbers int整型一维数组 * @return int整型*/public int duplicate (int[] numbers) {// write code hereint t = 0;if(numbers == null||numbers.length == 0)return -1;Arrays.sort(numbers);for(int i=0;i<numbers.length;i++){if(numbers[i]==numbers[i+1]){t = numbers[i];break;}}return t;}
}

但是，还是那句话：“没有技术含量。”

所以说：使用数组重排

解题思路：

由于题目中告诉我们所有的数字都在0到n-1的范围内，因此如果没有重复，那么所存储的值也正好是0到n-1这n个数字，我们把原数组重新排列为一个元素和对应下标值相同的数组。

从头到尾扫描整个数组中的数字，当扫描到下标为i的数字时，首先比较这个数字（用m表示）是不是等于下标i，如果是，接着比较下一个数字；如果不是，则将其与第m个数字比较，若与第m个数字相同，则说明它就是一个重复数字，如果不同，就将其与第m个数字进行交换，也就是把它放到自己应在的位置去。重复这个过程，直到该位置上的数与下标相同为止。

import java.util.*;public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param numbers int整型一维数组 * @return int整型*/public int duplicate (int[] numbers) {// write code hereint t = -1;if(numbers == null||numbers.length<2)return t;for(int i=0;i<numbers.length;i++){while(numbers[i]!=i){if(numbers[numbers[i]]==numbers[i]){t = numbers[i];return t;}else{int temp = numbers[numbers[i]];numbers[numbers[i]] = numbers[i];numbers[i] = temp;}}}return t;}
}

12、构造乘积数组

题目描述：

给定一个数组 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]（除 A[i] 以外的全部元素的的乘积）。程序中不能使用除法。（注意：规定 B[0] = A[1] * A[2] * ... * A[n-1]，B[n-1] = A[0] * A[1] * ... * A[n-2]）

对于 A 长度为 1 的情况，B 无意义，故而无法构建，用例中不包括这种情况。

代码实现：只需要不乘以A[i]就可以

import java.util.ArrayList;
public class Solution {public int[] multiply(int[] A) {int[] B = new int[A.length];if(A == null||A.length == 0)return B;int t = 0;for(int i=0;i<A.length;i++){int sum = 1;for(int j = 0;j<A.length;j++){if(j == i)continue;elsesum*=A[j];}B[t++] = sum;}return B;}
}

剑指offer：数组相关推荐

8. 返回数组里出现次数最多的数字_剑指offer 数组中出现次数超过一半的数字
题目描述数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字.例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}.由于数字2在数组中出现了5次,超过数组长度的一半,因此输出2. ...
剑指offer:数组中重复的数字
题目描述在一个长度为n的数组里的所有数字都在0到n-1的范围内. 数组中某些数字是重复的,但不知道有几个数字是重复的.也不知道每个数字重复几次.请找出数组中任意一个重复的数字. 例如,如果输入长度为 ...
[剑指offer] 数组中只出现一次的数字
本文首发于我的个人博客:尾尾部落题目描述一个整型数组里除了两个数字之外,其他的数字都出现了偶数次.请写程序找出这两个只出现一次的数字. 解题思路法一:大家都能想到的HashMap法法二:异或法 ...
【排序】剑指offer:数组中重复的数字
对数组进行排序,然后遍历判断,如果两个数相等,那么这两个数一定相邻代码: class Solution { public:int duplicate(vector<int>& n ...
python剑指offer数组中出现次数超过一半的数字
题目描述数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字.例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}.由于数字2在数组中出现了5次,超过数组长度的一半,因此输出2. ...
剑指offer 数组中的逆序对
题目描述在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对.输入一个数组,求出这个数组中的逆序对的总数P.并将P对1000000007取模的结果输出. 即输出P%1000 ...
剑指offer 数组中的逆数对
链接:https://www.nowcoder.com/profile/8740530/codeBookDetail?submissionId=9156674 来源:牛客网class Solution ...
剑指offer：数组中的逆序对
题目描述在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对.输入一个数组,求出这个数组中的逆序对的总数P.并将P对1000000007取模的结果输出. 即输出P%1000 ...
[剑指Offer]5.二维数组中的查找
题目在一个二维数组中,每一行都依照从左到右递增的顺序排序,每一列都依照从上到下递增的顺序排序.请完毕一个函数,输入这种一个二维数组和一个整数.推断数组中是否含有该整数. 思路 [算法系列之三十三]杨 ...
《LeetCode力扣练习》剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 Java
<LeetCode力扣练习>剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 Java 一.资源题目: 输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有奇数在数组 ...

剑指offer：数组

剑指offer：数组相关推荐

最新文章

热门文章