选择排序

1、简单选择排序

每一趟排序都会得到数值最小的元素，按顺序放在已排好的序列的最后

• 代码实现

public static void SelectionSort1(int nums[]) {

        for(int i= 0; i < nums.length - 1; i++) {

            for(int j = i + 1; j < nums.length; j++) {
                if(nums[j] < nums[i]) {
                    huan(nums, i, j);
                }
            }
        }

    }

    public static void huan(int[] nums, int i, int j) {
        int c;
        c = nums[i];
        nums[i] = nums[j];
        nums[j] = c;
    }

• 测试结果

public static void main(String[] args) {
        int[] nums = {23, 4, 56, 166, 2};
        SelectionSort1(nums);
        for(int i : nums) {
            System.out.println(i);
        }
    }

2、堆排序
利用堆进行排序的算法。
基本思想 ： 将待排序的序列构造成一个大顶堆，此时，整个序列最大的元素就是堆顶的值，将他移走，即将他与堆数组的末尾交换，此时末尾为最大元素。然后剩余的n - 1个序列重新构造成一个堆，重复上述操作。

• 堆的概念
  堆是顺序存储的完全二叉树，其中大顶堆是非叶结点大于左右子结点的完全二叉树，小顶堆是非叶结点小于左右子结点的完全二叉树。

public static void SortAlgorithm6(int[] init) {

        int temp = -1;
        //初始化大顶堆
        for(int i = init.length / 2 - 1; i >= 0; i--) {
            maxHeadHeap(init, i, init.length - 1);
        }

        for(int j = init.length - 1; j >= 0; j--) {
            temp = init[j];
            init[j] = init[0];
            init[0] = temp;
            maxHeadHeap(init, 0, j - 1);
        }
    }

    public static void maxHeadHeap(int[] init, int index, int indexLast) {

        int left = index * 2 + 1;
        int right = index * 2 + 2;
        int max = index;

        if(left <= indexLast && init[left] > init[max]) {

            max = left;
        }

        if(right <= indexLast && init[right] > init[max]) {

            max = right;
        }

        if(max != index) {

            int temp = init[index];
            init[index] = init[max];
            init[max] = temp;
            maxHeadHeap(init, max, indexLast);
        }
    }

    //对未排序序列进行重置
    public static void maxHeadHeap(int[] init, int index) {

        int left = index * 2 + 1;
        int right = index * 2 + 2;

        if(left > init.length) {
            return;
        }

        int max = index;

        if(init[left] > init[index]) {
            max = left;
        }

        if(right < init.length && init[right] > init[max]) {

            max = right;
        }

        if(max != index) {

            int temp = init[index]; 
            init[index] = init[max];
            init[max] = temp;
        }
    }

• 测试结果

public static void main(String[] args) {
        int[] list = {1, 3, 2, 5, 7, 6, 9, 4, 10};
        SortAlgorithm6(list);

        for(int i : list) {
            System.out.println(i);
        }
    }

• 总结
  多上网学习~