二维数组是由多个一维数组组成的,可以理解为一个表格,行和列分别对应数组的第一维和第二维。它在Java中的应用非常广泛,尤其在矩阵计算、图像处理、游戏等方面。
int[][] array = new int[3][4];这表示创建一个3行4列的二维数组。我们也可以使用另一种方式初始化二维数组:
int[][] array = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
这种方式可以直接初始化二维数组的每个元素。
for (int i = 0; i < array.length; i++) { for (int j = 0; j < array[i].length; j++) { System.out.print(array[i][j] + " "); } System.out.println(); }这个例子中,我们首先使用一个外层循环来遍历每一行,然后在内层循环中遍历每一列。下面是使用Java8流和Lambda表达式来遍历二维数组:
Arrays.stream(array).forEach(row -> { Arrays.stream(row).forEach(num -> System.out.print(num + " ")); System.out.println(); });
这个例子中,我们首先使用Arrays.stream()方法将二维数组转换成一个流,然后使用forEach()方法和Lambda表达式来遍历每个元素,和前面的方法相比,这个方法更简洁。
public static int[][] rotate(int[][] matrix) { int n = matrix.length; int[][] result = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { result[j][n - i - 1] = matrix[i][j]; } } return result; }这个方法中,我们使用一个新的二维数组来存储旋转后的结果。我们使用两个循环遍历原始矩阵中的元素,并将其存储到旋转后的新矩阵中。
最后,返回旋转后的矩阵result。
public static int binarySearch(int[] sortedArray, int key) { int low = 0; int high = sortedArray.length - 1; // 堆代码 duidaima.com while (low <= high) { int mid = (low + high) / 2; if (sortedArray[mid] < key) { low = mid + 1; } else if (sortedArray[mid] > key) { high = mid - 1; } else { return mid; } } return -1; }这个方法中,我们使用一个while循环进行二分查找。在每一次循环中,我们将要查找的元素和数组中间元素进行比较,然后根据比较结果将要查找的范围缩小一半。
总体来说,这段代码的时间复杂度为O(log n),可以快速找到数组中的元素。
public static int[] removeDuplicates(int[] array) { if (array == null || array.length == 0) { return array; } int len = array.length; Arrays.sort(array); int j = 0; for (int i = 0; i < len - 1; i++) { if (array[i] != array[i + 1]) { array[j++] = array[i]; } } array[j++] = array[len - 1]; return Arrays.copyOf(array, j); }这个方法中,我们首先对数组进行排序,然后使用一个循环遍历数组中的元素,如果当前元素和下一个元素不相同,则将当前元素存储到一个新数组中。最后,我们使用Arrays.copyOf()方法返回一个新的数组,长度为j。
最后,将数组的最后一个元素添加到去重后的数组中,并返回数组的前 j 个元素,即为去重后的数组。
可以看出,这段代码的时间复杂度为 O(nlogn),其中 n 为数组的长度。因为要进行排序操作,虽然去重操作只需要一次遍历,但排序的复杂度占据了主要部分。
public static int findMostFrequentElement(int[] elements) { int n = elements.length; Map<Integer, Integer> count = new HashMap<>(); for (int i = 0; i < n; i++) { if (!count.containsKey(elements[i])) { count.put(elements[i], 0); } count.put(elements[i], count.get(elements[i]) + 1); } int mostFrequentElement = -1, maxCount = -1; for (Map.Entry<Integer, Integer> entry : count.entrySet()) { if (entry.getValue() > maxCount) { mostFrequentElement = entry.getKey(); maxCount = entry.getValue(); } } return mostFrequentElement; }这个方法中,我们首先使用一个Map来记录每个元素出现的次数,然后使用一个循环遍历数组中的元素,并将其存储到Map中。最后,我们使用另一个循环
最后,该方法返回最频繁出现的元素。如果该数组中所有元素都只出现了一次,则返回 -1。
public static int[][] transpose(int[][] matrix) { int n = matrix.length; int m = matrix[0].length; int[][] result = new int[m][n]; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { result[i][j] = matrix[j][i]; } } return result; }代码分析:
最后,返回转置后的矩阵result。
总体来说,这段代码实现了简单的矩阵转置算法,具有较高的可读性和易于理解的特点。
public static void rotate(int[] nums, int k) { int n = nums.length; k = k % n; reverse(nums, 0, n - 1); reverse(nums, 0, k - 1); reverse(nums, k, n - 1); } private static void reverse(int[] nums, int start, int end) { while (start < end) { int temp = nums[start]; nums[start] = nums[end]; nums[end] = temp; start++; end--; } }这个例子中,我们首先计算出旋转的次数k。然后,我们首先将整个数组反转,然后再将前k个元素反转,最后再将剩余的元素反转。
这段代码中用到了一个双指针的技巧,即用两个指针start和end分别指向数组的开头和结尾,然后不停地交换它们所指向的元素,直到它们相遇为止,这样就可以实现数组反转的功能。
public static int binarySearch(int[] sortedArray, int key) { int low = 0; int high = sortedArray.length - 1; while (low <= high) { int mid = (low + high) / 2; if (sortedArray[mid] < key) { low = mid + 1; } else if (sortedArray[mid] > key) { high = mid - 1; } else { return mid; } } return -1; }代码分析:
在每次查找过程中,都会将数组的范围缩小一半,因此最差情况下的时间复杂度为O(log n)。如果要查找的元素不存在于数组中,则返回-1。
public static int[] removeDuplicates(int[] array) { if (array == null || array.length == 0) { return array; } int len = array.length; Arrays.sort(array); int j = 0; for (int i = 0; i < len - 1; i++) { if (array[i] != array[i + 1]) { array[j++] = array[i]; } } array[j++] = array[len - 1]; return Arrays.copyOf(array, j); }代码分析:
总的来说,这个算法在空间复杂度上比较低,只需要O(1)的额外空间用于记录指针,但时间复杂度偏高,相对于使用哈希表或者Set等数据结构,其速度较慢。
package com.example.javase.se.array; import java.util.HashMap; import java.util.Map; /** * @Author ms * @Date 2023-11-14 21:11 */ public class ArrayTest7 { public static int findMostFrequentElement(int[] elements) { int n = elements.length; Map<Integer, Integer> count = new HashMap<>(); for (int i = 0; i < n; i++) { if (!count.containsKey(elements[i])) { count.put(elements[i], 0); } count.put(elements[i], count.get(elements[i]) + 1); } int mostFrequentElement = -1, maxCount = -1; for (Map.Entry<Integer, Integer> entry : count.entrySet()) { if (entry.getValue() > maxCount) { mostFrequentElement = entry.getKey(); maxCount = entry.getValue(); } } return mostFrequentElement; } public static void main(String[] args) { } }代码分析: