下一页 → ← 上一页

Java 数组程序

2025 年 5 月 6 日 | 30 分钟阅读

在 Java 中，数组是一种线性数据结构，包含相同数据类型的集合。这些元素存储在连续的内存位置。在本节中，我们将讨论各种数组程序，包括数组操作、操纵、排序、搜索等。

1. Java 程序，用于查找数组元素的和。

为了找到数组元素的和，我们首先定义并声明了一个数组。之后，我们定义了一个 sum() 方法来添加数组元素。在该方法内部，循环重复遍历数组的每个元素并将元素添加到 sum 变量中。在 main() 方法中，我们调用了 sum() 方法，它返回数组元素的和。

示例

class Main {
    static int arr[] = { 7, 4, 10, 9, 13, 26 };
    // method for the sum of elements 
    static int sum()
    {
        int i, sum = 0; 
        // Iterate through all elements and add them to the sum
        for (i = 0; i < arr.length; i++)
            sum += arr[i];
        return sum;
    }
    public static void main(String[] args)
    {
        System.out.println("The sum of the given array is: "+ sum());
    }
}

编译并运行

输出

The sum of the given array is: 69

2. Java 程序，用于反转数组。

反转数组意味着从最后一个元素到第一个元素写入数组。首先，我们初始化一个数组。循环遍历数组直到数组被反转。我们交换第一个元素和最后一个元素，第二个元素和倒数第二个元素，依此类推。最后，我们将数组转换为字符串并打印反转后的数组。

示例

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {     
        int[] arr = {1, 2, 3, 4, 5};
        // Swap elements from start to end
        for (int i = 0; i < arr.length / 2; i++) {
            int t = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = t;
        }
        System.out.println("" + Arrays.toString(arr));
    }
}

编译并运行

输出

[5, 4, 3, 2, 1]

3. Java 程序，用于合并两个数组。

有多种方法可以合并两个数组。但在此程序中，我们使用用户定义的逻辑来合并两个数组。当我们需要完全控制合并过程而不依赖内置函数时，此方法非常有用。它直接合并数组。

示例

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int arr1[] = { 23, 45, 56, 78, 90};
        int arr2[] = { 3, 4, 6, 8, 9, 0, 7};
        // determining the length of both arrays
        int sizearr1 = arr1.length;
        int sizearr2 = arr2.length;
        // resultant array size
        int sizearr3 = sizearr1 + sizearr2;
        // Creating a new array 
        int[] arr3 = new int[sizearr3];
        // Loop to store the elements of the first array into the resultant array
        for (int i = 0; i < sizearr1; i = i + 1) {  
            // Storing the elements in the resultant array
            arr3[i] = arr1[i];
        }
        // Loop to concatenate the elements of the second array into the resultant array
        for (int i = 0; i < sizearr2; i = i + 1) {
            // Storing the elements in the resultant array
            arr3[sizearr1 + i] = arr2[i];
        }
        System.out.println("" + Arrays.toString(arr3));
    }
}

编译并运行

输出

[23, 45, 56, 78, 90, 3, 4, 6, 8, 9, 0, 7]

4. Java 程序，用于查找排序矩阵中第二重要的元素。

在排序矩阵中，元素的行和列按升序排列。我们可以遍历矩阵并记录最大和第二大元素，以确定第二大元素。遍历完成后，第二大元素将被存储。

该程序使用一种简单的方法来查找排序矩阵中第二大的元素。它应用嵌套循环以逆序遍历矩阵，并将每个元素与迄今为止找到的最大和第二大元素进行比较。程序相应地更新最大和第二大的变量。最后，它打印第二大元素的值。

示例

public class Main
{  
    public static void main(String[] args)   
    {  
        int[][] matrix =   
        {  
            {1,2,3},  
            {4,5,6},  
            {7,8,9}  
        };  
        int rows=matrix.length;  
        int cols=matrix[0].length;  
        int largest=matrix[rows-1][cols-1]; // Initialize largest with the bottom-right element  
        int secondLargest=matrix[rows-1][cols-2]; // Initialize secondLargest with the element before largest  
          
        // Traverse the matrix in reverse order  
        for (int i=rows-1;i>=0;i--)   
        {  
            for (int j=cols-1;j>=0;j--)   
            {  
                if (matrix[i][j]>largest)   
                {  
                    secondLargest=largest; // Update secondLargest to the previous largest  
                    largest=matrix[i][j]; // Update largest to the new largest element  
                }   
              else if(matrix[i][j]>secondLargest&&matrix[i][j]<largest)   
                {  
                    secondLargest=matrix[i][j];   
                }  
            }  
        }  
        System.out.println("Second largest element in the sorted matrix is: "+secondLargest);  
    }  
}  

编译并运行

输出

Second largest element in the sorted matrix is: 8

复杂度分析

时间复杂度：O(行数 * 列数)，其中行数和列数是矩阵的维度。

空间复杂度：O(1)，因为我们使用恒定的额外空间。

5. Java 程序，用于查找排序矩阵中第 k 个最小的元素。

在排序矩阵中，元素按行和列的升序排列。任务是查找矩阵中第 k 个最小的元素。

该程序使用一个由 PriorityQueue 实现的最小堆来查找排序矩阵中第 k 个最小的元素。findKthSmallest() 方法初始化 minHeap 并添加第一列的元素。然后它执行 k-1 次迭代，提取最小元素，找到其索引，并将同一行的下一个元素添加到 minHeap。最后，该方法返回第 k 个最小的元素。main 函数通过提供示例矩阵和 k 值来演示该方法。

示例

import java.util.*;  
public class Main  
{  
    public static int findKthSmallest(int[][] matrix,int k)   
    {  
        int rows=matrix.length;  
        int cols=matrix[0].length;  
        PriorityQueue<Integer> minHeap=new PriorityQueue<>();  
        for (int i=0;i<rows;i++) {  
            minHeap.add(matrix[i][0]);  
        }  
        // Perform k-1 iterations  
        for (int i=0;i<k-1;i++)   
        {  
            int minElement=minHeap.poll(); // Extract the minimum element  
            // Get the row and column index of the extracted element  
            int rowIndex=-1;  
            int colIndex=-1;  
            for (int j=0;j<rows;j++)   
            {  
                for (int p=0;p<cols;p++)   
                {  
                    if (matrix[j][p]==minElement)   
                    {  
                        rowIndex=j;  
                        colIndex=p+1;  
                        break;  
                    }  
                }  
            }  
            // Add the next element from the same row to the min-heap  
            if (colIndex<cols) {  
                minHeap.add(matrix[rowIndex][colIndex]);  
            }  
        }  
        return minHeap.peek(); // Return the kth smallest element  
    }  
    public static void main(String[] args)   
    {  
        int[][] matrix={  
            {1,3,5},  
            {6,7,12},  
            {11,14,14}  
        };  
        int k=4;  
        int kthSmallest=findKthSmallest(matrix,k);  
        System.out.println("The "+ k+"-th smallest element in the sorted matrix is: "+kthSmallest);  
    }  
}  

编译并运行

输出

The 4-th smallest element in the sorted matrix is: 6

复杂度分析

时间复杂度：时间复杂度为 O(k * log(行数))。

空间复杂度：空间复杂度为 O(行数)，用于在最小堆中存储元素。

6. Java 程序，用于从排序数组中删除重复元素。

在排序数组中，重复元素可能连续出现。要从维护的数组中删除重复项，我们需要就地调整数组，确保每个细节只出现一次。Java 程序使用“RemoveDuplicates”类从排序数组中删除重复项。“removeDuplicates”方法返回修改后的无重复数组的新长度。它检查数组是否为空，将“nextUnique”初始化为 1，并从第二个元素开始遍历数组。它将唯一元素分配给“nextUnique”的位置并递增。循环结束后，“nextUnique”表示新长度。“main”函数通过打印修改后的数组来演示该方法。

示例

import java.util.*;  
public class Main  
{  
    public static int removeDuplicates(int[] nums)   
    {  
        int n=nums.length;  
        if (n==0)   
        {  
            return 0;   
        }  
        int nextUnique=1;   
        // Pointer to track the position of the next unique element  
        // Traverse the array starting from the second element  
        for (int current=1;current<n;current++)   
        {  
            // Compare the current element with the element at the next unique - 1  
            if (nums[current]!=nums[nextUnique-1])   
            {  
   nums[nextUnique]=nums[current]; // Assign current element to nextUnique position  
                nextUnique++; // Increment nextUnique  
            }  
        }  
        return nextUnique;   
    }  
    public static void main(String[] args)   
    {  
        int[] nums={1,1,2,2,3,4,4,5};  
        int length=removeDuplicates(nums);  
        System.out.print("Modified Array: ");  
        for (int i=0;i<length;i++)   
        {  
            System.out.print(nums[i]+" ");  
        }  
    }  
}  

编译并运行

输出

Modified Array: 1 2 3 4 5

复杂度分析

时间复杂度为 O(n)，其中 n 是数组的元素计数。

空间复杂度为 O(1)，因为数组是直接修改的，无需额外的数据结构。

7. Java 程序，用于查找字符串数组中每个单词的频率。

我们将使用 Java 程序计算字符串数组中每个单词的频率。在字符串列表中，我们想知道每个单词出现的频率。为了计算字符串数组中每个单词的频率，该程序使用了一个哈希映射。

一种简单的方法是将每个字符串分成单词，然后将每个单词的计数保存在哈希映射中。在初始化一个空 HashMap 后，程序遍历数组中的每个字符串。它确定 HashMap 中是否存在它遇到的每个单词。

如果存在，频率增加；如果不存在，则将其设置为 1，并将单词添加到哈希映射中。最后，程序打印存储在 HashMap 中的单词-频率对。该方法有效地跟踪和计算每个单词的出现次数，从而可以准确分析字符串数组中单词的频率。

示例

import java.util.*;  
public class Main 
{  
    public static void main(String[] args)   
    {  
        String[] strings={"Hello world","Hello Java","Java is great","Java is powerful"};         // Create a HashMap to store word-frequency pairs  
        Map<String,Integer> frequencyMap=new HashMap<>();  
        for (String str:strings)   
        {  
            // Split the string into words using whitespace as the delimiter  
            String[] words=str.split("\\s+");  
            // Count the occurrences of each word  
            for (String word:words)   
            {  
                // Check if the word already exists in the HashMap  
                if (frequencyMap.containsKey(word))   
                {  
                    // If it exists, increment its frequency by 1  
                    frequencyMap.put(word,frequencyMap.get(word)+1);  
                } else {  
                    // If it does not exist, add it to the HashMap with a frequency of 1  
                    frequencyMap.put(word,1);  
                }  
            }  
        }  
        // Print the word-frequency pairs  
        for (Map.Entry<String, Integer> entry : frequencyMap.entrySet()) {  
            System.out.println("Word: " + entry.getKey() + ", Frequency: " + entry.getValue());  
        }  
    }  
}  

编译并运行

输出

Word: Java, Frequency: 3
Word: world, Frequency: 1
Word: Hello, Frequency: 2
Word: powerful, Frequency: 1
Word: is, Frequency: 2
Word: great, Frequency: 1

复杂度分析

时间复杂度为 O(n*m)，其中 n 表示数组中的字符串数量，m 表示每个字符串中单词的最大常见类型。

程序的空间复杂度为 O(n)，其中 n 是数组中单词的总数。

8. Java 程序，用于查找连续整数排序数组中缺失的数字。

使用二分搜索方法，我们定位连续整数排序数组中缺失的整数。第一个元素的索引为 low，其余为 high。我们通过计算中间元素的预期值来确定缺失的整数是在数组的左侧还是右侧，该预期值应该与第一个元素加上中间索引相同。重复操作，直到搜索空间中只剩下一个元素，此时我们根据需要更新 low 或 high。缺失的数字将是索引 low 处的预期值。

示例

public class Main 
{  
    public static int findMissingNumber(int[] nums)   
    {  
        int low=0;  
        int high=nums.length-1;  
        // Perform binary search  
        while (low<=high)   
        {  
            int mid=low+(high-low)/2;  
            int expectedValue=nums[0]+mid;  
            if (nums[mid]==expectedValue)   
            {  
                // Missing number lies in the right half  
                low=mid+1;  
            } else   
            {  
                // Missing number lies in the left half  
                high=mid-1;  
            }  
        }  
        // Return the missing number  
        return nums[0]+low;  
    }  
    public static void main(String[] args)   
    {  
        int[] nums={1,2,3,4,6,7,8,9};  
        int missingNumber=findMissingNumber(nums);  
        System.out.println("Missing number: "+missingNumber);  
    }  
}  

编译并运行

输出

Missing number: 5

复杂度分析

时间复杂度：二分搜索方法的时间复杂度为 O(log n)，其中 n 是数组的大小。

空间复杂度：该程序的空间复杂度为 O(1)，只使用少量变量来跟踪 low、high 和 mid 索引以及预期值。

9. Java 程序，用于查找数组中只出现一次的元素。

用于查找数组中只出现一次的元素的技术主要基于 XOR 运算。通过对数组中的所有因子进行 XOR 运算，出现偶数次的因子将抵消，只留下只出现一次的因子。为了实现这种方法，我们将变量“unique”初始化为零。然后，我们遍历数组中的每个细节并将其与“particular”变量进行 XOR 运算。结果存储回“unique”中。迭代结束时，“unique”将保存只出现一次的元素的值。

示例

public class Main   
{  
    public static int findUnique(int[] nums)   
    {  
        int unique=0;  
        for (int num:nums)   
        {  
            unique^=num; // XOR the current element with 'unique'  
        }  
        return unique;  
    }  
  
    public static void main(String[] args)   
    {  
        int[] nums = {1,2,3,4,3,2,1};  
        int uniqueElement=findUnique(nums);  
        System.out.println("The element that appears only once: " + uniqueElement);  
    }  
}  

编译并运行

输出

The element that appears only once: 4

复杂度分析

时间复杂度：此技术的时间复杂度为 O(n)，其中 n 是数组的长度。

空间复杂度：空间复杂度为 O(1)，因为我们只使用一个变量来保存结果。

10. Java 程序，用于检查数组是否是回文。

要检查数组是否是回文，我们将使用指针方法，其中一个指针从数组的开头开始，另一个指针从数组的末尾开始。元素与这些建议进行比较，我们让它们越来越靠近，直到它们在中心相遇。如果任何指针处的元素不相等，我们得出结论数组不是回文。否则，如果循环完成而没有发现任何不相等的元素，则数组是回文。双指针方法允许我们通过消除额外空间的需要来有效地检查回文性。

示例

public class Main
{  
    public static boolean isPalindrome(int[] nums)   
    {  
        int left=0;                     // Initialize the left pointer at the beginning of the array  
        int right=nums.length-1;      // Initialize the right pointer at the end of the array  
while (left<=right) {      // Continue the loop until the pointers meet or cross each other  
 if (nums[left]!=nums[right])   
{  
   return false;             // If the elements at the pointers are not equal, the array is not a palindrome  
            }  
            left++;                         
            right--;                        
        }  
 return true;    // If the loop completes without finding unequal elements, the array is a palindrome  
    }  
    public static void main(String[] args) {  
        int[] nums={1,2,3,2,1};     
        boolean isPalindrome=isPalindrome(nums);    
        if (isPalindrome)   
       {  
            System.out.println("The array is a palindrome.");  
        }   
       else   
       {  
            System.out.println("The array is not a palindrome.");  
        }  
    }  
}

编译并运行

输出

The array is a palindrome.

复杂度分析

上述方法的时间复杂度为 O(n)，其中 n 是数组的长度。

空间复杂度为 O(1)，因为我们没有使用任何额外空间。

11. Java 程序，用于打乱数组的元素。

为了打乱数组的元素，我们通常使用 Fisher-Yates 洗牌算法。该过程确保数组的每个项都被随机置换。从数组中的最后一个条目开始，该过程以逆序遍历数组以启动。每次，将当前元素添加到剩余未收缩元素的范围中以创建随机索引。然后将当前索引处的元素与随机生成的索引处的元素交换。交换继续进行，直到达到第一个元素，从而生成一个元素随机排列的打乱数组。

示例

import java.util.Random;  
public class Main   
{  
    public static void shuffle(int[] nums)   
    {  
        Random rand=new Random();  
        for (int i=nums.length-1;i>=1;i--)   
        {  
            int j=rand.nextInt(i+1);  
            // Swap the current element with the randomly selected element  
            int temp=nums[i];  
            nums[i]=nums[j];  
            nums[j]=temp;  
        }  
    }  
    public static void main(String[] args)   
    {  
        int[] nums = {1,2,3,4,5};  
        System.out.println("Original array: ");  
        for (int num:nums)   
      {  
            System.out.print(num + " ");  
        }  
        shuffle(nums);  
        System.out.println("\nShuffled array: ");  
        for (int num:nums)   
      {  
            System.out.print(num + " ");  
        }  
    }  
}  

编译并运行

输出

Original array: 
1 2 3 4 5 
Shuffled array: 
5 2 1 3 4

复杂度分析

此技术的时间复杂度为 O(N)，其中 N 是数组的大小。

空间复杂度为 O(1)，因为我们为随机变量使用一致的额外空间量。

12. Java 程序，用于检查两个矩阵是否正交。

为了检查两个矩阵是否正交，我们评估矩阵的相应行或列的点积。如果所有对的点积均为 0，则称这些矩阵正交。该算法遍历行或列，然后计算点积，如果任何点积非零，则返回 false。然后它检查适当的维度。如果所有点积均为零，则返回 true 以指示矩阵正交。

示例

public class Main  
{  
    public static boolean areMatricesOrthogonal(int[][] matrix1,int[][] matrix2)   
{  
        int rows1=matrix1.length;  
        int cols1=matrix1[0].length;  
        int rows2=matrix2.length;  
        int cols2=matrix2[0].length;  
        // Check if matrices have compatible dimensions  
        if (rows1 != rows2 || cols1 != cols2) {  
            return false;  
        }  
        // Check the dot product for each row/column pair  
        for (int i=0;i<rows1;i++) {  
            int dotProduct = 0;  
            for (int j=0;j<cols1;j++) {  
                dotProduct += matrix1[i][j] * matrix2[i][j];  
            }  
            if (dotProduct!=0)   
            {  
                return false;  
            }  
        }  
        return true;  
    }  
    public static void main(String[] args) {  
        int[][] matrix1={{1,2},{3,4}};  
        int[][] matrix2={{0,1},{-1,0}};  
          
        boolean areOrthogonal = areMatricesOrthogonal(matrix1, matrix2);  
        if (areOrthogonal) {  
            System.out.println("The matrices are orthogonal.");  
        } else {  
            System.out.println("The matrices are not orthogonal.");  
        }  
    }  
}  

编译并运行

输出

The matrices are not orthogonal.

复杂度分析

此技术的时间复杂度为 O(n)，其中 n 是矩阵中的行数或列数。

空间复杂度为 O(1)，因为没有使用额外的数据结构。

13. Java 程序，用于查找二维数组中的最大元素。

我们用给定数组元素数据类型可能最小的值初始化变量“max”，以确定二维数组中的最大元素。下一步是分别遍历数组的行和因子。每个元素都与“max”的当前值进行比较，如果该细节更大，“max”就会更新。一旦所有项都已迭代，二维数组中的最大元素将包含在“max”中。通过将每个元素与当前最大值进行比较，该方法使我们能够快速确定最大元素。

示例

public class Main
{  
    public static int findMaximumElement(int[][] array) {  
        int max=Integer.MIN_VALUE; // Initialize max with the minimum value  
        for (int i=0;i<array.length;i++)   
        {  
            // Iterate through each element of the row  
            for (int j=0;j<array[i].length;j++)   
            {  
                // Compare the current element with the current max value  
                if (array[i][j] > max) {  
                    max=array[i][j];   
                }  
            }  
        }  
        return max; // Return the maximum element  
    }  
    public static void main(String[] args) {  
        int[][] array={  
            {1, 2, 3},  
            {4, 5, 6},  
            {7, 8, 9}  
        };  
        int maximum=findMaximumElement(array);  
        System.out.println("The maximum element in the array is: "+maximum);  
    }  
}  

编译并运行

输出

The maximum element in the array is: 9

复杂度分析

此方法的时间复杂度为 O(n * m)，其中 n 是二维数组的行数，m 是列数。

空间复杂度为 O(1)，因为我们不使用任何随输入大小增长的额外空间。

14. Java 程序，用于查找矩阵中每个对角线的和。

为了找到矩阵中每个对角线的和，我们遍历元素并通过将其行和列索引相加来计算每个分量的对角线索引。然后，我们将元素的值添加到数组中相应的对角线和。处理完所有元素后，数组将包含每个对角线的和。

示例

public class Main {  
    public static int[] getDiagonalSums(int[][] matrix) {  
        int rows=matrix.length;  
        int cols=matrix[0].length;  
        int numDiagonals=rows+cols-1;  
        int[] sums=new int[numDiagonals];  
        for (int i=0;i<rows;i++)   {  
            for (int j=0;j<cols;j++)    {  
                int diagonalIndex=i+j;  
                sums[diagonalIndex]+=matrix[i][j];  
            }  
        }  
        return sums;  
    }  
    public static void main(String[] args) {  
        int[][] matrix={  
            {1, 2, 3},  
            {4, 5, 6},  
            {7, 8, 9}  
        };  
        int[] diagonalSums=getDiagonalSums(matrix);  
        System.out.println("Sum of each diagonal:");  
        for (int sum:diagonalSums)  {  
            System.out.println(sum);  
        }  
    }  
}  

编译并运行

输出

Sum of each diagonal:
1
6
15
14
9

复杂度分析

该方法的时间复杂度为 O(m*n)，其中 m 是矩阵的行数，n 是列数。

空间复杂度为 O(m + n)，因为我们必须将对角线和存储在数组中。

15. Java 程序，用于查找数组中频率最高的元素。

我们使用 HashMap 来记录数组中每个元素的频率，以找到频率最高的元素。可以通过遍历数组并更新哈希映射中的频率来识别频率最高的元素。然后，通过比较 HashMap 中的频率计数，我们识别出频率最高的元素。该方法使我们能够有效地找到数组中频率最高的元素。

示例

import java.util.*;
public class Main {
    public static int findMaxFrequencyElement(int[] nums) {
        Map<Integer, Integer> frequencyMap = new HashMap<>();
        for (int num : nums) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }
        return Collections.max(frequencyMap.entrySet(), Map.Entry.comparingByValue()).getKey();
    }
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 2, 1, 2, 3, 3, 3};
        System.out.println("Element with maximum frequency is: " + findMaxFrequencyElement(nums));
    }
}

编译并运行

输出

Element with maximum frequency is: 3

复杂度分析

此技术的时间复杂度为 O(n)，其中 n 是数组的大小。

空间复杂度为 O(n)，因为在最坏情况下，HashMap 可以存储多达 n 个唯一元素。

16. Java 程序，用于顺时针旋转二维数组。

要顺时针旋转二维数组，我们可以遵循两步法：转置数组并反转每一行。首先，我们遍历数组并用位置 (j, i) 处的细节切换功能 (i, j) 处的每个细节，然后成功转置数组。之后，我们遍历转置数组的每一行，并通过交换行头和行尾的元素直到它们在中间相遇来反转它。该过程将数组顺时针旋转。

示例

public class Main  {  
    public static void rotateClockwise(int[][] matrix)  {  
        int rows=matrix.length;  
        int cols=matrix[0].length;  
        // Transpose the array  
        for (int i=0;i<rows;i++)    {  
            for (int j=i;j<cols;j++)   {  
                int temp=matrix[i][j];  
                matrix[i][j]=matrix[j][i];  
                matrix[j][i]=temp;  
            }  
        }  
        // Reverse each row  
        for (int i=0;i<rows;i++)   {  
            int left=0;  
            int right=cols-1;  
            while (left<right)    {  
                int temp=matrix[i][left];  
                matrix[i][left]=matrix[i][right];  
                matrix[i][right]=temp;  
                left++;  
                right--;  
            }  
        }  
    }  
    public static void main(String[] args) {  
        int[][] matrix = {  
            {1, 2, 3},  
            {4, 5, 6},  
            {7, 8, 9}  
        };  
        System.out.println("Original Matrix:");  
        printMatrix(matrix);  
        rotateClockwise(matrix);  
        System.out.println("Rotated Matrix:");  
        printMatrix(matrix);  
    }  
    public static void printMatrix(int[][] matrix) {  
        int rows=matrix.length;  
        int cols=matrix[0].length;  
        for (int i=0;i<rows;i++)   {  
            for (int j=0;j<cols;j++)       {  
                System.out.print(matrix[i][j]+" ");  
            }  
            System.out.println();  
        }  
        System.out.println();  
    }  
} 

编译并运行

输出

Original Matrix:
1 2 3 
4 5 6 
7 8 9 

Rotated Matrix:
7 4 1 
8 5 2 
9 6 3

复杂度分析

此方法的时间复杂度为 O(n²)，其中 n 是数组的大小。

空间复杂度为 O(1)，因为我们原地执行旋转，不使用任何额外的存储系统。

17. Java 程序，用于按列对二维数组进行排序。

我们构建一个自定义比较器，根据所需列比较行，以按列对二维数组进行排序。调用 Arrays.sort() 方法并将自定义比较器作为参数。排序算法使用比较器根据选定的列比较行并正确排列它们。我们可以使用此方法快速按列对二维数组进行排序。

示例

import java.util.Arrays;  
import java.util.Comparator;  
public class Main {  
    public static void sortByColumn(int[][] matrix, int column) {  
        // Use Arrays.sort() with a custom comparator to sort the matrix by the specified column  
        Arrays.sort(matrix,Comparator.comparingInt(row -> row[column]));  
    }  
    public static void main(String[] args) {  
        int[][] matrix = {  
            {13, 12, 11},  
            {6, 5, 4},  
            {19, 18, 17}  
        };  
        int columnToSortBy=1;  
        System.out.println("Original Matrix:");  
        printMatrix(matrix);  
        sortByColumn(matrix,columnToSortBy);  
        System.out.println("Sorted Matrix by Column " + columnToSortBy + ":");  
        printMatrix(matrix);  
    }  
    public static void printMatrix(int[][] matrix) {  
        int rows=matrix.length;  
        int cols=matrix[0].length;  
        for (int i=0;i<rows;i++)   {  
            for (int j=0;j<cols;j++)   {  
                System.out.print(matrix[i][j]+" ");  
            }  
            System.out.println();  
        }  
        System.out.println();  
    }  
}  

编译并运行

输出

Original Matrix:
13 12 11 
 6    5   4 
19 18 17 

Sorted Matrix by Column 1:
 6    5   4 
13 12 11 
19 18 17

复杂度分析

此方法的时间复杂度为 O(n log n)，其中 n 是矩阵中的行数。

空间复杂度为 O(1)，因为排序是原地完成的。

18. Java 程序，用于执行矩阵指数化以高效计算斐波那契数。

我们还可以将斐波那契序列描述为矩阵，并计算矩阵乘法以利用矩阵指数化快速计算斐波那契数。该过程包括创建表示斐波那契序列的变换矩阵，利用矩阵乘法和指数化策略，然后使用 powerMatrix 方法将矩阵提升到所需的幂次。通过从以下矩阵中删除斐波那契数，我们还可以快速计算斐波那契数。

示例

public class Main {  
    public static long computeFibonacci(int n)   {  
        if (n<=0)   {  
            return 0;  
        }  
        // Fibonacci transformation matrix  
        long[][] fibMatrix = {{1, 1}, {1, 0}};  
        // Raise fibMatrix to the power of (n-1)  
        fibMatrix = powerMatrix(fibMatrix, n - 1);  
        // Extract the Fibonacci number from the matrix  
        return fibMatrix[0][0];  
    }  
    private static long[][] powerMatrix(long[][] matrix, int power) {  
        if (power == 0) {  
            // Identity matrix  
            return new long[][]{{1, 0}, {0, 1}};  
        }  
        if (power == 1) {  
            return matrix;  
        }  
        long[][] result = powerMatrix(matrix, power / 2);  
        result = multiplyMatrices(result, result);  
        if (power % 2 != 0) {  
            result = multiplyMatrices(result, matrix);  
        }  
        return result;  
    }  
    private static long[][] multiplyMatrices(long[][] matrix1,long[][] matrix2)    {  
        long[][] result=new long[2][2];  
        result[0][0]=matrix1[0][0]*matrix2[0][0]+matrix1[0][1]*matrix2[1][0];  
        result[0][1]=matrix1[0][0]*matrix2[0][1]+matrix1[0][1]*matrix2[1][1];  
        result[1][0]=matrix1[1][0]*matrix2[0][0]+matrix1[1][1]*matrix2[1][0];  
        result[1][1]=matrix1[1][0]*matrix2[0][1]+matrix1[1][1]*matrix2[1][1];  
        return result;  
    }  
    public static void main(String[] args)    {  
        int n=10;  
        long fibonacci=computeFibonacci(n);  
        System.out.println("Fibonacci number at position "+n+" is: "+fibonacci);  
    }  
}  

编译并运行

输出

Fibonacci number at position 10 is: 55

复杂度分析

此方法的时间复杂度为 O(log n)，因为我们使用平方求幂技术执行矩阵乘法。

空间复杂度为 O(1)，因为我们只需要一个固定大小的矩阵和一些额外的变量。

19. 给定一个整数数组，重新排列数组，使所有偶数出现在所有奇数之前。

注意：保持相对顺序与此问题无关。

我们可以使用双指针技术来重新排序数组，使所有偶数出现在所有奇数之前。右指针从末尾开始向后移动，而左指针从开头向前移动。每一步都会检查左指针和右指针指向的元素，并根据需要进行交换。当循环完成时，所有偶数将排列在奇数之前。

示例

public class Main   
{  
    public static void rearrangeArray(int[] arr)   
    {  
        int left=0;  
        int right=arr.length-1;  
        while (left<=right)   {  
            if (arr[left]%2==0)    {  
                left++; // Move the left pointer forward if the element is even  
            } else if (arr[right]%2==1)   {  
                right--; // Move the right pointer backwards if the element is odd  
            } else {  
    swap(arr,left,right); // Swap the elements if the left element is odd and the right element is even  
                left++; // Move the left pointer forward  
                right--; // Move the right pointer backwards  
            }  
        }  
    }  
    public static void swap(int[] arr,int i,int j)   {  
        int temp=arr[i];  
        arr[i]=arr[j];  
        arr[j]=temp;  
    }  
    public static void main(String[] args)    {  
        int[] arr = {1,2,3,4,5,6,7,8,9};  
        System.out.println("Original Array: ");  
        printArray(arr);  
        rearrangeArray(arr);  
        System.out.println("Rearranged Array: ");  
        printArray(arr);  
    }  
    public static void printArray(int[] arr)   {  
        for (int num:arr)   {  
            System.out.print(num+" ");  
        }  
        System.out.println();  
    }  
}  

编译并运行

输出

Original Array: 
1 2 3 4 5 6 7 8 9 
Rearranged Array: 
8 2 6 4 5 3 7 1 9

复杂度分析

此方法的时间复杂度为 O(n)，其中 n 是数组中的元素数量。

空间复杂度为 O(1)，因为我们原地执行重新排列，不使用任何额外的数据结构。

20. Java 程序，用于查找未排序数组中最小的缺失正数。

我们可以通过将每个正整数分配到其适当的索引来重新排列数组，以发现未排序数组中最小的缺失正数。您可以通过遍历数组并将每个带有正整数的元素与所需索引处的元素进行交换来完成此操作。重新排列后，数组再次迭代以找到第一个元素不再对应于所需值的索引。该索引对应于最小的缺失正数。如果所有元素都与它们的所需值匹配，则最小的缺失正数是数组大小之后的下一个正整数。

示例

public class Main  
{  
    public static int findSmallestMissingPositive(int[] nums)  
    {  
        int n=nums.length;  
        // Rearrange the array  
        for (int i=0;i<n;i++)   
        {  
            while (nums[i]>0&&nums[i]<=n&&nums[nums[i]-1]!=nums[i])   
            {  
                swap(nums,i,nums[i]-1);  
            }  
        }  
        //Find the smallest missing positive number  
        for (int i=0;i<n;i++)   
        {  
            if (nums[i]!=i+1)   
            {  
                return i+1;  
            }  
        }  
        // If all elements match their desired values, return the next positive integer  
        return n+1;  
    }  
    public static void swap(int[] nums,int i,int j)   
    {  
        int temp=nums[i];  
        nums[i]=nums[j];  
        nums[j]=temp;  
    }  
    public static void main(String[] args)   
    {  
        int[] nums={3,4,-1,1};  
        int smallestMissingPositive = findSmallestMissingPositive(nums);  
        System.out.println("Smallest Missing Positive Number: "+smallestMissingPositive);  
    }  
} 

编译并运行

输出

Smallest Missing Positive Number: 2

复杂度分析

该方法确保时间复杂度为 O(n)，空间复杂度为 O(1)，因为我们原地执行重新排列和搜索，无需额外的数据结构。

21. Java 程序，用于查找两个数组的交集。

查找两个数组交集的最佳方法是使用 HashSet 数据结构。我们创建一个 HashSet 并将一个数组中的所有元素添加到其中。然后，我们遍历第二个数组并检查每个元素是否存在于 HashSet 中。如果存在，我们将其添加到结果 ArrayList 中，并将其从 HashSet 中删除以避免重复。

示例

import java.util.ArrayList;  
import java.util.HashSet;  
import java.util.List;  
public class Main{  
    public static List<Integer> intersection(int[] nums1, int[] nums2) {  
        HashSet<Integer> set=new HashSet<>();  
        List<Integer> result=new ArrayList<>();  
        // Add elements of nums1 to the set  
        for (int num:nums1)  {  
            set.add(num);  
        }  
        // Check for intersection in nums2  
        for (int num:nums2)   {  
            if (set.contains(num))   {  
                result.add(num);  
                set.remove(num);  
            }  
        }  
        return result;  
    }  
    public static void main(String[] args) {  
        int[] nums1 = {1, 2, 2, 1};  
        int[] nums2 = {2, 2};  
        List<Integer> intersection=intersection(nums1, nums2);  
        System.out.println("Intersection: "+intersection);  
    }  
}  

编译并运行

输出

Intersection: [2]

复杂度分析

此方法的时间复杂度为 O(n)，其中 n 是较大数组的大小。

空间复杂度为 O(m)，其中 m 是 HashSet 的大小。

22. Java 程序，用于查找 0 和 1 数量相等的最长子数组。

利用前缀和方法，我们可以确定包含相等数量的 0 和 1 的最长子数组。我们可以通过为每个 1 分配值 1，为每个 0 分配值 -1 来在遍历数组时计算运行和。当运行和达到零时，我们到目前为止看到的 0 和 1 的数量是相等的。为了找到最长的子数组，我们将运行和及其对应的索引存储在 HashMap 中。如果相同的运行和再次出现，我们通过从当前索引中减去存储的索引来更新最大长度。通过在整个迭代过程中跟踪最大长度，我们可以找到 0 和 1 相等的最长子数组。

示例

import java.util.HashMap;  
public class Main {  
    public static int findMaxLength(int[] nums)   {  
        int maxLength=0;  
        int runningSum=0;  
        HashMap<Integer,Integer> sumMap=new HashMap<>();  
        sumMap.put(0,-1); // Handle the case when the subarray starts from the beginning  
        for (int i=0;i<nums.length;i++)   {  
            runningSum+=nums[i]==0?-1:1;  
            if (sumMap.containsKey(runningSum))    {  
                int startIndex=sumMap.get(runningSum);  
                maxLength=Math.max(maxLength,i-startIndex);  
            } else {  
                sumMap.put(runningSum,i);  
            }  
        }  
        return maxLength;  
    }  
    public static void main(String[] args)    {  
        int[] nums = {0, 1, 0, 0, 1, 1, 0};  
        int maxLength=findMaxLength(nums);  
  System.out.println("Length of the longest subarray with equal 0s and 1s is: "+maxLength);  
    }  
}  

编译并运行

输出

Length of the longest subarray with equal 0s and 1s: 6

复杂度分析

此方法的时间复杂度为 O(n)，因为我们只遍历数组一次。

空间复杂度为 O(n)，因为我们将运行和及其对应的索引存储在 HashMap 中。

23. Java 程序，用于查找数组中两个整数的最大乘积。

为了找到数组中两个整数的最大乘积，我们遍历数组并跟踪最大和第二大元素。我们将 max1 和 max2 初始化为尽可能小的整数值。然后，对于每个元素，我们将其与 max1 进行比较并相应地更新 max2 和 max1。遍历数组后，最大乘积是 max1 和 max2 的乘积，因为 max1 将保存最大元素，max2 将保存第二大元素。

示例

public class Main {  
    public static int findMaximumProduct(int[] arr)  {  
      int max1=Integer.MIN_VALUE; // Initialize the maximum element to the smallest possible value  
        int max2=Integer.MIN_VALUE; // Initialize the second maximum element to the smallest possible value  
        for (int num:arr)    {  
            if (num>max1)    {  
                max2=max1; // Update the second maximum element  
                max1=num; // Update the maximum element  
            }   
            else if (num>max2)    {  
                max2=num; // Update the second maximum element  
            }  
        }  
        return max1*max2; // Return the maximum product  
    }  
    public static void main(String[] args)    {  
        int[] arr={1,2,3,4,5};  
        int maximumProduct=findMaximumProduct(arr);  
        System.out.println("Maximum Product: "+maximumProduct);  
    }  
}  

编译并运行

输出

Maximum Product: 20

复杂度分析

此方法的时间复杂度为 O(n)，其中 n 是数组的大小。

空间复杂度为 O(1)，因为我们只使用恒定的额外空间来存储最大和第二大元素。

24. Java 程序，用于查找和大于给定值的最小子数组长度。

为了找到和大于给定值的最小子数组长度，我们可以利用滑动窗口技术。该方法涉及维护一个在计算当前和时扩展和收缩的窗口。我们从一个空窗口开始，并通过从右端添加元素来逐渐扩展它。如果当前和超过给定值，我们更新子数组的最小长度。然后，直到当前总和小于或等于指定值，我们通过消除项目从左端收缩窗口。直到我们到达数组末尾，我们一直这样做。

示例

public class Main{  
    public static int findSmallestSubarray(int[] arr,int target)   {  
        int minLength=Integer.MAX_VALUE; // Variable to store the minimum length of the subarray  
        int currentSum=0; // Variable to track the current sum of the subarray  
        int left=0; // Left pointer to mark the start of the subarray  
        int right=0; // Right pointer to mark the end of the subarray  
        while (right<arr.length) {  
        currentSum+=arr[right]; // Add the element at the right pointer to the current sum            while (currentSum>target)   {  
  minLength=Math.min(minLength,rightleft+1); // Update the minimum length if necessary  
    currentSum=arr[left]; // Subtract the element at the left pointer from the current sum
                left++; // Move the left pointer to the right to contract the window  
            }  
            right++; // Move the right pointer to the right to expand the window  
        }  
        return (minLength==Integer.MAX_VALUE)?-1:minLength;   
    }  
    public static void main(String[] args)   {  
        int[] arr={1, 4, 45, 6, 0, 19};  
        int target=51;  
        int smallestSubarrayLength=findSmallestSubarray(arr,target);  
        System.out.println("Smallest Subarray Length: "+smallestSubarrayLength);  
    }  
}  

编译并运行

输出

Smallest Subarray Length: 3

复杂度分析

此方法的时间复杂度为 O(n)，其中 n 是数组的大小。

空间复杂度为 O(1)，因为我们只使用恒定的额外空间来存储变量。

25. Java 程序，用于查找数组中和最小的三元组。

我们可以借助三个变量（一个大小为三的整数数组也可以）并使用循环来找到给定数组中存在的最小元素。我们将寻找最小元素，因为我们必须找到最小和。

示例

public class Main   {  
public static void findSmallestTripletSum(int[] arr)  {  
int n = arr.length; // finding the size  
// for storing the first three minimum values present in the given array.  
int fMin = Integer.MAX_VALUE;  
int sMin = Integer.MAX_VALUE;  
int tMin = Integer.MAX_VALUE;   
for (int i = 0; i < n; i++)   {   
// getting the first, second and third minimum elements   
if (arr[i] < fMin)   {   
    tMin = sMin;   
    sMin = fMin;   
    fMin = arr[i];   
}   
// updating the second and third minimum elements   
else if (arr[i] < sMin)   {   
    tMin = sMin;   
    sMin = arr[i];   
}   
else if (arr[i] < tMin)   {   
    tMin = arr[i];   
}   
}  
// print statement  
System.out.println("The Triplet with the smallest sum is: {"+ fMin + ", " + sMin + ", " + tMin + "}");  
}  
// main method  
public static void main(String[] args)   {  
int[] arr = {5, 1, -3, -4, -2, 6};  
findSmallestTripletSum(arr);  
}  
}  

编译并运行

输出

The Triplet with the smallest sum is: {-4, -3, -2}

复杂度分析

此方法的时间复杂度为 O(n)，因为程序中只使用了一个循环。

空间复杂度为 O(1)，因为我们没有使用任何随输入大小增长的额外空间。

26. Java 程序，用于将数组的所有元素加一。

输入数组定义为 {1, 2, 3, 4, 5}。方法 incrementArrayElements(int[] array) 接受一个数组作为参数。然后它使用 for 循环遍历数组中的每个元素。增量操作：在循环内部，代码 array[i]++ 将每个元素加一。最终输出在 main() 方法中打印，其中显示递增后的数组元素。

示例

public class Main {  
    public static void main(String[] args) {  
        int[] array = {1, 2, 3, 4, 5};  
        incrementArrayElements(array);  
        // Print the incremented array  
        for (int i = 0; i < array.length; i++) {  
            System.out.print(array[i] + " ");  
        }  
    }  
    public static void incrementArrayElements(int[] array) {  
        for (int i = 0; i < array.length; i++) {  
            array[i]++;  
        }  
    }  
} 

编译并运行

输出

2 3 4 5 6

27. Java 程序，用于将所有零移动到数组的末尾。

对于这种方法，我们遍历数组两次。在第一次遍历中，我们执行以下操作：

遍历数组，同时计数非零元素。将计数初始化为 0，这也表示数组中下一个非零元素的位置。
对于每个非零元素，将其放置在 arr[count] 处，然后将计数增加 1。
一旦处理完所有元素，所有非零条目将移动到前面，保持其原始序列。

在第二次遍历中，我们执行以下操作：

在初始遍历之后，所有非零元素将占据数组的开头，而变量“count”将指示第一个零的位置。
从“count”开始到数组末尾，用 0 填充所有后续索引。

示例

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 0, 2, 0, 3, 0, 4, 0};
        int n = arr.length;  //finding array length
        int count = 0;
        for (int i = 0; i < n; i++) { //loop iterate over the array
            if (arr[i] != 0) {  //compare if the array element is equals to zero or not
                arr[count++] = arr[i];  //
            }
        }
        while (count < n) {
            arr[count++] = 0;
        }
        System.out.println("Array after moving zeroes: " + java.util.Arrays.toString(arr));
    }
}

编译并运行

输出

Array after moving zeroes: [1, 2, 3, 4, 0, 0, 0, 0]

28. 反转数组而不改变零的位置。

为了解决这个问题，该方法涉及从两端遍历数组并交换非零元素直到到达中心。在此过程中，零的位置保持不变。代码使用 while 循环跳过零，同时从末尾递减索引。当检测到非零元素时，它会与另一端的相应非零元素交换。这种交换一直持续到到达数组的中心。

示例

import java.util.Arrays;
public class Main {
// Print function
public static void printReverse(int[] arr) {
    // Print the original array
    System.out.print("Original array: ");
    System.out.println(Arrays.toString(arr));
    // Reverse the array without changing the position of zeroes
    // Initialize the index to the last element
    int j = arr.length - 1;
    for (int i = 0; i < j; i++) {
    // If the current element is zero, skip to the next element
    if (arr[i] == 0) {
        continue;
    }
    // If the current element is zero from the end
    while (j > i && arr[j] == 0) {
        // Decrement the index to the previous element
        j--;
    }
    // Swap the elements
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    // Decrement the index to the previous element
    j--;
    }
    // Prints the reversed array
    System.out.print("Reversed array: ");
    System.out.println(Arrays.toString(arr));
}
public static void main(String[] args) {
    int[] arr = { 6, 0, 8, 0, 2, 0, 1 };
    printReverse(arr);
}
}

编译并运行

输出

Original array: [6, 0, 8, 0, 2, 0, 1]
Reversed array: [1, 0, 2, 0, 8, 0, 6]

29. Java 程序，用于查找数组中的领导元素。

给定一个大小为 n 的数组 arr[]，任务是找到数组中的所有领导元素。如果一个元素大于或等于其右侧的所有元素，则它是一个领导元素。

注意：最右边的元素总是领导元素。

示例

public class Main {
    public static void main(String[] args) {
        int[] arr = {12, 11, 4, 7, 9, 6, 8, 15};
        int n = arr.length;
        int maxFromRight = arr[n - 1];
        System.out.print("Leader is: " + maxFromRight + " ");
        for (int i = n - 2; i >= 0; i--) {
            if (arr[i] > maxFromRight) {
                maxFromRight = arr[i];
                System.out.print(maxFromRight + " ");
            }
        }
    }
}

编译并运行

输出

Leader is: 15

30. Java 程序，用于查找所有非空子数组。

要创建子数组，我们首先需要原始数组中的起始索引。我们可以通过遍历范围 [0 到 n-1] 并将每个索引 i 视为潜在的起始点来选择此起始索引。对于每个选定的起始索引 i，我们然后从范围 [i 到 n-1] 确定一个结束索引。一个从 [i 到 n-1] 运行的嵌套循环将有助于选择结束索引。一旦起始索引和结束索引都确定，就需要一个最内层的循环来打印子数组的元素。

示例

import java.util.ArrayList;
public class Main {
    //Prints all subarrays in arr[0..n-1]
    static void findSubArray(ArrayList<Integer> arr) {
        int n = arr.size();
        // Pick starting point
        for (int i = 0; i < n; i++) {         
            // Pick ending point
            for (int j = i; j < n; j++) {             
                // Print subarray between current starting and ending points
                for (int k = i; k <= j; k++) {
                    System.out.print(arr.get(k) + " ");
                }
                System.out.println();
            }
        }
    }
    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(2);
        arr.add(3);
        System.out.println("Subarrays are:");
        findSubArray(arr);
    }
}

编译并运行

输出

Subarrays are:
1 
1 2 
1 2 3 
2 
2 3 
3

下一主题Java 中的 Arrays 类

← 上一页下一页 →

相关帖子

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

关注我们

教程

Java 数据结构 C 语言 C++ 教程 C# 教程 PHP 教程 HTML 教程 JavaScript 教程 jQuery 教程 Spring 教程

面试题

Microsoft Amazon Adobe Intuit Accenture Cognizant Capgemini Wipro Tcs Infosys

在线编译器

C R C++ Php Java Html Swift Python JavaScript TypeScript

最新帖子 | 教程列表 | 隐私政策 | 关于我们 | 联系我们

© 版权所有 2011 - 2025 TpointTech.com。保留所有权利。