java初学必会代码

原创已于 2024-06-14 14:21:45 修改 · 253 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #排序算法 #算法

于 2024-06-14 13:26:58 首次发布

java中数组的使用

一维数组

说明：

在Java中，一维数组是一种数据结构，用于存储相同类型的多个元素。以下是一维数组的使用方法：

1. 定义一维数组：使用数组类型后面跟上方括号 []，然后指定数组的大小。例如：int[] numbers = new int[5];

2. 初始化一维数组：可以在定义数组时直接赋值，或者后续给数组的某个元素赋值。例如：int[] numbers = {1, 2, 3, 4, 5}; 或者 numbers[0] = 1;

3. 访问一维数组元素：通过下标来访问数组元素，下标从0开始。例如：int firstNumber = numbers[0];

4. 获取一维数组长度：使用数组的 length 属性来获取数组的长度。例如：int length = numbers.length;

5. 遍历一维数组：可以使用循环来遍历整个数组元素。例如：for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); }

6. 处理一维数组元素：可以对数组元素进行各种操作，例如修改元素的值、计算元素的和或平均值等。

注意事项：
- 数组的大小在创建时就已经确定，不能动态改变数组的大小。
- 数组下标越界会导致异常错误，所以需要确保在访问数组元素时下标的范围是有效和合法的。

代码实现

public class Main {
    public static void main(String[] args) {
        // 定义并初始化一个一维数组
        int[] numbers = {1, 2, 3, 4, 5};

        // 访问一维数组元素
        int firstNumber = numbers[0];
        System.out.println("First number: " + firstNumber);

        // 获取一维数组的长度
        int length = numbers.length;
        System.out.println("Array length: " + length);

        // 遍历一维数组并打印每个元素
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Number at index " + i + ": " + numbers[i]);
        }
    }
}

运行结果

First number: 1
Array length: 5
Number at index 0: 1
Number at index 1: 2
Number at index 2: 3
Number at index 3: 4
Number at index 4: 5

二维数组

在Java中，二维数组是一种特殊的数组，它是由多个一维数组组成的。二维数组在内存中是一个表格，可以表示行和列的关系。

创建二维数组：可以使用以下方式创建一个二维数组：

// 声明并初始化一个二维数组matrix
int[][] matrix = new int[rowCount][columnCount];

访问二维数组元素：可以使用索引来访问二维数组中的元素。第一个索引表示行号，第二个索引表示列号。

int element = matrix[rowIndex][columnIndex];

获取二维数组的行数和列数：可以使用length属性来获取二维数组的行数和列数。对于二维数组matrix，matrix.length表示行数，matrix[0].length表示列数（假设所有行的列数都相同）。

int rows = matrix.length; // 行数
int columns = matrix[0].length; // 列数

遍历二维数组：可以使用嵌套的循环来遍历二维数组，并访问每个元素。

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        // 访问 matrix[i][j]
    }
}

二维数组可以用于解决各种问题，例如表示矩阵、游戏棋盘等。

java中的排序

在Java中，有多种排序方法，包括使用内置的排序方法，如Arrays.sort()或Collections.sort()，以及实现自己的排序算法（如冒泡排序、插入排序、选择排序、快速排序、归并排序等）。以下是一些示例：

1. 使用Arrays.sort()进行排序：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] array = {5, 2, 9, 1, 5, 6};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

2. 使用Collections.sort()进行排序：

3. 冒泡排序：

public class Main {
    public static void main(String[] args) {
        int[] array = {5, 2, 9, 1, 5, 6};
        bubbleSort(array);
        for (int i : array) {
            System.out.print(i + " ");
        }
    }

    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // swap array[j+1] and array[i]
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

4. 快速排序：

public class Main {
    public static void main(String[] args) {
        int[] array = {5, 2, 9, 1, 5, 6};
        quickSort(array, 0, array.length - 1);
        for (int i : array) {
            System.out.print(i + " ");
        }
    }

    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pi = partition(array, low, high);
            quickSort(array, low, pi - 1);
            quickSort(array, pi + 1, high);
        }
    }

    public static int partition(int[] array, int low, int high) {
        int pivot = array[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (array[j] <= pivot) {
                i++;
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;
        return i + 1;
    }
}

5.选择排序 (Selection Sort)

选择排序的工作方式是首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

public class SelectionSort {
    public static void selectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int temp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {64, 25, 12, 22, 11};
        selectionSort(array);
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

6.归并排序 (Merge Sort):

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

7.插入排序 (InsertionSort)

在Java中，插入排序是一种简单的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。以下是插入排序的Java代码示例：

public class InsertionSort {
public static void main(String[] args) {
int[] array = {5, 2, 9, 1, 5, 6};
insertionSort(array);
for (int i : array) {
System.out.print(i + " ");
}
}

public static void insertionSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int key = array[i];
int j = i - 1;

// Move elements of array[0..i-1], that are greater than key,
// to one position ahead of their current position
while (j >= 0 && array[j] > key) {
array[j + 1] = array[j];
j = j - 1;
}
array[j + 1] = key;
}
}
}