常见的算法代码实现

//快速排序
public static void qSort(int[] data, int left, int right) {

    int base = data[left]; // 就是我们的基准数，取序列的第一个,不能用data[0]
    int ll = left; // 表示的是从左边找的位置
    int rr = right; // 表示从右边开始找的位置
    while (ll < rr) {
        // 从后面往前找比基准数小的数
        while (ll < rr && data[rr] >= base) {
            rr--;
        }
        if (ll < rr) { // 表示是找到有比之大的
            int temp = data[rr];
            data[rr] = data[ll];
            data[ll] = temp;
            ll++;
        }
        System.out.println("left:" + ll + "right:" + rr + Arrays.toString(data));

        while (ll < rr && data[ll] <= base) {
            ll++;
        }
        if (ll < rr) {
            int temp = data[rr];
            data[rr] = data[ll];
            data[ll] = temp;
            rr--;
        }
        System.out.println("left:" + ll + "right:" + rr + Arrays.toString(data));

    }
    // 肯定是递归 分成了三部分,左右继续快排，注意要加条件不然递归就栈溢出了
    if (left < ll)
        qSort(data, left, ll - 1);
    if (ll < right)
        qSort(data, ll + 1, right);

}

// 选择排序

/**
 * 选择排序
 *
 * @param a 核心思想:选择排序的核心思想是通过反复遍历未排序部分，
 *          找到其中的最小（或最大）元素，并将其放到已排序部分的正确位置。
 *          这样，经过多次遍历后，数组就会变得有序
 */
public static void selectSort(int[] a) {

    for (int i = 0; i < a.length - 1; i++) {
        int s = i; // s元素 记录每轮最小元素的索引
        for (int j = s + 1; j < a.length; j++) {
            if (a[s] > a[j]) {
                s = j; // 记录最小元素的下标
            }
        }
        if (s != i) { // 说明下标替换了 需要交换元素值
            int temp = a[s];
            a[s] = a[i];
            a[i] = temp;
        }
        System.out.println(Arrays.toString(a));
    }
}

//冒泡排序
private static void sort(int[] arr) {
    for (int i = 0; i < arr.length - 1; ++i) {
        for (int j = 0; j < arr.length - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                exchange(arr, j, j + 1);
            }
        }
        System.out.println(Arrays.toString(arr));

    }
}

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

/**
 * 插入排序
 * 核心思想:工作原理类似于整理扑克牌。它通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
 * 6, 4, 3, 9, 4, 5, 7, 8
 * 第1次的排序结果为：4 6 3 9 4 5 7 8
 * 第2次的排序结果为：3 4 6 9 4 5 7 8
 * 第3次的排序结果为：3 4 6 9 4 5 7 8
 * 第4次的排序结果为：3 4 4 6 9 5 7 8
 * 第5次的排序结果为：3 4 4 5 6 9 7 8
 * 第6次的排序结果为：3 4 4 5 6 7 9 8
 * 第7次的排序结果为：3 4 4 5 6 7 8 9
 */
private static void insertSort(int[] nums) {
    int n = nums.length;
    for (int i = 1; i < n; i++) {//为什么i要从1开始？ 第一个不用排序，我们就把数组从i分开，0~I的认为已经排好序
        int data = nums[i];
        int j = i - 1;
        for (; j >= 0; j--) {//从尾到头
            if (nums[j] > data) {
                nums[j + 1] = nums[j];// 数据往后移动
            } else {//因为前面已经是排好序的 那么找到一个比他小的就不用找了，因为前面的肯定更小
                break;
            }
        }
        System.out.println(j);
        nums[j+1]=data;
        System.out.print("第" +i +"次的排序结果为：");
        for(j = 0 ; j < n;j++){
            System.out.print(nums[j]+" ");
        }
        System.out.println();
    }
}
/**
 * 归并排序
 * 核心思想是将数组分成更小的子数组，分别排序后再合并成一个有序数组
 */
public static void megerSort(int data[], int left, int right) { // 数组的两端
    if (left < right) { // 相等了就表示只有一个数了 不用再拆了
        int mid = (left + right) / 2;
        megerSort(data, left, mid);
        megerSort(data, mid + 1, right);
        // 分完了 接下来就要进行合并，也就是我们递归里面归的过程
        meger(data, left, mid, right);
    }
}

public static void meger(int data[], int left, int mid, int right) {
    int temp[] = new int[data.length];     //借助一个临时数组用来保存合并的数据

    int point1 = left;     //表示的是左边的第一个数的位置
    int point2 = mid + 1;   //表示的是右边的第一个数的位置

    int loc = left;    //表示的是我们当前已经到了哪个位置了
    while(point1 <= mid && point2 <= right){
        if(data[point1] < data[point2]){
            temp[loc] = data[point1];
            point1 ++ ;
            loc ++ ;
        }else{
            temp[loc] = data[point2];
            point2 ++;
            loc ++ ;
        }
    }
    while(point1 <= mid){
        temp[loc ++] = data[point1 ++];
    }
    while(point2 <= right){
        temp[loc ++] = data[point2 ++];
    }
    for(int i = left ; i <= right ; i++){
        data[i] = temp[i];
    }
}