[算法入门笔记] 1. 常见排序算法

本篇主要介绍了常见排序算法的思想及其部分实现，如有不足，恳请指正，欢迎交流~

1. 选择排序

算法思想：从头至尾顺序扫描序列，找出最小的关键字，和第一个关键字交换，接着从剩下的关键字中继续选择和交换，最终使序列有序。

public static void selectionSort(int[] arr){
    //非法情况
    if (arr == null || arr.length < 2) {
        return;
    }
    for (int i = 0; i < arr.length - 1; ++i) {
        //minIndex记录最小值的下标
        int minIndex = i;
        //for循环表示无序序列部分
        for (int j = i + 1; j < arr.length; ++j) {
            //当找到更小的值则记录下来
            minIndex = arr[j] < arr[minIndex] ? j : minIndex;
        }
        //当前关键字和最小的交换
        swap(arr, i, minIndex);
    }
}

2. 冒泡排序

算法思想：首先第一个关键字和第二个关键字比较，如果第一个关键字比第二个关键字大，二者交换，否则不交换；然后第二个关键字和第三个关键字比较，如果第二个关键字比第三个关键字大，二者交换，否则不交换...。一直进行下去，一趟排序完成后，最大的关键字会交换到最后。经过多趟排序，最终使序列有序。

public static void bubbleSort(int[] arr) {
    //标记是否发生交换，一旦发生交换操作，flag更新为true
    boolean flag = false;
    //非法情况
    if (arr == null || arr.length < 2) {
        return;
    }
    //外循环控制无序序列范围
    for (int i = arr.length - 1; i > 0; --i) {
        flag = false;
        for (int j = 0; j < i; ++j) {
            if (arr[j] > arr[j + 1]) {
                utils.swap(arr, j, j + 1);
                flag = true;
            }
        }
        //一趟排序过程没发生交换，则序列有序
        if (flag == false) {
            return;
        }
    }
}

3. 插入排序

算法思想：每趟将一个待排序的关键字按照其值大小插入到已经排好序的部分有序序列的适当位置，直到所有待排关键字都被插入到有序序列中为止。

public static void insertionSort(int[] arr) {
	//非法情况
    if (arr == null || arr.length < 2) {
        return;
    }
    for (int i = 0; i < arr.length; ++i) {
        //在排好的部分有序序列中找出位置
        for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; --j) {
            utils.swap(arr, j, j + 1);
        }
    }
}

4. 归并排序

算法思想：将整个序列分成两半，对每一半进行归并排序，将得到两个有序序列，然后两个有序序列归并成一个序列即可。

public static void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int i = 0;
    int p1 = left;
    int p2 = mid + 1;
    //当左右两边都有元素
    while (p1 <= mid && p2 <= right) {
        temp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    //当左边元素有剩余
    while (p1 <= mid) {
        temp[i++] = arr[p1++];
    }
    //当右边元素有剩余
    while (p2 <= right) {
        temp[i++] = arr[p2++];
    }
    //重新拷贝回原始数组对应位置
    for (int j = 0; j < temp.length ; j++) {
        arr[left + j] = temp[j];
    }
}
public static void mergeSort(int[] arr, int left, int right) {
    if (left == right) {
        return;
    }
    int mid = left + ((right - left) >> 1);
    mergeSort(arr,left, mid);
    mergeSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

public static void mergeSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    mergeSort(arr, 0, arr.length - 1);
}

5. 堆排序

算法思想：将无序序列调整成大根堆，将堆顶元素与序列最后一个元素交换位置，此时有序序列增加一个，无序序列减少一个，对新的无序序列进行重复操作，即可实现排序。

public static void heapSort(int[] arr) {
	//非法情况
    if (arr == null || arr.length < 2) {
        return;
    }
    //插入操作
    for (int i = 0; i < arr.length; i++) {
        heapInsert(arr, i);
    }
    int size = arr.length;
    //将大顶堆的堆顶和末尾元素交换
    utils.swap(arr, 0, --size);
    while (size > 0) {
        //调整堆
        heapify(arr,0, size);
        //当前堆顶元素和当前堆中最后一个元素交换
        utils.swap(arr,0, --size);
    }
}

public static void heapInsert(int[] arr, int index) {
   //若孩子结点大于父亲结点，破坏了大根堆的性质，向上调整
    while (arr[index] > arr[(index - 1) / 2] ) {
        utils.swap(arr, index, (index - 1) / 2);
        //向上调整
        index = (index - 1) / 2;
    }
}

public static void heapify(int[] arr, int index, int size) {
    //left表示左孩子
    int left = index * 2 + 1;
    while (left < size) {
        //largest表示index结点两个孩子中较大的结点
        int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
        //当前结点和较大孩子结点比较
        largest = arr[largest] > arr[index] ? largest : index;
        //当前结点大于较大的孩子无需操作
        if (largest == index) {
            break;
        }
        //如果当前结点小的话，就与孩子结点交换
        utils.swap(arr, largest, index);
        //往下继续调整
        index = largest;
        left = index * 2 + 1;
    }
}

6. 快速排序

算法思想：通过多次枢轴划分操作实现排序，每趟选择当前所有子序列中的一个关键字作为枢轴，将子序列中比枢轴小的移动到枢轴前面，比枢轴大的移动到枢轴后面，划分结束，继续下一趟划分直到整个序列有序。

public static int[] partition(int[] arr, int left, int right) {
    int less = left - 1;
    int more = right;

    while (left <  more) {
        if (arr[left] < arr[right]) {
            utils.swap(arr, ++less, left++);
        } else if(arr[left] > arr[right]) {
            utils.swap(arr, --more, left);
        } else {
            left++;
        }
    }
    utils.swap(arr, more, right);
    return new int[] {less + 1, more};
}

public static void quickSort(int[] arr, int left, int right) {
    if (left < right) {
        utils.swap(arr, left + (int)(Math.random() * (right - left + 1)), right);
        int[] p = partition(arr, left, right);
        quickSort(arr, left, p[0] - 1);
        quickSort(arr, p[1] + 1, right);
    }
}

public static void quickSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    quickSort(arr, 0, arr.length - 1);
}

7. 桶排序

算法思想：多关键字排序，最低位优先。最低位关键字通过”分配“和”收集“的思想排成若干子序列，再对每个子序列进行更高位排序。

算法图解：

//主函数调用
public static void radixSort(int[] arr) {
    //非法情况
    if (arr == null || arr.length < 2) {
        return;
    }
    radixSort(arr, 0, arr.length - 1, maxbits(arr));
}

// 求最大值的十进制位数
public static int maxbits(int[] arr) {
    int max = Integer.MIN_VALUE;
    for (int i = 0; i < arr.length; i++) {
        max = Math.max(max, arr[i]);
    }
    int res = 0;
    while (max != 0) {
        res++;
        max /= 10;
    }
    return res;
}

public static void radixSort(int[] arr, int begin, int end, int digit) {

    final int radix = 10;
    int i = 0, j = 0;

    //定义辅助数组
    int[] bucket = new int[end - begin + 1];
    for (int d = 1; d <= digit; d++) {
        //count数组记录词频前缀和
        int[] count = new int[radix];
        //位数词频统计
        for (i = begin; i <= end; i++) {
            j = getDigit(arr[i], d);
            count[j]++;
        }

        //优化成前缀和数组
        for (i = 1; i < radix; i++) {
            count[i] = count[i] + count[i - 1];
        }

        //更新辅助数组，一趟进出桶
        for (i = end; i >= begin; i--) {
            j = getDigit(arr[i], d);
            bucket[count[j] - 1] = arr[i];
            count[j]--;
        }

        //将桶元素放入数组中
        for (i = begin, j = 0; i <= end; i++, j++) {
            arr[i] = bucket[j];
        }
    }
}

//将d位上的数字取出
public static int getDigit(int x, int d) {
    return ((x / ((int) Math.pow(10, d - 1))) % 10);
}