排序算法

排序算法

冒泡排序（Bubble Sort）

package Sort;

public class BubbleSort {
    public static void main(String[] args) {
        int[] nums = new int[]{3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
        bubbleSort(nums);
        for (int n : nums)
            System.out.println(n);
    }

    private static void bubbleSort(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; ++i) {
            boolean swapped = false;
            for (int j = 0; j < n - i - 1; ++j) {
                if (nums[j] > nums[j+1]) {
                    swap(nums, j, j+1);
                    swapped = true;
                }
            }
            // not change, exit loop
            if (!swapped) break;  
        }
    }

    private static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

选择排序（Selection Sort）

package Sort;

public class SelectionSort {
    public static void main(String[] args) {
        int[] nums = new int[]{29,10,14,37,13};
        selectionSort(nums);
        for (int n : nums)
            System.out.println(n);
    }

    private static void selectionSort(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n - 1; ++i) {
            // record index of min element
            int index = i;
            // search min element in array
            for (int j = i+1; j < n; ++j) {
                if (nums[index] > nums[j]) {
                    index = j;
                }
            }
            // execute change
            swap(nums, i, index);
        }
    }

    private static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

插入排序（Insertion Sort）

package Sort;

public class InsertionSort {
    public static void main(String[] args) {
        int[] nums = new int[]{6,7,4,5,3,1,2};
        insertionSort(nums);
        for (int n : nums)
            System.out.println(n);
    }

    private static void insertionSort(int[] nums) {
        int n = nums.length;
        // part sort to complete total sort
        for (int i = 1; i < n; ++i) {
            int inserted = nums[i];
            int j = i - 1;
            for (; j >= 0 && nums[j] > inserted; --j) {
                nums[j+1] = nums[j];
            }
            nums[j+1] = inserted;
        }
    }
}

快速排序（Quick Sort）

package Sort;

public class QuickSort {
    public static void main(String[] args) {
        int[] nums = new int[]{4,5,7,6,2,1,3};
        quickSort(nums, 0, nums.length-1);
        for (int n : nums)
            System.out.println(n);
    }

    private static void quickSort(int[] nums, int low, int high) {
        if (low < high) {
            int m = partition(nums, low, high);
            quickSort(nums, low, m-1);
            quickSort(nums, m+1, high);
        }
    }

    private static int partition(int[] nums, int i, int j) {
        // partition point
        int p = nums[i];
        int m = i;
        for (int k = i + 1; k <= j; ++k) {
            if (nums[k] < p) {
                m++;
                swap(nums, k, m);
            }
        }
        swap(nums, i, m);
        return m;
    }

    private static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

归并排序（Merge Sort）

package Sort;

public class MergeSort {
    public static void main(String[] args) {
        int[] nums = new int[] {2,3,1,5,4,7,8};
        mergeSort(nums, 0, nums.length-1);
        for (int n : nums)
            System.out.println(n);
    } 

    private static void mergeSort(int[] a, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            mergeSort(a, low, mid);
            mergeSort(a, mid+1, high);
            merge(a, low, mid, high);
        }
    }

    private static void merge(int[] a, int low, int mid, int high) {
         int left = low, right = mid + 1, bIdx = 0;
         int N = high - low + 1;
         int[] b = new int[N];
         while (left <= mid && right <= high) {
             b[bIdx++] = (a[left] <= a[right]) ? a[left++] : a[right++];
         }
         while (left <= mid) b[bIdx++] = a[left++];
         while (right <= high) b[bIdx++] = a[right++];
         for (int k = 0; k < N; ++k) a[low+k] = b[k];

    }
    
}