使用Java自带函数库实现常见的算法：排序、查找、哈希等

Java是一种广泛使用的编程语言，它提供了一个丰富的函数库，使得在Java中实现常见的算法非常容易。下面我们将介绍一些Java自带函数库中的常见算法。

排序算法

Java自带函数库中提供了多种排序算法，包括冒泡排序、插入排序、快速排序和归并排序等。

冒泡排序：BubbleSort

冒泡排序是指每次比较相邻的两个元素，如果它们的顺序错误，则交换之。通常经过多次迭代后，就可以将数组排序。

Java代码实现：

public class BubbleSort {
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

插入排序：InsertionSort

插入排序是一种简单的排序算法，它的排序方法是将数组中的元素逐个插入到已排好序的数组中，直到将所有元素都排序完成。

Java代码实现：

public class InsertionSort {
    public static void sort(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 = j - 1;
            }
            arr[j + 1] = key;
        }
    }
}

快速排序：QuickSort

快速排序是一种分治算法，它的排序过程是将数组分成两个子数组，然后递归地排序这两个子数组，最后将它们合并起来。

Java代码实现：

public class QuickSort {
    public static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);

            sort(arr, low, pi - 1);
            sort(arr, pi + 1, high);
        }
    }

    static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);

        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;

                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;
    }
}

归并排序：MergeSort

归并排序是一种分治算法，它将数组分成两个子数组，递归地排序这两个子数组，然后将它们合并起来。

Java代码实现：

public class MergeSort {
    public static void sort(int[] arr, int l, int r) {
        if (l < r) {
            int m = (l + r) / 2;

            sort(arr, l, m);
            sort(arr, m + 1, r);

            merge(arr, l, m, r);
        }
    }

    static void merge(int[] arr, int l, int m, int r) {
        int n1 = m - l + 1;
        int n2 = r - m;

        int L[] = new int[n1];
        int R[] = new int[n2];

        for (int i = 0; i < n1; ++i) {
            L[i] = arr[l + i];
        }
        for (int j = 0; j < n2; ++j) {
            R[j] = arr[m + 1 + j];
        }

        int i = 0, j = 0;
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
}

查找算法

Java自带函数库中提供了多种查找算法，包括二分查找和线性查找。

二分查找：BinarySearch

二分查找是一种在有序数组中查找给定元素的算法，它通过将数组分成两半来减少查找的时间。

Java代码实现：

public class BinarySearch {
    public static int search(int[] arr, int x) {
        int low = 0, high = arr.length - 1;

        while (low <= high) {
            int mid = (low + high) / 2;

            if (arr[mid] == x) {
                return mid;
            }

            if (arr[mid] < x) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }

        return -1;
    }
}

线性查找：LinearSearch

线性查找是一种在数组中查找给定元素的算法，它通过逐个比较数组中的元素来查找给定元素。

Java代码实现：

public class LinearSearch {
    public static int search(int[] arr, int x) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == x) {
                return i;
            }
        }

        return -1;
    }
}

哈希算法

Java自带函数库中提供了哈希算法，用于将任意长度的数据映射成固定长度的数据。

Java代码实现：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class HashFunction {
    public static String hash(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] hash = md.digest(input.getBytes());
            return bytesToHex(hash);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) sb.append('0');
            sb.append(hex);
        }
        return sb.toString();
    }
}

总结

Java自带函数库提供了一系列常见的算法，开发人员可以根据自己的需要选择适合的算法来实现不同的功能。上面介绍的算法只是其中的一部分，读者可以参考Java自带函数库的文档，了解更多的算法实现方式。