Números repetidos en matrices, buscar y reemplazar espacios en matrices bidimensionales y combinar dos matrices ordenadas A1A2

1. Números repetidos en una matriz

• Solución 1: ordenar la matriz rápidamente y ordenar una matriz de longitud n toma O (nlogn) tiempo.
• Solución 2: use HashMap para registrar el número de ocurrencias de cada número, y se puede devolver el primero mayor que 2. La replicación de tiempo es O (n) y se requiere una tabla hash de tamaño O (n) como costo.
• Solución 3: De hecho, también es una idea general La condición del título es "En una matriz de longitud n, todos los números están en [0, n-1]". Entonces podemos completar este problema en O (n) tiempo de complejidad sin abrir nuevo espacio de almacenamiento. Es decir, para recorrer desde el principio, el propósito es almacenar el valor correspondiente en cada posición, por ejemplo, a [0] almacena 0, a [3] almacena 3.

/**
 * @author bro
 * @date 2020/9/17 20:53
 * @desc 数组中重复的数字
 */
public class Duplicate {
    
    
    public static boolean dup(int number[], int length, int[] duplication) {
    
    
        if (number == null || length <= 0) return false;
        for (int i = 0; i < length; i++) {
    
    
            if (number[i] < 0 || number[i] > length - 1) return false;
        }
        for (int i = 0; i < length - 1; i++) {
    
    
            while (number[i] != i) {
    
    
                if (number[i] == number[number[i]]) {
    
    
                    duplication[0] = number[i];
                    return true;
                }
                int temp = number[i];
                number[i] = number[temp];
                number[temp] = temp;
            }
        }
        return false;
    }

    public static void main(String[] args) {
    
    
        int[] number = {
    
    2, 3, 1, 0, 4, 5, 3};
        int[] duplication = new int[1];
        System.out.println(dup(number, number.length, duplication));
    }
}

2. Busca en una matriz bidimensional

• Solución 1: Primero seleccione el número en la esquina superior derecha de la matriz. Si el número es igual al número a buscar, la búsqueda finaliza. Si el número es mayor que el número a buscar, se elimina la columna donde se ubica el número; si el número es menor que el número a buscar, se elimina la fila donde se ubica el número.
• Solución 2: método de búsqueda binaria.

/**
 * @author bro
 * @date 2020/9/20 9:37
 * @desc 二维数组找数字
 */
public class Find {
    
    
    public static boolean findTo(int target, int[][] array) {
    
    
        boolean flag = false;
        int rows = array.length;
        int columns = array[0].length;
        if (array != null && rows > 0 && columns > 0) {
    
    
            int row = 0;
            int column = columns - 1;
            while (row < rows && column >= 0){
    
    
                if (array[row][column] == target){
    
    
                    flag = true;
                    break;
                }
                else if (array[row][column] > target){
    
    
                    column --;
                }
                else row ++;
            }
        }
        return flag;
    }

    public static void main(String[] args) {
    
    
        int[][] array = {
    
    {
    
    1,2,8,9},{
    
    2,4,9,12},{
    
    4,7,10,13},{
    
    6,8,11,15}};
        System.out.println(findTo(5, array));
    }
}

public class Solution {
    
    
    public static boolean Find(int target, int[][] array) {
    
    
        for (int i = 0; i < array.length; i++) {
    
    
            int low = 0;
            int high = array[i].length - 1;
            while (low <= high) {
    
    
                int mid = (low + high) / 2;
                if (array[i][mid] > target) {
    
    
                    high = mid - 1;
                }
                if (array[i][mid] < target) {
    
    
                    low = mid + 1;
                } else return true;
            }
        }
        return false;
    }
}

 public static void main(String[] args) {
    
    
        int[][] array = {
    
    {
    
    1, 2, 8, 9}, {
    
    2, 4, 9, 12}, {
    
    4, 7, 10, 13}, {
    
    6, 8, 11, 15}};
        System.out.println(Find(7, array));
    }

3. Reemplazar espacios

• Solución 1: escanee la cadena de principio a fin y reemplácela cada vez que encuentre un carácter de espacio. Dado que 1 carácter se reemplaza con 3 caracteres, debemos mover todos los caracteres detrás del espacio en 2 bytes, de lo contrario, se sobrescribirán dos caracteres. La eficiencia del tiempo es O (n ^ 2).
• Solución 2: mueva los caracteres en la cadena original. (Muévase de atrás hacia adelante. Primero recorra el número de espacios, establezca la longitud de la cuerda y recorra la cuerda de atrás hacia adelante). La eficiencia del tiempo es O (n).

/**
 * @author bro
 * @date 2020/9/20 16:02
 * @desc 替换空格
 */
public class ReplaceBlank {
    
    
    public static String Replace(StringBuffer s) {
    
    
        if (s.length() <= 0 && s == null) return "";
        int numberOfBlack = 0;
        int originalLength = s.length() - 1;
        for (int i = 0; i < originalLength; i++) {
    
    
            if (s.charAt(i) == ' ') {
    
    
                numberOfBlack++;
            }
        }
        int newLength = s.length() + numberOfBlack * 2;
        int i = newLength -1;
        s.setLength(newLength);
        while (originalLength >= 0 && i > originalLength) {
    
    
            if (s.charAt(originalLength) == ' ') {
    
    
                s.setCharAt(i--, '0');
                s.setCharAt(i--, '2');
                s.setCharAt(i--, '%');
            } else s.setCharAt(i--,s.charAt(originalLength));
            originalLength--;
        }
        return s.toString();
    }

    public static void main(String[] args) {
    
    
        StringBuffer str = new StringBuffer("We are happy");
        System.out.println(Replace(str));
    }
}

3.1 Fusión de dos matrices ordenadas A1 A2

/**
 * @author bro
 * @date 2020/9/20 17:15
 * @desc 两个有序数组 A1 A2 的合并
 */
public class OrderArrayMerge {
    
    
    public static int[] merge(int[] A1, int[] A2) {
    
    
        if (A1 == null && A2 == null) return null;
        int A1A2Length = A1.length - 1;
        int A2Length = A2.length - 1;
        int A1Length = A1.length - A2.length - 1;
        if (A2.length <= 0) return A1;
        while (A2Length >= 0 && A1Length >= 0) {
    
    
            if (A2[A2Length] >= A1[A1Length]) {
    
    
                A1[A1A2Length] = A2[A2Length--];
            } else A1[A1A2Length] = A1[A1Length--];
            A1A2Length--;
        }
        return A1;
    }

    public static void main(String[] args) {
    
    
        int[] A1 = {
    
    1, 5, 7, 8, 9, 12, 20, 39, 0, 0, 0, 0, 0, 0, 0};
        int[] A2 = {
    
    3, 5, 7, 13, 15, 23, 45};
        for (int num : merge(A1, A2)) {
    
    
            System.out.println(num);
        }
    }
}