算法问题——排序算法

java版本实现排序算法的

冒泡排序

选择排序

插入排序

希尔排序

归并排序

快速排序

冒泡排序

两个for 虚幻遍历 第一个数从总的个数一次减小 第二是比较剩余中的最大的，或者是最小的数据。

/**
 * Copyright (C), 2018-2020
 * FileName: BubboSort
 * Author:   xjl
 * Date:     2020/3/19 14:50
 * Description: 冒泡排序原理
 */
package ArraySort;

public class BubboSort {
    public static int[] BubboSort(int[] number) {
        //控制比较的排序的次数
        for (int i = number.length - 1; i >= 0; i--) {
            for (int j = 0; j < i; j++) {
                if (number[j] > number[j + 1]) {
                    int temp = number[j];
                    number[j] = number[j + 1];
                    number[j + 1] = temp;
                }
            }
        }
        return number;
    }

    public static void main(String[] args) {
        int count=200000;
        int[] number =new int[count];
        for (int i=0;i0; j--) {
                if (number[j-1]>number[j]) {
                    int temp = number[j];
                    number[j - 1] = number[j];
                    number[j] = temp;
                } else {
                    break;
                }
            }
        }
        return number;
    }

    @Test
    public void test() {
        int count = 5;
        int[] number = new int[count];
        for (int i = 0; i < count; i++) {
            System.out.println(number[i] = (int) (Math.random() * 10));
        }
        int[] number2 = Insertsort(number);
        System.out.println("*******************************************");
        for (int value : number2) {
            System.out.println(value);
        }
    }
}

希尔排序

选定一的增长量h 按照增长量的h作为数据分组的依据 对每一次的分好数组的进行插入的排序的操作， 接着就是减少增长量，减少到1在一次的执行插入排序的操作。 其中h的初始值的确定是：

/**
 * Copyright (C), 2018-2020
 * FileName: shell_my
 * Author:   xjl
 * Date:     2020/3/24 11:51
 * Description: 希尔排序
 */
package JAVA_sort_arithmetic.src.high_sort;

import org.junit.Test;

/**
 * 希尔排序的原理是
 * 选定一个增长的量h 按照增长的量h作为数据的分组的依据 对数据的进行分组
 * 对分好组的每一组数据完成插入的排序
 * 减少增长量 最下减到1 这个操作
 */
public class shell_my {
    public int[] shell(int[] numbers) {
        //根据数组长度 确定h
        int h = 1;
        while (h < numbers.length / 2) {
            h = 2 * h + 1;
        }
        while (h >= 1) {
            //排序
            //找到带插入的元素
            for (int i = h; i < numbers.length; i++) {
                //把代插入的元素插入到有序的数列中
                for (int j = i; j >= h; j -= h) {
                    //代插入的元素
                    if (numbers[j] < numbers[j - h]) {
                        int temp = numbers[j];
                        numbers[j] = numbers[j - h];
                        numbers[j - h] = temp;
                    } else {
                        break;
                    }
                }
            }
            //减少h的值
            h = h / 2;
        }
        return numbers;
    }

    @Test
    public void test() {
        int[] numbers = {5, 1, 8, 9, 4, 5, 8, 6};
        for (Integer va : shelltest(numbers)) {
            System.out.println(va);
        }
    }

    public int[] shelltest(int[] numbers) {
        //确定h 的增强的量
        int h = 1;
        while (h < numbers.length / 2) {
            h = 2 * h + 1;
        }
        while (h >= 1) {
            //找到分组的排序的元素 选择插入排序原理
            for (int i = h; i < numbers.length; i++) {
                for (int j = i; j >= h; j -= h) {
                    if (numbers[j] < numbers[j - h]) {
                        int temp = numbers[j];
                        numbers[j] = numbers[j - h];
                        numbers[j - h] = temp;
                    } else {
                        break;
                    }
                }
            }
            h = h / 2;
        }
        return numbers;
    }
}

归并排序

/**
 * Copyright (C), 2018-2020
 * FileName: Merge_new
 * Author:   xjl
 * Date:     2020/3/24 12:46
 * Description: 归并排序
 */
package JAVA_sort_arithmetic.src.high_sort;

/**
 * 归并排序就是的： 递归+分离+双指针
 */
public class Merge_new {
    //需要一个辅助的数组
    private static Comparable[] assit;

    //对数组内的元素进行排序
    public static void sort(Comparable[] a) {
        //初始化数组assit
        assit = new Comparable[a.length];
        //定义一个lo变量 和hi变量 分别记录数组中最小的索引和最大的索引：
        int lo = 0;
        int hi = a.length - 1;
        //调用重载的sort方法完成数据a中，从索引库lo到hi的元素的排序
        sort(a, lo, hi);
    }

    //对数组的lo到hi之间进行排序
    public static void sort(Comparable[] a, int lo, int hi) {
        //安全校验
        if (lo >= hi) {
            return;
        }
        //对数据lo 到hi之间的分为两个数据
        int mid = lo + (hi - lo) / 2;
        //这里是递归的算法
        sort(a, lo, mid);//递归调用自己
        sort(a, mid + 1, hi);
        //在把两个组的数据进行归并
        merge(a, lo, mid, hi);
    }

    //从索引lo到mid为一个子数组 从mid+1到hi为一个数组 将a中的两个子数组数据合并成为一个大的有序的数组
    public static void merge(Comparable[] a, int lo, int mid, int hi) {
        //定义三个指针
        int i = lo;//assit的指针
        int p1 = lo;//左数组
        int p2 = mid + 1;//右数组
        //遍历p1 p2的比较对应的索引的值 找到那个比较小的 放置到辅助的数组中
        while (p1