Java函数实现常用算法举例

1. 排序算法：如冒泡排序、插入排序、选择排序、快速排序等。

// 冒泡排序
public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                // 交换相邻元素
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

// 插入排序
public static void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

// 选择排序
public static void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++) {
        int minIndex = i;
        for (int j = i+1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

// 快速排序
public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);
        quickSort(arr, low, pivot - 1);
        quickSort(arr, pivot + 1, high);
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivot = arr[low];
    while (low < high) {
        while (low < high && arr[high] >= pivot) {
            high--;
        }
        arr[low] = arr[high];
        while (low < high && arr[low] <= pivot) {
            low++;
        }
        arr[high] = arr[low];
    }
    arr[low] = pivot;
    return low;
}

2. 查找算法：如顺序查找、二分查找等。

// 顺序查找
public static int sequentialSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

// 二分查找（递归实现）
public static int binarySearch(int[] arr, int target, int low, int high) {
    if (low <= high) {
        int mid = (low + high) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] > target) {
            return binarySearch(arr, target, low, mid - 1);
        } else {
            return binarySearch(arr, target, mid + 1, high);
        }
    }
    return -1;
}

3. 矩阵运算：如矩阵相加、矩阵乘法等。

// 矩阵加法
public static int[][] matrixAddition(int[][] matrix1, int[][] matrix2) {
    int m = matrix1.length;
    int n = matrix1[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] = matrix1[i][j] + matrix2[i][j];
        }
    }
    return result;
}

// 矩阵乘法
public static int[][] matrixMultiplication(int[][] matrix1, int[][] matrix2) {
    int m = matrix1.length;
    int n = matrix1[0].length;
    int p = matrix2[0].length;
    int[][] result = new int[m][p];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < p; j++) {
            for (int k = 0; k < n; k++) {
                result[i][j] += matrix1[i][k] * matrix2[k][j];
            }
        }
    }
    return result;
}

4. 图算法：如深度优先搜索（DFS）和广度优先搜索（BFS）等。

// 深度优先搜索
public static void depthFirstSearch(int[][] graph, boolean[] visited, int vertex) {
    visited[vertex] = true;
    System.out.print(vertex + " ");
    for (int i = 0; i < graph.length; i++) {
        if (!visited[i] && graph[vertex][i] != 0) {
            depthFirstSearch(graph, visited, i);
        }
    }
}

// 广度优先搜索
public static void breadthFirstSearch(int[][] graph, boolean[] visited, int start) {
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(start);
    visited[start] = true;
    while (!queue.isEmpty()) {
        int vertex = queue.poll();
        System.out.print(vertex + " ");
        for (int i = 0; i < graph.length; i++) {
            if (!visited[i] && graph[vertex][i] != 0) {
                queue.offer(i);
                visited[i] = true;
            }
        }
    }
}

以上仅是常见算法的简单实现，实际应用中可能会有更复杂的情况需要考虑。这些算法的实例可作为学习和理解算法思想的起点，在实际应用中可以根据具体需求进行优化和调整。