[Java]各种经典排序

来源：互联网发布：淘宝七匹狼钱包编辑：程序博客网时间：2024/05/22 03:45
package sort;  
  
import java.util.ArrayList;  
import java.util.List;  
  
public class SortMethods {  
    public static void main(String args[]) {  
        int a[] = { 5, 8, 1, 4, 3, 1, 2, 3, 7, 6 };  
        int size = a.length;  
  
        // BubbleSort(a, size);  
        // InsertSort(a, size);  
        SelectSort(a, size);  
        // QuickSort(a, size);  
        // HeapSort(a, size);  
        // ShellSort(a, size);  
        // MergeSort(a, size);  
        // CountSort(a, size);  
        print(a, size);  
    }  
  
    public static void print(int[] a, int size) {  
        for (int i = 0; i < size; i++) {  
            System.out.print(a[i] + " ");  
        }  
    }  
  
    // 冒泡排序  
    public static void BubbleSort(int[] a, int size) {  
        for (int i = 0; i < size; i++) {  
            for (int j = size - 1; j > i; j--) {  
                if (a[j] < a[j - 1]) {  
                    Swap(a, j - 1, j);  
                }  
            }  
        }  
    }  
  
    // 选择排序  
    public static void SelectSort(int[] a, int size) {  
        int min; // min指向最小数的下标  
        for (int i = 0; i < size; i++) {  
            min = i;  
            for (int j = i + 1; j < size; j++) {  
                if (a[min] > a[j]) {  
                    min = j;  
                }  
            }  
            if (min != i)  
                Swap(a, i, min);  
        }  
    }  
  
    // 插入排序  
    public static void InsertSort(int[] a, int size) {  
        int temp, j;  
        for (int i = 1; i < size; i++) {  
            temp = a[i];  
            j = i - 1;  
            while (j >= 0 && temp < a[j]) {  
                a[j + 1] = a[j];  
                j--;  
            }  
            a[j + 1] = temp;  
        }  
    }  
  
    // 快速排序  
    public static void QuickSort(int[] a, int size) {  
        RecQuickSort(a, 0, size - 1);  
    }  
  
    public static void RecQuickSort(int[] a, int low, int high) {  
        int p;  
        if (low < high) {  
            p = Partition(a, low, high);  
            RecQuickSort(a, low, p - 1);  
            RecQuickSort(a, p + 1, high);  
        }  
    }  
  
    public static int Partition(int[] a, int low, int high) {  
        int p = a[low];  
        while (low < high) {  
            while (low < high && a[high] >= p) {  
                high--;  
            }  
            a[low] = a[high];  
            while (low < high && a[low] <= p) {  
                low++;  
            }  
            a[high] = a[low];  
        }  
        a[low] = p;  
        return low;  
    }  
  
    // 堆排序  
    public static void HeapSort(int[] a, int size) {  
        BuildHeap(a, size);  
        for (int i = size - 1; i >= 0; i--) {  
            Swap(a, 0, i);  
            HeapAdjust(a, 0, i);  
        }  
    }  
  
    public static void BuildHeap(int[] a, int size) {  
        for (int i = size / 2 - 1; i >= 0; i--) {  
            HeapAdjust(a, i, size);  
        }  
    }  
  
    public static void HeapAdjust(int[] a, int i, int size) {  
        int temp = a[i];  
        int j = 2 * i + 1;  
        while (j < size) {  
            if (j + 1 < size && a[j + 1] > a[j])  
                j++;  
  
            if (a[j] < temp)  
                break;  
  
            a[i] = a[j];  
            i = j;  
            j = 2 * i + 1;  
        }  
        a[i] = temp;  
    }  
  
    // 希尔排序  
    public static void ShellSort(int[] a, int size) {  
        int temp, k;  
        for (int i = size / 2; i > 0; i /= 2) {  
            for (int j = i; j < size; j = j + i) {  
                temp = a[j];  
                k = j;  
                while (k - i >= 0 && temp < a[k - i]) {  
                    a[k] = a[k - i];  
                    k = k - i;  
                }  
                a[k] = temp;  
            }  
        }  
    }  
  
    // 归并排序  
    public static void MergeSort(int[] a, int size) {  
        RecMerge(a, 0, size - 1);  
    }  
  
    public static void RecMerge(int[] a, int low, int high) {  
        if (low < high) {  
            int middle = (low + high) / 2;  
            RecMerge(a, low, middle);  
            RecMerge(a, middle + 1, high);  
            Merge(a, low, middle, high);  
        }  
    }  
  
    public static void Merge(int[] a, int low, int middle, int high) {  
        int temp1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };  
        int temp2[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };  
        int n1 = middle - low + 1;  
        int n2 = high - middle;  
  
        for (int i = 0; i < n1; i++) {  
            temp1[i] = a[low + i];  
        }  
        for (int i = 0; i < n2; i++) {  
            temp2[i] = a[middle + i + 1];  
        }  
        temp1[n1] = 100;  
        temp2[n2] = 100;  
        int j = 0, k = 0;  
        for (int i = low; i <= high; i++) {  
            if (temp1[j] < temp2[k]) {  
                a[i] = temp1[j];  
                j++;  
            } else {  
                a[i] = temp2[k];  
                k++;  
            }  
        }  
    }  
  
    // 计数排序  
    public static void CountSort(int a[], int size) {  
        int MAX = 0;  
        for (int i = 0; i < size; i++) {  
            if (a[i] > MAX)  
                MAX = a[i];  
        }  
        MAX++;  
        List<Integer> temp = new ArrayList<Integer>();  
        for (int i = 0; i < MAX; i++) {  
            temp.add(i, 0);  
        }  
  
        for (int i = 0; i < size; i++) {  
            temp.set(a[i], (Integer) (temp.get(a[i])) + 1);  
        }  
  
        int j, k = 0;  
        for (int i = 0; i < MAX; i++) {  
            j = temp.get(i);  
            while (j != 0) {  
                a[k] = i;  
                k++;  
                j--;  
            }  
        }  
    }  
  
    public static void Swap(int a[], int i, int j) {  
        int temp;  
        temp = a[j];  
        a[j] = a[i];  
        a[i] = temp;  
    }  
}  
0 0