剑指offer系列｜解题思路总结(持续更新记录）

最新推荐文章于 2022-07-18 23:24:38 发布

MarkusZhang

最新推荐文章于 2022-07-18 23:24:38 发布

阅读量459

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/MarkusZhang/article/details/104245626

版权

算法系列专栏收录该内容

25 篇文章 1 订阅

订阅专栏

数组篇

二维数组中的查找

题目描述：

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

解题思路：

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<array[i].length;
在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]<array[mid],则low=mid；如果array[high]>array[mid],则high=mid；
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));
    }
}

MarkusZhang

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
剑指offer系列｜解题思路总结(持续更新记录）

数组篇二维数组中的查找题目描述：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。解题思路：1.暴力求解法两层for循环+判断相等条件时间复杂度为O(m*n)2.巧妙解题查找规律利用二分的思想解决问题每一行都是从左到右依次递增...
复制链接

扫一扫

专栏目录