剑指offer-数组

剑指03-数组中的重复元素

• 原地置换

public class _03_数组中的重复数字 {
    // 原地置换
    public int findRepeatNumber(int[] number) {
        for (int i = 0; i < number.length; i++) {
            while (number[i] != i) {
                if (number[i] == number[number[i]]) {
                    return number[i];
                }
                swap(number, number[i], i);
            }
        }
        return -1;
    }
    // 交换
    public void swap(int[] number, int i, int j) {
        int temp = number[i];
        number[i] = number[j];
        number[j] = temp;
    }
}

• 利用hash(题目中给了数组值的范围，利用数组模拟hash不会出现越界情况）

public class _03_数组中的重复数字 {
    // 利用hash 
    public int findRepeatNumber(int[] number) {
    	// 利用数组模拟hash
        int[] arr = new int[number.length];
        for (int num : number) {
            arr[num]++;
            if (arr[num] > 1) return num;
        }
        return -1;
    }
}

• 利用排序

public int findRepeatNumber(int[] number) {
    Arrays.sort(number);
    for (int i = 0; i < number.length-1; i++) {
        if (number[i] == number[i+1]) return number[i];
    }
    return -1;
}

剑指04-二维数组中的查找

• 规律题

public class _04_二维数组中的查找 {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        // 边界判断
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
        // 核心
        int row = 0;
        int col = matrix[0].length-1;
        while (row < matrix.length && col >= 0) {
            if (matrix[row][col] == target) {
                return true;
            }else if (matrix[row][col] > target) {
                col--;
            }else{
                row++;
            }
        }
        return false;
    }
}

剑指05-顺时针打印矩阵

public class _05_顺时针打印矩阵 {
    public int[] spiralOrder(int[][] matrix) {
        if (matrix.length == 0) return new int[0];
        int left = 0, right = matrix[0].length - 1;
        int top = 0, bottom = matrix.length - 1;
        int[] res = new int[(right+1) * (bottom+1)];
        int index = 0;
        
        while (true) {
            for (int i = left; i <= right; i ++) {
                res[index++] = matrix[left][i]; // 从左到右
            } 
            if (++top > bottom) break; // 往下走，如果超出范围则停止
            for (int i = top; i <= bottom; i++) {
                res[index++] = matrix[i][right];// 从上往下
            }
            if (--right < left) break;
            for (int i = right; i >= left; i--) {
                res[index++] = matrix[bottom][i];
            }
            if (--bottom < top) break;
            for (int i = bottom; i >= top; i--) {
                res[index++] = matrix[i][left];
            }
            if (++left > right) break;
        }
        return res;
    }
}

剑指53- 1-在排序数组中查找数字

public class _53_在排序数组中查找数字 {
    public int search(int[] nums, int target) {
        return helper(nums, target) - helper(nums, target - 1);
    }
    public int helper(int[] nums, int tar) {
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] <= tar) i = m + 1;
            else j = m - 1;
        }
        return i;
    }
}

剑指53- 2- 0～n-1中缺失的数字

public class _53_缺失的数字 {
    public int missingNumber(int[] nums) {
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] == m) i = m + 1;
            else j = m - 1;
        }
        return i;
    }
}