Java高级编程技术与算法应用全解析

遗传算法

Java中的遗传算法

遗传算法通过模拟自然选择和遗传机制来寻找最优解。本文将介绍遗传算法的基本概念及其Java实现。

遗传算法的基本概念

遗传算法通过选择、交叉和变异等操作来优化问题。

示例代码：简单的遗传算法

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

class Individual {
    int[] genes;
    int fitness;

    /**
     * 构造函数，随机初始化个体的基因
     * @param geneLength 基因长度
     */
    public Individual(int geneLength) {
        genes = new int[geneLength];
        Random rand = new Random();
        for (int i = 0; i < geneLength; i++) {
            genes[i] = rand.nextInt(2);
        }
        calculateFitness();
    }

    /**
     * 计算个体的适应度
     */
    public void calculateFitness() {
        fitness = 0;
        for (int gene : genes) {
            fitness += gene;  // 简单的适应度函数，基因值的和
        }
    }
}

public class GeneticAlgorithm {
    private static final int POPULATION_SIZE = 100;
    private static final int GENE_LENGTH = 10;
    private static final int GENERATIONS = 50;
    private static final double MUTATION_RATE = 0.01;

    public static void main(String[] args) {
        List<Individual> population = new ArrayList<>();
        for (int i = 0; i < POPULATION_SIZE; i++) {
            population.add(new Individual(GENE_LENGTH));  // 初始化种群
        }

        for (int generation = 0; generation < GENERATIONS; generation++) {
            population.sort((i1, i2) -> Integer.compare(i2.fitness, i1.fitness));  // 根据适应度排序
            System.out.println("Generation " + generation + " Best fitness: " + population.get(0).fitness);  // 输出最佳适应度

            List<Individual> newPopulation = new ArrayList<>();
            for (int i = 0; i < POPULATION_SIZE / 2; i++) {
                Individual parent1 = population.get(new Random().nextInt(POPULATION_SIZE / 2));
                Individual parent2 = population.get(new Random().nextInt(POPULATION_SIZE / 2));
                Individual offspring = crossover(parent1, parent2);  // 交叉
                mutate(offspring);  // 变异
                newPopulation.add(offspring);  // 添加后代到新种群
            }
            population = newPopulation;  // 更新种群
        }
    }

    /**
     * 交叉操作
     * @param parent1 父代1
     * @param parent2 父代2
     * @return 后代
     */
    private static Individual crossover(Individual parent1, Individual parent2) {
        Individual offspring = new Individual(GENE_LENGTH);
        for (int i = 0; i < GENE_LENGTH; i++) {
            offspring.genes[i] = new Random().nextBoolean() ? parent1.genes[i] : parent2.genes[i];  // 随机选择父代的基因
        }
        offspring.calculateFitness();
        return offspring;
    }

    /**
     * 变异操作
     * @param individual 个体
     */
    private static void mutate(Individual individual) {
        Random rand = new Random();
        for (int i = 0; i < GENE_LENGTH; i++) {
            if (rand.nextDouble() < MUTATION_RATE) {
                individual.genes[i] = 1 - individual.genes[i];  // 随机变异
            }
        }
        individual.calculateFitness();
    }
}

分治法

Java中的分治法

分治法是解决复杂问题的一种重要算法设计策略。本文将介绍分治法的基本概念及其Java实现。

分治法的基本思想

分治法将问题分解为子问题，递归解决子问题，然后合并子问题的解。

示例代码：归并排序

import java.util.Arrays;

public class MergeSort {
    /**
     * 归并排序主函数
     * @param arr 输入数组
     * @return 排序后的数组
     */
    public static int[] mergeSort(int[] arr) {
        if (arr.length <= 1) {
            return arr;  // 基本情况，数组长度小于等于1
        }
        int mid = arr.length / 2;
        int[] left = mergeSort(Arrays.copyOfRange(arr, 0, mid));  // 递归排序左半部分
        int[] right = mergeSort(Arrays.copyOfRange(arr, mid, arr.length));  // 递归排序右半部分
        return merge(left, right);  // 合并排序后的左右部分
    }

    /**
     * 合并两个有序数组
     * @param left 左半部分
     * @param right 右半部分
     * @return 合并后的有序数组
     */
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0, j = 0, k = 0;

        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                result[k++] = left[i++];  // 左边元素较小，放入结果数组
            } else {
                result[k++] = right[j++];  // 右边元素较小，放入结果数组
            }
        }
        while (i < left.length) {
            result[k++] = left[i++];  // 将剩余的左边元素放入结果数组
        }
        while (j < right.length) {
            result[k++] = right[j++];  // 将剩余的右边元素放入结果数组
        }
        return result;
    }

    public static void main(String[] args) {
        int[] numbers = {3, 6, 1, 5, 2, 4};
        int[] sortedNumbers = mergeSort(numbers);
        System.out.println(Arrays.toString(sortedNumbers));  // 输出排序后的数组
    }
}

数据结构优化

Java中的数据结构优化

高效的数据结构对程序性能有显著影响。本文将介绍一些常用的数据结构及其优化方法。

自定义哈希表

哈希表是一种高效的数据结构，用于快速查找、插入和删除。

示例代码：自定义哈希表

import java.util.LinkedList;

class CustomHashTable<K, V> {
    private static final int INITIAL_CAPACITY = 16;
    private LinkedList<Entry<K, V>>[] buckets;

    /**
     * 构造函数，初始化哈希表
     */
    public CustomHashTable() {
        buckets = new LinkedList[INITIAL_CAPACITY];
        for (int i = 0; i < INITIAL_CAPACITY; i++) {
            buckets[i] = new LinkedList<>();
        }
    }

    static class Entry<K, V> {
        final K key;
        V value;

        public Entry(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }

    /**
     * 计算键的哈希值
     * @param key 键
     * @return 哈希值
     */
    private int getBucketIndex(K key) {
        return key.hashCode() % buckets.length;
    }

    /**
     * 插入键值对
     * @param key 键
     * @param value 值
     */
    public void put(K key, V value) {
        int index = getBucketIndex(key);
        LinkedList<Entry<K, V>> bucket = buckets[index];
        for (Entry<K, V> entry : bucket) {
            if (entry.key.equals(key)) {
                entry.value = value;  // 更新已有键的值
                return;
            }
        }
        bucket.add(new Entry<>(key, value));  // 插入新的键值对
    }

    /**
     * 获取键对应的值
     * @param key 键
     * @return 值，如果不存在则返回null
     */
    public V get(K key) {
        int index = getBucketIndex(key);
        LinkedList<Entry<K, V>> bucket = buckets[index];
        for (Entry<K, V> entry : bucket) {
            if (entry.key.equals(key)) {
                return entry.value;  // 返回找到的值
            }
        }
        return null;  // 键不存在
    }

    public static void main(String[] args) {
        CustomHashTable<String, Integer> table = new CustomHashTable<>();
        table.put("apple", 1);
        table.put("banana", 2);
        System.out.println("Value for 'apple': " + table.get("apple"));  // 输出值
        System.out.println("Value for 'banana': " + table.get("banana"));  // 输出值
    }
}

优化数据结构

通过选择合适的数据结构，可以提高程序性能。例如，使用平衡树（如红黑树）来优化查找和插入操作。

示例代码：红黑树

import java.util.Map;
import java.util.TreeMap;

public class RedBlackTreeExample {
    public static void main(String[] args) {
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("apple", 1);
        treeMap.put("banana", 2);
        treeMap.put("cherry", 3);

        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());  // 输出键值对
        }
    }
}