基本排序算法

Java 中有多种排序算法，包括冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序等。这些算法在复杂度、稳定性和适用性上有所不同。以下是一些基本排序算法的 Java 实现：
 

1、冒泡排序 (Bubble Sort)

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

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]) {  
                // swap arr[j+1] and arr[j]  
                int temp = arr[j];  
                arr[j] = arr[j + 1];  
                arr[j + 1] = temp;  
            }  
        }  
    }  
}

2、选择排序 (Selection Sort)

选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

public static void selectionSort(int[] arr) {  
    int n = arr.length;  
    for (int i = 0; i < n - 1; i++) {  
        int min_idx = i;  
        for (int j = i + 1; j < n; j++) {  
            if (arr[j] < arr[min_idx]) {  
                min_idx = j;  
            }  
        }  
        // Swap the found minimum element with the first element  
        int temp = arr[min_idx];  
        arr[min_idx] = arr[i];  
        arr[i] = temp;  
    }  
}

3、插入排序 (Insertion Sort)

插入排序的工作方式是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

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;  
        /* Move elements of arr[0..i-1], that are  
           greater than key, to one position ahead  
           of their current position */  
        while (j >= 0 && arr[j] > key) {  
            arr[j + 1] = arr[j];  
            j = j - 1;  
        }  
        arr[j + 1] = key;  
    }  
}

4、归并排序（Merge Sort）

归并排序是一种分治思想的排序算法。它将待排序的数组分成两个子数组，分别对这两个子数组进行排序，然后将排序好的子数组合并成一个有序的数组。

public class MergeSort {  
    public static void mergeSort(int[] arr) {  
        if (arr == null || arr.length < 2) {  
            return;  
        }  
        mergeSort(arr, 0, arr.length - 1);  
    }  
  
    private static void mergeSort(int[] arr, int left, int right) {  
        if (left < right) {  
            int mid = left + (right - left) / 2;  
            mergeSort(arr, left, mid);  
            mergeSort(arr, mid + 1, right);  
            merge(arr, left, mid, right);  
        }  
    }  
  
    private static void merge(int[] arr, int left, int mid, int right) {  
        int[] temp = new int[right - left + 1];  
        int i = left, j = mid + 1, k = 0;  
        while (i <= mid && j <= right) {  
            if (arr[i] <= arr[j]) {  
                temp[k++] = arr[i++];  
            } else {  
                temp[k++] = arr[j++];  
            }  
        }  
        while (i <= mid) {  
            temp[k++] = arr[i++];  
        }  
        while (j <= right) {  
            temp[k++] = arr[j++];  
        }  
        for (i = 0; i < temp.length; i++) {  
            arr[left + i] = temp[i];  
        }  
    }  
}

5、快速排序（Quick Sort）

快速排序也是一种分治思想的排序算法。它选择一个基准元素，将数组中小于基准的元素移到基准的左边，大于基准的元素移到基准的右边，然后分别对左右两个子数组进行递归排序。

public class QuickSort {  
    public static void quickSort(int[] arr) {  
        if (arr == null || arr.length < 2) {  
            return;  
        }  
        quickSort(arr, 0, arr.length - 1);  
    }  
  
    private static void quickSort(int[] arr, int left, int right) {  
        if (left < right) {  
            int pivotIndex = partition(arr, left, right);  
            quickSort(arr, left, pivotIndex - 1);  
            quickSort(arr, pivotIndex + 1, right);  
        }  
    }  
  
    private static int partition(int[] arr, int left, int right) {  
        int pivot = arr[right];  
        int i = left - 1;  
        for (int j = left; j < right; j++) {  
            if (arr[j] <= pivot) {  
                i++;  
                swap(arr, i, j);  
            }  
        }  
        swap(arr, i + 1, right);  
        return i + 1;  
    }  
  
    private static void swap(int[] arr, int i, int j) {  
        int temp = arr[i];  
        arr[i] = arr[j];  
        arr[j] = temp;  
    }  
}

6、堆排序（Heap Sort）

堆排序是利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。堆排序可以分为两个主要的过程：建堆和堆调整。

public class HeapSort {  
    void sort(int arr[]) {  
        int n = arr.length;  
  
        // Build heap (rearrange array)  
        for (int i = n / 2 - 1; i >= 0; i--)  
            heapify(arr, n, i);  
  
        // One by one extract an element from heap  
        for (int i=n-1; i>=0; i--) {  
            // Move current root to end  
            int temp = arr[0];  
            arr[0] = arr[i];  
            arr[i] = temp;  
  
            // call max heapify on the reduced heap  
            heapify(arr, i, 0);  
        }  
    }  
  
    // To heapify a subtree rooted with node i which is an index in arr[]. n is size of heap  
    void heapify(int arr[], int n, int i) {  
        int largest = i; // Initialize largest as root  
        int left = 2*i + 1; // left = 2*i + 1  
        int right = 2*i + 2; // right = 2*i + 2  
  
        // If left child is larger than root  
        if (left < n && arr[left] > arr[largest])  
            largest = left;  
  
        // If right child is larger than largest so far  
        if (right < n && arr[right] > arr[largest])  
            largest = right;  
  
        // If largest is not root  
        if (largest != i) {  
            int swap = arr[i];  
            arr[i] = arr[largest];  
            arr[largest] = swap;  
  
            // Recursively heapify the affected sub-tree  
            heapify(arr, n, largest);  
        }  
    }  
  
    // A utility function to print array of size n  
    static void printArray(int arr[]) {  
        int n = arr.length;  
        for (int i=0; i<n; ++i)  
            System.out.print(arr[i]+" ");  
        System.out.println();  
    }  
  
    // Test the code  
    public static void main(String args[]) {  
        int arr[] = {12, 11, 13, 5, 6, 7};  
        int n = arr.length;  
  
        HeapSort hs = new HeapSort();  
        hs.sort(arr);  
  
        System.out.println("Sorted array is");  
        printArray(arr);  
    }  
}