搞懂剑指offer-数组

搞懂剑指offer-数组

数据结构与算法题目，分析过程很重要，明确题目是考察什么知识点，按照自己的知识体系来定位解决方法

1.数组的查找

1.1数组无规律

数组无规律只能通过暴力遍历的方法来查找目标值

//数组无规律时的查找-查找特定的数
public int findTarget(int[] array, int target){
    for (int i = 0;i < array.length;i++){
        if (array[i] == target){
            return i;
        }
    }
    return -1;
}

//数组无规律时的查找-查找最小的数,需要借助一个变量来保存最小的值，查找都需要遍历数组
public int findMin(int[] array, int target){
    int min = array[0];
    for (int i = 1;i < array.length;i++){
        if (array[i] < min){
            min = array[i];
        }
    }
    return min;
}

//数组无规律时的查找-查找最大的数
public int findMax(int[] array){
    int max = array[0];
    for (int i = 1;i < array.length;i++){
        if (array[i] > max){
            max = array[i];
        }
    }
    return max;
}

1.2数组有规律

数组有规律也可以通过暴力遍历的方法来进行查找，但是会复杂。所以往往需要根据实际的规律来进行分析，确定更优的算法来就那些查找。

1.2.1有序数组

当数组有序的时候，一般先考虑二分查找法，再者是根据规律找出更好的算法。

//二分法
public static int findTargetInSortArray(int[] array, int target){
    int low = 0;
    int high = array.length-1;

    while (low <= high){
        int mid = (low + high)/2;
        if (array[mid] == target){
            return mid;
        }else if (array[mid] > target){
            high = mid - 1;
        }else {
            low = mid + 1;
        }
    }
    return -1;
}

1.2.2剑指题目

二维数组的查找

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

分析：是一个数组的查找类型的题目，分析数组是否有规律（一般都是有规律的，没有规律不是白给吗），数组是行和列都是有序的。可以想到二分查找法，也可是根据规律来进行算法设计哦。

根据规律：因为每一行和每一列都是递增的，所有只需要将target与右上角的数进行比较，如果target小，则右上角数所在列都比target大，把这一列去掉，再进行比较。

按照规律

public boolean find(int[][] array,int target){
    int row = 0;
    int col = array[0].length - 1;
    while (row < array[0].length && col >= 0) {
        if (array[row][col] == target) {
            return true;
        } else if (array[row][col] > target) {
            col--;
        } else {
            row++;
        }
    }
    return false;
}

二分法

//二分查找法，每行依次二分查找
public boolean findBin(int[][] array, int target){
    for (int i = 0;i < array[0].length;i++){
        int low = 0;
        int high = array[0].length - 1;
        while (low <= high){
            int mid = (low + high)/2;
            if (array[i][mid] == target){
                return true;
            }else if (array[i][mid] > target){
                high = mid -1;
            }else {
                low = mid + 1;
            }
        }
    }
    return false;
}

旋转数组的最小值

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

分析：

数组的查找，有规律，非递减排序，旋转后变成分块的非递减排序。可以算是有序的，利用二分法；属于二分法的变形

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y4ttlIW5-1591448841040)(C:\Users\xiaolong\Desktop\images\二分法比较.png)]

代码

public int search(int[] array){
    int low = 0;
    int high = array.length - 1;
    while (low <= high){
        int mid = (low + high)/2;
        if (array[mid] > array[high]){
            low = mid + 1;
        }else if (array[mid] < array[high]){
            high = high - 1;
        }else {
            high = mid;//如果小，本身也可能是
        }
    }
    return array[low];
}

2.统计数组中数的个数

统计数组中数的个数这类题目，需要保存数字和出现的次数这两个数，所以借助外部容器hashmap是一个万金油的方法。如果是记录第一个重复出现的数字，则可以借助hashset容器。

但是最优的算法还是根据题目给出的规律，分析规律才设计算法，这才是最优的解法。

数组中重复的数字

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

分析：

采用外部容器的方法，记录第一个重复的数字，那采用hashset，思路是遍历数组，依次存放到hashset中，因为hashset里面的元素不能重复，当添加的元素是之前已经添加过的，那这个数字就是重复出现的元素。

代码：

//借助外部容器
public boolean duplicate(int numbers[],int length,int [] duplication) {
    if (length == 0 || numbers == null){
        return false;
    }else{
        HashSet<Integer> hs = new HashSet<>();
        for (int i = 0; i < length; i++){
            if (!hs.add(numbers[i])){
                duplication[0] = numbers[i];
                return true;
            }
        }
        return false;
    }
}

分析：

分析数组的规律，利用题目中“一个长度为n的数组里的所有数字都在0到n-1的范围内”的条件，把所有数字排序成array[i]=i;

代码：

public boolean duplicate(int numbers[],int length,int [] duplication) {
        if (length == 0 || numbers == null){
            return false;
        }else{
            for (int i = 0; i < length; i++){
                //归位
                while (numbers[i] != i){
                    //如果要交换的数相等，则重复
                    if (numbers[i] == numbers[numbers[i]]){
                        duplication[0] = numbers[i];
                        return true;
                    }
                    //交换，交换规则是把这个数赋值给另外一个数，让另外一个数归位
                    int temp = numbers[i];
                    numbers[i] = numbers[temp];
                    numbers[temp] = temp;
                }
            }
            return false;
        }
    }

数组中只出现一次的数字

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字

分析：

出现重复数字字眼，万金油hash解法,将数字和次数存入haspmap中，然后遍历判断

代码：

public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < array.length;i++){
            if (map.containsKey(array[i])){
                map.put(array[i],2);
            }else{
                map.put(array[i],1);
            }
        }
        
        int count = 0;
        for (Map.Entry<Integer,Integer> entry:map.entrySet()){
            if (entry.getValue() == 1){
                if (count == 0){
                    num1[0] = entry.getKey();
                    count++;
                }else {
                    num2[0] = entry.getKey();
                }
            }
        }
    }

数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。

分析：有序数组，利用二分法。以前的二分法是找出目标值就可以，现在数字出现了多次，所以要找到数字第一次出现的位置和第二次出现的位置。然后就可以计算数字出现的次数了。主要步骤是相等的时候的处理

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
       int first = getFirstK(array,k);
       int last = getLastK(array,k);
       if (first == -1 || last == -1){
           return 0;
       }else{
           return last - first + 1;
       }
    }
    //找第一个
    public int getFirstK(int[] array, int k){
        int left = 0;
        int right = array.length - 1;
        int middle = 0;
        while (left <= right){
            middle = (left + right)/2;
            if (array[middle] == k){
                //主要步骤，判断相等的前一个是否相等
                if (middle > 0 && array[middle - 1] != k || middle == 0){
                    return middle;
                }else{
                    //因为是找第一个，要往前移动
                    right = middle - 1;
                }
                
            }else if (array[middle] > k){
                right = middle - 1;
            }else{
                left = middle + 1;
            }
        }
        return -1;
    }
    //找最后一个
    public int getLastK(int[] array, int k){
        int left = 0;
        int right = array.length - 1;
        int middle = 0;
        while (left <= right){
            middle = (left + right)/2;
            if (array[middle] == k){
                //主要步骤，判断相等的后一个是都相等
                if (middle < array.length - 1 && array[middle + 1] != k || middle == array.length -1){
                    return middle;
                }else{
                    //不相等，因为是找最后一个，所以要往后移
                    left = middle + 1;
                }
                
            }else if (array[middle] > k){
                right = middle - 1;
            }else{
                left = middle + 1;
            }
        }
        return -1;
    }
}

优化后，看不懂

//优化后的算法，看不懂，先放着吧
public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        int first = binarySearch(array, k);
        int last = binarySearch(array, k + 1);
        return (first == array.length || array[first] != k) ? 0 : last - first;
    }
    
   private int binarySearch(int[] nums, int K) {
        int l = 0, h = nums.length;
        while (l < h) {
            int m = l + (h - l) / 2;
            if (nums[m] < K)
                h = m + 1;
            else
                l = m;
            }
        return l;
    }
}

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

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

分析：

1.hashMap存储
2.排序，如果有超过长度一半的数，肯定是在中间，与中间值比较

代码：

//思路1，利用hashMap
import java.util.*;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int length = array.length;
        for (int i = 0;i < length;i++){
            if (!map.containsKey(array[i])){
                map.put(array[i],1);
            }else{
                int count = map.get(array[i]);
                map.put(array[i],++count);
            }
        }
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            if (entry.getValue() > length/2){
                return entry.getKey();
            }
        }
        return 0;
    }
}
//思路2，排序
import java.util.Arrays;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        Arrays.sort(array);
        int count = 0;
        for (int i = 0;i < array.length;i++){
            if (array[i] == array[array.length/2]){
                count++;
            }
        }
        if (count > array.length/2){
            return array[array.length/2];
        }else{
            return 0;
        }
    }
}

注：仅用于学习交流