java--算法--排序算法

排序算法的基本介绍：

算法的具体实现：

package com.model.sort;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.UUID;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/11 9:11
 * 排序算法:
 * 冒泡排序
 */
public class SortDemo01 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,5,3,9,4,2,6,7};
        int[] arr1=new int[]{1,2,3,4,5,6};
        System.out.println(Arrays.toString((sort(arr1))));
        int[] arr2=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr2[i]= (int)(Math.random()*80000);
        }
        int second = LocalDateTime.now().getSecond();
        sort(arr2);
        System.out.println("总共花费时间："+(LocalDateTime.now().getSecond()-second));

    }
    public static int[] sort(int[] arr){
        //        冒泡排序的时间复杂度是o(n^2)
        boolean flag=false;
        for (int i=0;i< arr.length-1;i++){
            for (int j = 0; j < arr.length-1-i ; j++) {
                if (arr[j]>arr[j+1]){
                    flag=true;//如果某一趟一次交换都没有发生则说明已经排好了，可以直接退出了
                    int n=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=n;
                }
            }
            if (flag==false){
                break;
            }else {
                flag=false;
            }
        }
       return arr;

    }

}

package com.model.sort;

import java.time.LocalDateTime;
import java.util.Arrays;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/11 10:34
 * 排序算法：
 * 选择排序 Select Sort
 */
public class SortDemo02 {
    public static void main(String[] args) {
        int[] array=new int[]{9,3,1,6,4,2,7,8,5};
        selectSort(array);
        System.out.println(Arrays.toString(array));

        int[] array1=new int[80000];
        for (int i=0;i<80000;i++){
         array1[i]=(int)(Math.random()*800000);
        }
        int second = LocalDateTime.now().getSecond();
        selectSort(array1);
        System.out.println(LocalDateTime.now().getSecond()-second);

    }
//    选择排序：记录最小值和最小值的下标
    public static void selectSort(int[] array){
        for (int i=0;i<array.length-1;i++){//第一圈找到最小的放在第一个位置
            int min=array[i];
            int index=i;
            for (int j = i; j < array.length; j++) {
                if (array[j]<min){
                    min=array[j];
                    //找到最小的进行交换
                    index=j;
                }
            }
            if (i != index) {
                int n=array[i];
                array[i]=array[index];
                array[index]=n;
            }


        }

    }
}

package com.model.sort;

import java.util.Arrays;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/11 11:06
 * 选择排序：
 * 插入排序 （Insertion Sort）
 * 分成两个表，一个是有序的的，一个无序的表，寻找无序表中第一个元素在有序表中的位置，插入，一次类推，将无序表中的数据全部放在有序表中
 */
public class SortDemo03 {
    public static void main(String[] args) {
        int[] array = new int[]{9,5, 6, 4, 2, 1, 3, 7,8};
//        insertionSort(array);
//        System.out.println(Arrays.toString(array));
//        insertionSort02(array);
//        System.out.println(Arrays.toString(array));

        insertionSort02(array);
        System.out.println(Arrays.toString(array));
    }

    public static void insertionSort(int[] array) {

        for (int i = 1; i < array.length; i++) {
            int insertVal = array[i];
            int index = i - 1;
            while (index >= 0 && insertVal < array[index]) {
                array[index + 1] = array[index];
                index--;
            }
            array[index + 1] = insertVal;
        }
    }

    public static void insertionSort02(int[] array) {

        for (int i = 1; i < array.length; i++) {
            int insertVal = array[i];
            int index = i;
            for (int j = 0; j <= i; j++) {
                if (array[j] > insertVal) {
                    index = j;
                    break;
                }
            }
            for (int k = i; k > index; k--) {
                array[k] = array[k - 1];
            }
            array[index] = insertVal;
        }
    }

    public static void insertionSort03(int[] array) {

        for (int i = 1; i < array.length; i++) {
            int insertVal = array[i];
            int index = 0;
            for (int j = i - 1; j >= 0; j--) {
                if (insertVal > array[j]) {
                    index = j + 1;
                    break;
                }
                array[j + 1] = array[j];
            }
            array[index] = insertVal;
        }
    }
}

package com.model.sort;

import java.time.LocalDateTime;
import java.util.Arrays;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/11 17:13
 * 排序算法：
 * 希尔排序 （Hill Sort）
 */
public class SortDemo04 {
    static int count=0;
    public static void main(String[] args) {

        int[] array = new int[]{8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
//        hillSort(array);
//        System.out.println(Arrays.toString(array));
//        hillSort02(array);
//        System.out.println(Arrays.toString(array));
//        hillSort03(array);
//        System.out.println(Arrays.toString(array));
//        hillSort04(array);
//        System.out.println(Arrays.toString(array));

        int[] arrays = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            arrays[i]= (int) (Math.random()*800000);
        }
        int second = LocalDateTime.now().getSecond();
        hillSort04(arrays);
        System.out.println("花费时间为"+(LocalDateTime.now().getSecond()-second));


    }

    public static void hillSort(int[] array) {
        int groupNum = array.length / 2;
        while (groupNum >= 1) {

            for (int i = 0; i < groupNum; i++) {

                //对每组的数据进行插入排序
                for (int j = 1; j < array.length / groupNum; j++) {
                    int insertVal = array[i + j * groupNum];
                    int index = i + (j - 1) * groupNum;
                    while (index >= 0 && insertVal < array[index]) {
                        array[index + groupNum] = array[index];
                        index = index - groupNum;
                    }
                    array[index + groupNum] = insertVal;
                }

            }
            groupNum = groupNum / 2;

        }
    }

    //    交换的方式实现希尔排序
    public static void hillSort02(int[] array) {

        int groupNum = array.length / 2;
        while (groupNum >= 1) {
            for (int i = groupNum; i < array.length; i++) {
                for (int j = i - groupNum; j >= 0; j -= groupNum) {
                    if (array[j] > array[j + groupNum]) {
                        int temp = array[j + groupNum];
                        array[j + groupNum] = array[j];
                        array[j] = temp;
                    }
                }
            }
            System.out.println("第"+count+++"躺"+Arrays.toString(array));
            groupNum = groupNum / 2;
        }
    }

    public static void hillSort03(int[] array){
        int temp=0;
        for (int groupNum=array.length/2;groupNum>0;groupNum/=2){
            for (int i=groupNum;i<array.length;i++){
                for (int j=i-groupNum;j>=0;j-=groupNum){
                    if (array[j]>array[j+groupNum]){
                        temp=array[j];
                        array[j]=array[j+1];
                        array[j+1]=temp;
                    }
                }
            }
            System.out.println("第"+(++count)+"轮比较的结果："+Arrays.toString(array));
        }
    }
//    移动的方式实现希尔排序(时间最快)
    public static void hillSort04(int[] array){
        for (int groupNum=array.length/2;groupNum>0;groupNum/=2){
            for (int i=groupNum;i<array.length;i++){
                int insertVal=array[i];
                int index=i-groupNum;
                while(index>=0&&insertVal<array[index]){
                    array[index+groupNum]=array[index];
                    index-=groupNum;
                }
                array[index+groupNum]=insertVal;
            }
        }
    }
}

package com.model.sort;

import java.util.Arrays;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/11 20:26
 * 排序算法：
 * 快速排序（Quick sort）-->交换排序（冒泡排序）
 */
public class SortDemo05 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, -1, -2, 0};
        quickSort(array, 0, array.length - 1);
        System.out.println(Arrays.toString(array));

    }

    public static void quickSort(int[] array, int left, int right) {

        int l = left;
        int r = right;
        int pivot = array[(l + r) / 2];
        //递归实现将比pivot大的值放在右边，比pivot小的值放在左边
        while (l < r) {
            while (array[l] < pivot) {
                l++;
            }
            while (array[r] > pivot) {
                r--;
            }
            if (l >= r) {
                break;
            }
            int temp = array[l];
            array[l] = array[r];
            array[r] = temp;
            //交换之后发现，这个值和pivot相等，则跳过这个值
            if (array[l]==pivot){
                l++;
            }
            if (array[r]==pivot){
                r--;
            }
        }
        if (l==r){
            l++;
            r--;
        }
        if (left<r) quickSort(array, left, r);
        if (left>l) quickSort(array, l, r);
    }
}

原文地址：https://www.cnblogs.com/zzhAylm/p/14998290.html