正文

Java编程必备：精选算法练习题助你提升编程技能

/0 浏览量
1012

在Java编程的世界里，算法是基石。掌握各种算法不仅能够帮助你解决实际问题，还能提升你的编程思维和逻辑能力。本文将为你精选一系列适合Java编程者的算法练习题，助你提升编程技能。

基础算法

1. 排序算法

冒泡排序

public class BubbleSort {
    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 class SelectionSort {
    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;
        }
    }
}

2. 查找算法

二分查找

public class BinarySearch {
    public static int binarySearch(int[] arr, int key) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == key) {
                return mid;
            } else if (arr[mid] < key) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }
}

中级算法

1. 动态规划

斐波那契数列

public class Fibonacci {
    public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        int[] fib = new int[n + 1];
        fib[0] = 0;
        fib[1] = 1;
        for (int i = 2; i <= n; i++) {
            fib[i] = fib[i - 1] + fib[i - 2];
        }
        return fib[n];
    }
}

2. 栈和队列

栈实现

public class Stack {
    private int[] elements;
    private int size;
    private int capacity;

    public Stack(int capacity) {
        this.capacity = capacity;
        elements = new int[capacity];
        size = 0;
    }

    public void push(int element) {
        if (size == capacity) {
            throw new IllegalStateException("Stack is full");
        }
        elements[size++] = element;
    }

    public int pop() {
        if (size == 0) {
            throw new IllegalStateException("Stack is empty");
        }
        return elements[--size];
    }
}

高级算法

1. 图算法

深度优先搜索

public class DFS {
    private boolean[] visited;
    private List<Integer> path;

    public DFS(int[][] graph) {
        visited = new boolean[graph.length];
        path = new ArrayList<>();
    }

    public void dfs(int start) {
        visited[start] = true;
        path.add(start);
        for (int i = 0; i < graph[start].length; i++) {
            int neighbor = graph[start][i];
            if (!visited[neighbor]) {
                dfs(neighbor);
            }
        }
    }
}

通过以上精选的算法练习题，相信你能够在Java编程的道路上越走越远。不断练习，积累经验，你将能够应对各种复杂的编程挑战。祝你在编程的世界里一帆风顺！

-- 展开阅读全文 --