Java版本的数据结构——排序算法

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;i<count;i++){
            number[i]=(int) (Math.random()*100);
        }
        long st=System.currentTimeMillis();
        int[] number2 = BubboSort(number);
        long end=System.currentTimeMillis();
        for (int i = 0; i <number2.length; i++) {
            System.out.println(number2[i]);
        }
        System.out.println(end-st);
    }
}

选择排序

选择排序就是首先应该是的选择最小的数据的将其放入前面。

/**
 * Copyright (C), 2018-2020
 * FileName: Select_sort
 * Author:   xjl
 * Date:     2020/3/24 8:18
 * Description: 选择排序
 */
package JAVA_sort_arithmetic.src.base_sort;

import org.junit.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

//选择排序就是为了在剩下的数据中找到最小的数然后与i进行交换
public class Select_sort {
    public int[] select(int[] numbers) {
        //第一遍是遍历从第一个到倒数的第二个
        for (int i = 0; i < numbers.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < numbers.length; j++) {
                if (numbers[j] < numbers[min]) {
                    min = j;
                }
            }
            int temp = numbers[i];
            numbers[i] = numbers[min];
            numbers[min] = temp;
        }
        return numbers;
    }

    /**
     * 插入时候就是为了在将剩下的开始插入到里面去
     *
     * @param numbers
     * @return
     */
    public int[] insert(int[] numbers) {
        for (int i = 1; i < numbers.length; i++) {
            for (int j = i; j > 0; j--) {
                if (numbers[j] < numbers[j - 1]) {
                    int temp = numbers[j];
                    numbers[j] = numbers[j - 1];
                    numbers[j - 1] = temp;
                } else {
                    break;
                }
            }
        }
        return numbers;
    }

    @Test
    public void test2() {
        int[] numbers = {5, 1, 8, 9, 4, 5, 8, 6};
        for (Integer va : insert(numbers)) {
            System.out.println(va);
        }
        String[] Array = {"a", "b", "c", "d", "e"};

    }

    @Test
    public void test3() {
        String[] aa = {"a", "b", "c", "d", "e"};
        List list = Arrays.asList(aa);
        Collections.reverse(list);
        System.out.println(list);
        //System.out.println(new StringBuilder(Arrays.toString(aa)).reverse().toString());
        //System.out.println(new StringBuilder(Array.toString()).reverse().toString());
        System.out.println("*************************************");
        StringBuffer sb = new StringBuffer("abcd");
        System.out.println(sb.reverse().toString());
    }

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

插入排序

分为两组已经排序的和后面没有排序的，第一个for 从第1个数据遍历到倒数第二个数据，然后在遍历其中的前面的第j-1个数据的大小，不多的比较 如果遇见大于的则直接跳出来，进入下一个比较就好。

/**
 * Copyright (C), 2018-2020
 * FileName: Insertsort
 * Author:   xjl
 * Date:     2020/3/19 15:28
 * Description: c插入排序
 */
package ArraySort;

import org.junit.Test;

public class Insertsort {
    public static int[] Insertsort(int[] number) {
        for (int i = 1; i < number.length; i++) {
            for (int j = i; j >0; 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 <= mid && p2 <= hi) {
            if (less(a[p1], a[p2])) {
                assit[i++] = a[p1++];
            } else {
                assit[i++] = a[p2++];
            }
        }
        //遍历，如果p1没有走完，那就移动p1指针，把对应的元素的放置到数组中找到对应的所引处
        while (p1 <= mid) {
            assit[i++] = a[p1++];
        }
        //遍历，如果p2没有走完，那就移动p2指针，把对应的元素的放置到数组中找到对应的所引处
        while (p2 <= hi) {
            assit[i++] = a[p2++];
        }

        //再将辅助数组赋值到原来的数组中
        for (int index = lo; index <= hi; index++) {
            a[index] = assit[index];
        }
    }

    //比较两个元素的大小
    public static Boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

}

快速排序

/**
 * Copyright (C), 2018-2020
 * FileName: qiucksort
 * Author:   xjl
 * Date:     2020/3/24 16:45
 * Description: 快速排序原理
 */
package JAVA_sort_arithmetic.src.high_sort;

public class qiucksort {
    //对数组的元素进行排序
    public static void sort(Comparable[] a) {
        int low = 0;
        int hi = a.length - 1;
        sort(a, low, hi);
    }

    //对数组a中lo到hi之间的元素进行排序
    public static void sort(Comparable[] a, int lo, int hi) {
        //安全索引
        if (hi <= lo) {
            return;
        }
        //从lo到hi进行分组为2组
        int partition = partition(a, lo, hi);//分界值的位置变换后的索引
        //让左边有序
        sort(a, lo, partition - 1);
        //让右边有序
        sort(a, partition + 1, hi);
    }

    //对数组a中lo到hi之间的元素进行分组 并但会对应的分组界限的索引
    public static int partition(Comparable[] a, int lo, int hi) {
        //确定分界值设定第一个为分界值
        Comparable key = a[lo];
        //定义两个指针
        int left = lo;
        int right = a.length - 1;
        while (true) {
            //先从右向左扫描移动right 找到一个比分界值小的元素 停止
            while (less(key, a[--right])) {
                if (right == lo) {
                    break;
                }
            }
            //在从左边想右边移动left  找到一个比分界值大的元素 停止
            while (less(a[++left],key)) {
                if (left == hi) {
                    break;
                }
            }
            //判断left>=right 如果是那就证明元素扫描完毕，如果不是的话则需要交换元素1
            if (left >= right) {
                break;
            } else {
                exch(a, left, right);
            }
        }
        //交换分界的值
        exch(a, lo, right);
        return right;
    }

    //比较元素
    private static Boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    //交换元素
    public static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}