数据结构中的八种排序算法

 1.插入排序

1.1直接插入排序

应用场景

插入排序适用于已经有部分数据已经排好，并且排好的部分越大越好。一般在输入规模大于1000的场合下不建议使用插入排序

 代码实现

 public static int[] insert(int[]nums){
        for (int i =1 ; i < nums.length; i++) {
            int inservalue=nums[i];
            //从右向左比较元素的同时，进行元素复制
            int j = i-1;
            for( ; j >=0&&inservalue<nums[j] ; j--) {
                nums[j+1]=nums[j];
               // System.out.println(nums[j+1]);
            }
            nums[j+1]=inservalue;

        }
        return nums;
    }

1.2希尔排序

 

package 排序算法;

import java.util.Arrays;

public class 希尔排序 {
    public static void shell(int[]arr){
        int temp=0;
        int count=0;
        //步长
        for (int gap = arr.length/2 ;gap >=1 ; gap=gap/2) {
            count++;
            for (int i = gap; i <arr.length ; i++) {
              //分组
                for (int j = i-gap; j >=0 ; j=j-gap) {
                    if (arr[j] > arr[j+gap]) {
                    temp=arr[j];
                    arr[j]=arr[j+gap];
                    arr[j+gap]=temp;

                    }
                }
            }
            System.out.println("第"+count+"轮排序后的数据：");
            System.out.println(Arrays.toString(arr));
        }
        System.out.println(Arrays.toString(arr));
    }

    public static void main(String[] args) {
        int[] arr={49,38,65,97,76,13,27,49,78,34};
        shell(arr);
    }
}

2交换排序

2.1冒泡排序

 

package 排序算法;

import java.util.Arrays;

public class 冒泡排序 {
    public static void paopaosort(int[]arr){
        int tmp=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length-1; j++) {
                if (arr[j]>arr[j+1]){
                    tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                }
            }
            
        }
        //return arr;
        System.out.println(Arrays.toString(arr));
    }

    public static void main(String[] args) {
        int arr[]={10,5,3,7,6};
        paopaosort(arr);
    }
}

 

2.2快速排序

 

package 排序算法;

public class 快速排序 {
    public static void quickSort(int[] array, int low, int high) {

        /**
         * 分析：
         * 1.选定一个基准值，array[low]
         * 2.右指针从右向左遍历high--，查找比基准值小的数据，左指针从左向右low++，查找比基准值大的数据
         * 3.如果指针未相遇，交换左右两值位置，如果指针相遇，则替换基准值的位置
         * 4.左递归，右递归
         */
        // 方法退出条件,指针相遇或错过
        if (low >= high) {
            return;
        }
        // 1. 指定基准值和左右指针记录位置
        int pivot = array[low];
        int l = low;
        int r = high;
        int temp = 0;
        // 2. 遍历条件，左右指针位置
        while (l < r) {
            // 2.1 右侧遍历
            while (l < r && array[r] >= pivot) {
                r--;
            }
            // 2.2 左侧遍历
            while (l < r && array[l] <= pivot) {
                l++;
            }
            // 2.3 l指针还在r指针左侧，尚未相遇
            if (l < r) {
                temp = array[l];
                array[l] = array[r];
                array[r] = temp;
            }
        }
        // 3. 当左右指针相遇，交换基准值位置
        array[low] = array[l];
        array[l] = pivot;
        // 4. 根据条件左侧递归遍历
        if (low < l) {
            quickSort(array, low, l - 1);
        }
        // 5. 根据条件右侧递归遍历
        if (r < high) {
            quickSort(array, r + 1, high);
        }

    }
    
}

3选择排序

3.1直接选择排序

3.2堆排序

4归并排序

package 排序算法;
import java.util.Arrays;
public class 归并排序 {
    
        public static void main(String[] args) {
            int[] nums = {-1, 2, -8, -10};          //给定一个数组
            int[] after = sortArray(nums);       //的带排序后的数组
            System.out.println(Arrays.toString(after)); //打印输出得到数组
        }

        private static int[] sortArray(int[] nums) {
            int len = nums.length;
            int[] temp = new int[len];
            mergeSort(nums,0,len-1,temp);
            return nums;
        }

        /**
         * 递归函数对nums[left...right]进行归并排序
         * @param nums 原数组
         * @param left 左边的索引
         * @param right 右边记录索引位置
         * @param temp
         */
        private static void mergeSort(int[] nums, int left, int right, int[] temp) {
            if (left == right){//当拆分到数组当中只要一个值的时候，结束递归
                return;
            }
            int mid = (left+right)/2;   //找到下次要拆分的中间值
            mergeSort(nums,left,mid,temp);//记录树左边的
            mergeSort(nums,mid+1,right,temp);//记录树右边的

            //合并两个区间
            for (int i = left; i <= right; i++) {
                temp[i] = nums[i];
//temp就是辅助列表，新列表的需要排序的值就是从辅助列表中拿到的
            }
            int i = left;       //给辅助数组里面的值标点
            int j = mid +1;
            for (int k = left; k <= right ; k++) {//k 就为当前要插入的位置
                if (i == mid + 1){
                    nums[k] = temp[j];
                    j++;
                }else if (j == right+1){
                    nums[k] = temp[i];
                    i++;
                }
                else if (temp[i] <= temp[j]){
                    nums[k] = temp[i];
                    i++;
                }else {
                    nums[k] = temp[j];
                    j++;
                }
            }
        }
    }

 

5基数排序

 

package com.keafmd.Sequence;

/**
 * Keafmd
 *
 * @ClassName: RadixSort
 * @Description: 基数排序
 * @author: 牛哄哄的柯南
 * @date: 2021-06-24 14:32
 */
public class RadixSort {
    public static void radixSort(int[] arr){
        radixSort(arr,true);
    }
    public static void radixSort(int[]arr,boolean ascending){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        //求出最大值、最小值
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max, arr[i]);
            min = Math.min(min, arr[i]);
        }
        if (min<0) {	//如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0
            for (int i = 0; i < arr.length; i++) {
                arr[i] -= min;
            }
            max -= min; //max也要处理！
        }
        //很巧妙求出最大的数有多少位
        int maxLength = (max+"").length();
        int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数
        int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数
        for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历
            for (int j = 0; j < arr.length ; j++) {
                int value = arr[j]/n % 10;
                bucket[value][bucketElementCount[value]] = arr[j];
                bucketElementCount[value]++;
            }

            //升序
            if(ascending) {
                int index = 0;
                //从左到右，从下到上取出每个数
                for (int j = 0; j < bucketElementCount.length; j++) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k < bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
            }else { // 降序
                int index=0;
                //从右到左，从下到上取出每个数
                for (int j = bucketElementCount.length-1; j >=0; j--) {
                    if (bucketElementCount[j] != 0) {
                        for (int k = 0; k <bucketElementCount[j]; k++) {
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketElementCount[j] = 0;
                }
            }


            /*for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i1]+" ");
            }
            System.out.println();*/



        }
        if (min<0){
            for (int i = 0; i < arr.length ; i++) {
                arr[i] += min;
            }
        }

    }
}