剑指offer解题思路总结(持续更新记录）
数组篇
二维数组中的查找
题目描述：
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解题思路：
1.暴力求解法
- 两层for循环+判断相等条件
- 时间复杂度为O(m*n)
2.巧妙解题
- 查找规律 利用二分的思想解决问题
- 每一行都是从左到右依次递增的情况
- 先遍历一层循环，在第二层循环时，利用二分思想，令low=0，high=array[i].length-1;
- 最后判断目标数的位置
- 时间复杂度为O(m*logn)
3.继续查找规律
- 每一行从左到右依次递增，从上到下依次递增，那么我们可以从左下到右上解决问题
- 令i=array.length,j=0;
- 来个while循环，判断条件是：i>=0&&j
- 在while循环里写定判断条件，当前数比目标数小就，j++；当前数比目标数大就，i–；
- 直到找到该数。
- 时间复杂度为O(m+n)
代码实现：
package com.zcl.offer.数组;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/8 9:47
*/
public class 二维数组中的查找 {
/**
* 暴力解决法
* 时间复杂度O(mn)
* @param target 目标元素
* @param array 数组
* @return
*/
public boolean Find(int target, int [][] array) {
if(array==null||array.length==0||(array.length==1&&array[0].length==0)){
return false;
}
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){
if(target==array[i][j]){
return true;
}
}
}
return false;
}
/**
* 查找规律
* 时间复杂度O(mlogn)
* @param target 目标元素
* @param array 数组
* @return
*/
public boolean Find1(int target,int [][]array){
if(array==null||array.length==0||(array.length==1&&array[0].length==0)){
return false;
}
for(int i=0;i<array.length;i++){
int begin = 0;
int end = array[0].length-1;
while(begin<=end){
int mid = (begin+end)>>1;
if(array[i][mid]<target){
begin = mid+1;
}else if (array[i][mid]>target){
end = mid-1;
}else{
return true;
}
}
}
return false;
}
/**
* 从左下开始，往右上的方向查找元素
* 时间复杂度O(m+n)
* @param target
* @param array
* @return
*/
public boolean Find2(int target,int [][]array){
if(array==null||array.length==0||(array.length==1&&array[0].length==0)){
return false;
}
int i = array.length-1;
int j = 0;
while(i>=0&&j<array[i].length){
if(array[i][j]<target){
j++;
}else if(array[i][j]>target){
i--;
}else{
return true;
}
}
return false;
}
}
旋转数组中的最小元素
题目描述：
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
解题思路：
看到这个题，还是先想到二分思想
举个例子：
3->4->5->1>2
假如是这样一个数组，令low=0；high=array.length-1;仔细观察不难发现，low指向的元素一定比high指向的元素要大
- 来一个while循环 结束条件为 low>=high while循环块里需要完成以下工作
- 1、如果low+1==high；说明low指向的是数组第一部分递增子序列的最后一个元素，high指向的是数组第二部分递增子序列的第一个元素，那么显而易见high指向的元素就是最小元素，并把它返回
- 2、接下来又是二分了，声明一个int型的变量mid，将(low+high)>>1赋值给mid；判断如果array[low]
- 3、还有一种情况就是 当中间值等于两边值得话，程序并不知道mid属于谁，那么就应该遍历low-high这一段得元素了，选择最小值返回；
- 时间复杂度最好是O(log n) 最差是O(n)
代码实现：
package com.zcl.offer.数组;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/8 11:08
*/
public class 旋转数组中的最小元素 {
public int minNumberInRotateArray(int [] array){
if(array==null || array.length<=0){
return 0;
}
int i = 0;
int j = array.length-1;
while(i<j){
if(i+1==j){
return array[j];
}
int mid = (i+j)>>1;
if(array[mid]>array[i]){
i = mid;
}else if(array[mid]<array[j]){
j=mid;
}else{
return minNum(array,i,j);
}
}
return array[0];
}
private int minNum(int []array,int low,int high){
int temp = array[low];
for(int i=low;i<=high;i++){
if(temp>array[i]){
temp = array[i];
}
}
return temp;
}
public static void main(String[] args) {
System.out.println(new 旋转数组中的最小元素().minNumberInRotateArray(new int[]{3,4,5,1,2}));
}
}
数组中得重复元素
题目描述：
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
解题思路：
1.暴力求解法
- 两层for循环，找出第一个重复的元素，将其放入到给定数组中去并返回
- 时间复杂度为O(n2)
2.设置一个boolean数组标记法
- 因为题目中说了，数组里的数字都在0到n-1的范围内，所以声明一个boolean数组，给开n个空间；
- 一层for循环，循环块里的任务是 判断boolean数组中的真假情况
- 如果为真，把当前boolean索引值给目标数组并返回
- 时间复杂度O(n)
3.声明一个hashset集合
- 一层for循环，将数组中的元素放入到集合中，每次放入之前先判断集合中有无该元素，如果有，就把该元素放入目标数组中并返回，无的话，就继续添加
- 时间复杂度O(n)
代码实现：
package com.zcl.offer.数组;
import java.util.HashMap;
import java.util.HashSet;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/8 10:27
*/
public class 数组中重复的数字 {
/**
* 暴力解决法
* 时间复杂度O(m2)
* @param numbers
* @param length
* @param duplication
* @return
*/
public boolean duplicate(int numbers[],int length,int [] duplication) {
if(numbers==null||length<=1){
return false;
}
for(int i=0;i<length-1;i++){
for(int j=i+1;j<length;j++){
if(numbers[j]==numbers[i]){
duplication[0] = numbers[i];
return true;
}
}
}
return false;
}
/**
* 根据题意 设置boolean数组解决问题
* 时间复杂度O(n)
* @param numbers
* @param length
* @param duplication
* @return
*/
public boolean duplicate1(int numbers[],int length,int [] duplication) {
if(numbers==null || length<=1){
return false;
}
boolean[] flag = new boolean[length];
for(int i=0;i<flag.length;i++){
if(flag[numbers[i]]){
duplication[0] = numbers[i];
return true;
}
flag[numbers[i]]=true;
}
return false;
}
public boolean duplicate2(int numbers[],int length,int [] duplication) {
if(numbers==null || length<=1){
return false;
}
HashSet<Integer> hashSet = new HashSet<>();
for(int i=0;i<length;i++){
if(hashSet.contains(numbers[i])){
duplication[0] = numbers[i];
return true;
}
hashSet.add(numbers[i]);
}
return false;
}
}
调整数组顺序使得奇数位于偶数前面
题目描述：
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
解题思路：
用空间换时间：
- 遍历一次数组，统计出数组中奇数的个数和偶数的个数
- 声明两个数组，并分配相应的空间以来存放对应的偶数和奇数
- 然后再遍历一次原来的数组，把奇数数组先放入原来数组，再把偶数数组后放入原来数组
- 时间复杂度为O(n)
- 空间复杂度为O(n)
省去空间
- while循环遍历数组，标记第一次出现偶数的位置，记录其索引值
- 然后从此位置的下一个索引位置出发，标记第一次出现奇数的位置，记录其索引值
- 交换两个值。
- 重复以上步骤，直至所有数交换完成
- 时间复杂度为O(n2)
- 空间复杂度为O(1)
代码实现：
package com.zcl.offer.数组;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/11 8:54
*/
public class 调整数组顺序使奇数位于偶数前面 {
/**
* 暴力解决法
* 时间复杂度位O(n)
* @param array
*/
public void reOrderArray(int []array){
if(array==null){
return ;
}
int even = 0,odd=0;
for(int i=0;i<array.length;i++){
if(array[i]%2==0){
even++;
}else{
odd++;
}
}
int []evenNum = new int[even];
int []oddNum = new int[odd];
int indexEven = 0;
int indexOdd = 0;
for(int i=0;i<array.length;i++){
if(array[i]%2==0){
evenNum[indexEven++] = array[i];
}else{
oddNum[indexOdd++] = array[i];
}
}
int index = 0;
for(int i=0;i<array.length;i++){
if(index<indexOdd){
array[i] = oddNum[index++];
}else{
array[i] = evenNum[index++-indexOdd];
}
}
}
public void reOrderArray1(int []array){
if(array==null || array.length<=0){
return ;
}
int arrL=0,arrR;
while(arrL<array.length){
while(arrL<array.length && array[arrL]%2!=0){
arrL++;
}
arrR = arrL+1;
while(arrR<array.length && array[arrR]%2==0){
arrR++;
}
if(arrR<array.length){
int temp = array[arrR];
for(int i=arrR-1;i>=arrL;i--){
array[i+1] = array[i];
}
array[arrL] = temp;
}else{
break;
}
}
for(int i=0;i<array.length;i++){
System.out.print(array[i]+" ");
}
}
public static void main(String[] args) {
new 调整数组顺序使奇数位于偶数前面().reOrderArray1(new int[]{1,2,3,4,5});
}
}
数组中出现次数超过一半的数字
题目描述：
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
解题思路：
- 对数组进行排序，并找出中间数字(ps：如果数组中出现符合条件的数字，那么它一定是中间的那个数字)
- 遍历数组，统计中间数字出现的次数
- 如果次数超半，则返回该数字，否则返回0
代码实现：
package com.zcl.offer.数组;
import java.util.Arrays;
import java.util.Collections;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/11 9:52
*/
public class 数组中出现次数超过一半的数字 {
/**
* 该数超过一半，那么排序后中间那个数一定是这个数
* 时间复杂度为O(n)
* @param array
* @return
*/
public int MoreThanHalfNum_Solution(int [] array) {
if(array==null || array.length<=0){
return -1;
}
Arrays.sort(array);
int number = array[array.length/2];
int sum = 0;
for(int i=0;i<array.length;i++){
if(array[i]==number){
sum++;
}
}
if(sum>array.length/2){
return number;
}else{
return 0;
}
}
}
连续子数组的最大和
题目描述：
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
解题思路：
- 声明两个变量ans，sum，ans是记录所有连续子数组中最大和的值，默认为array[0]，sum是记录当前连续子数组最大和,默认为0；
- 从数组第二个数字开始遍历数组，如果sum>0,就将当前数字加上sum，否则，就将sum=该数字。最后比较ans和sum谁大，将最大值赋给ans
- 返回ans
代码实现：
package com.zcl.offer.数组;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/11 10:28
*/
public class 连续子数组的最大和 {
/**
* 采用迭代的思想
* 时间复杂度为O(n)
* @param array
* @return
*/
public int FindGreatestSumOfSubArray(int[] array) {
if(array==null || array.length<=0){
return 0;
}
int sum = 0;
int ans = array[0];
for(int arr:array){
if(sum>0){
sum+=arr;
}else{
sum = arr;
}
ans = Math.max(sum,ans);
}
return ans;
}
public int FindGreatestSumOfSubArray1(int[] array) {
if(array==null || array.length<=0){
return 0;
}
int res = array[0];//所有连续子数组和中的最大值
int max = array[0];//当前连续子数组和的最大值
for(int i=1;i<array.length;i++){
max = Math.max(max+array[i],array[i]);
res = Math.max(max,res);
}
return res;
}
public static void main(String[] args) {
System.out.println(new 连续子数组的最大和().FindGreatestSumOfSubArray1(new int[]{6,-3,-2,7,-15,1,2,2}));
}
}
数组中的逆序对
题目描述：
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
解题思路：
归并解题
- 在归并排序中增加一个pairsNum表示逆序对个数，然后再合并时，先将最大元素放入临时数组，pairsNum = R-middle
代码实现：
package com.zcl.offer.数组;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/12 10:30
*/
public class 数组中的逆序对 {
public int InversePairs(int[] array) {
if(array==null || array.length<=1){
return 0;
}
int pairsNum = merge(array,0,array.length-1);
return pairsNum;
}
private int merge(int []array,int left,int right){
int middle = (left+right)>>1;
if(left<right){
int LeftPairs = merge(array,left,middle);
int RightPairs = merge(array,middle+1,right);
return (mergeSort(array,left,middle,right)+LeftPairs+RightPairs)%1000000007;
}
return 0;
}
private int mergeSort(int []array,int left,int middle,int right){
int L = middle;
int R = right;
int []temp = new int[right-left+1];
int index = right-left;
int pairsNum = 0;
while(L>=left && R>=middle+1){
if(array[L]>array[R]){
temp[index--] = array[L--];
pairsNum += (R-middle);
if(pairsNum>1000000007){
pairsNum = pairsNum%1000000007;
}
}else{
temp[index--] = array[R--];
}
}
while(L>=left){
temp[index--] = array[L--];
}
while(R>=middle+1){
temp[index--] = array[R--];
}
for(int i=0;i<temp.length;i++){
array[left+i] = temp[i];
}
return pairsNum;
}
public static void main(String[] args) {
int []array = new int[]{1,2,3,4,5,6,7,0};
System.out.println(new 数组中的逆序对().InversePairs(array));
}
}
把数组排成最小的数
题目描述：
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
解题思路：
Collections.sort()重写comparator方法
- 声明一个数组链表，将数组中的元素放入链表中
- 利用Collections.sort()排序数组，重写comparator方法
- 声明一个StringBuffer，将数组链表中元素按顺序添加到stringBuffer中去
- 返回stringBuffer即为题目要求的最小数。
代码实现：
package com.zcl.offer.数组;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/12 9:47
*/
public class 把数组排成最小的数 {
public String PrintMinNumber(int [] numbers) {
if(numbers==null || numbers.length<=0){
return "";
}
ArrayList<Integer> aList = new ArrayList<>();
for(int i=0;i<numbers.length;i++){
aList.add(numbers[i]);
}
Collections.sort(aList, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
String str1 = o1+""+o2;
String str2 = o2+""+o1;
return str1.compareTo(str2);
}
});
StringBuffer stringBuffer = new StringBuffer();
for(Integer integer:aList){
stringBuffer.append(integer);
}
return stringBuffer.toString();
}
public static void main(String[] args) {
int []numbers = new int[]{3,32,321};
System.out.println(new 把数组排成最小的数().PrintMinNumber(numbers));
}
}
数字在排序数组中出现的次数
题目描述：
统计一个数字在排序数组中出现的次数。
解题思路：
暴力解决法
- 遍历数组，统计目标数字出现的次数
- 时间复杂度为O(n)
二分查找解决法
- 采用递归的方式计算出该数字第一次出现在数组中的索引
- 采用迭代的方式计算出该数字最后一次出现在数组中的索引
- 最终计算出该数字在数组中出现的次数
代码实现：
package com.zcl.offer.数组;
/**
* Author:markusZhang
* VM Args:
* Date:Create in 2020/2/12 15:52
*/
public class 数字在排序数组中的出现的次数 {
/**
* 暴力解决法
* 时间复杂度为O(n)
* @param array
* @param k
* @return
*/
public int GetNumberOfK(int [] array , int k) {
if(array==null || array.length<=0){
return 0;
}
int times = 0;
for(int i=0;i<array.length;i++){
if(array[i]==k){
times++;
}
}
return times;
}
public int GetNumberOfK1(int []array,int k){
if(array==null || array.length<=0){
return 0;
}
int firstIndex = getFirstIndex(array,k,0,array.length-1);
int endIndex = getEndIndex(array,k,0,array.length-1);
int times = 0;
if(firstIndex!=-1 && endIndex!=-1){
times = endIndex - firstIndex+1;
}
return times;
}
//递归写法 得出该元素出现的首索引位置
private int getFirstIndex(int []array,int k,int start,int end){
if(start>end){
return -1;
}
int mid = (start+end)>>1;
if(k<array[mid]){
return getFirstIndex(array,k,start,mid-1);
}else if(k>array[mid]){
return getFirstIndex(array,k,mid+1,end);
}else if(mid-1>=0 && k==array[mid-1]){
return getFirstIndex(array,k,start,mid-1);
}else{
return mid;
}
}
//迭代写法 得出该元素出现的尾索引位置
private int getEndIndex(int []array,int k,int start,int end){
int length = array.length;
while(start<=end){
int mid = (start+end)>>1;
if(array[mid]>k){
end = mid-1;
}else if (array[mid]<k){
start = mid+1;
}else if(mid+1<length && array[mid+1]==k){
start = mid+1;
}else{
return mid;
}
}
return -1;
}
public static void main(String[] args) {
int []array = new int[]{1,2,3,3,3,4,5,6};
System.out.println(new 数字在排序数组中的出现的次数().GetNumberOfK1(array,0));
}
}