Java实现冒泡排序、选择排序、插入排序、希尔排序、归并排序、基数排序

Java实现了冒泡排序、选择排序、插入排序、希尔排序、归并排序、插入排序

先定义工具类用于交换两个数

public class SwapUtils {
    public void swap(int[] arr,int i ,int j){
        if(arr[i]>arr[j]){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}

一、冒泡排序

/**
 * 冒泡排序
 */
public class BubbleSortUtils {
    public void sort(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                new SwapUtils().swap(arr,j,j+1);
            }
        }
    }
}

二、选择排序

/**
 * 选择排序
 */
public class SelectSort {
    public void sort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                new SwapUtils().swap(arr,i,j);
            }
        }
    }
}

三、直接插入排序

/**
 * 直接插入排序
 */
public class InsertSort {
    public void sort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = i ; j > 0; j--) {
                new SwapUtils().swap(arr,j-1,j);
            }
        }
    }
}

四、希尔排序

/**
 * 希尔排序
 */
public class ShellSort {
    public void sort(int[] arr){
       int jiange = 1;
       while (jiange<=arr.length/3){
           jiange = jiange*3+1;
       }
        for (int i = jiange; i > 0; i = (i-1)/3) {
            for (int j = i; j < arr.length; j+=i) {
                for (int k = j; k > i-1; k-=i) {
                    new SwapUtils().swap(arr,k-i,k);
                }
            }
        }
    }
}

五、归并排序

public class MergeSort {
    public void sort(int[] arr,int start,int end){
        int mid = (end+start)/2;
       if(start<end){
           sort(arr,start,mid);
           sort(arr,mid+1,end);
           mergeSort(arr,start,mid,end);
       }
    }

    public void mergeSort(int[] arr,int start,int mid,int end){
        int i = start;
        int j = mid+1;
        int index = 0;
        int[] tempArr = new int[end-start+1];
        while (i <= mid && j <=end){
            if(arr[i]<arr[j]){
                tempArr[index] = arr[i];
                i++;
                index++;
            }else {
                tempArr[index] = arr[j];
                j++;
                index++;
            }
        }
        while (i<=mid){
            tempArr[index] = arr[i];
            i++;
            index++;
        }
        while (j<=end){
            tempArr[index] = arr[j];
            j++;
            index++;
        }
        for (int l = 0; l < tempArr.length; l++) {
            arr[l+start] = tempArr[l];
        }
    }
}

六、快速排序

/**
 * 快速排序
 */
public class QuickSort {
    //start 默认是0
    //end 是数组长度-1
    public void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            //获取分区索引
            int index = getIndex(arr, start, end);
            //对左右两个分区 再进行同样的步骤 ，即是递归调用
            quickSort(arr, start, index - 1);//左半部分
            quickSort(arr, index + 1, end);//右半部分
        }
    }

    private int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义基准数
        int x = arr[i];
        //循环
        while (i < j) {
            //从右往左比较
            while (i < j && arr[j] >= x) {
                j--;
            }
            //从右往左找到比基准数小的数了后，填坑
            if (i < j) {
                //把这个数填到上一个坑位
                arr[i] = arr[j];
                //让 i++;
                i++;
            }

            //从左往右找
            while (i < j && arr[i] < x) {
                i++;
            }
            // 找比基准数大的数，找到后填坑
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        //当上面的循环结束后把基准数填到最后一个坑位，也就一基准数为界，分成了左右两部分
        arr[i] = x; //把基准数填进去
        return i; //返回基准数所在位置的索引
    }
}

七、基数排序

import java.util.Arrays;

/**
 * 基数排序
 */
public class 基数排序算法 {
    public static void main(String[] args) {
        int[] arr = {1, 9, 8, 12, 23, 28, 32, 42, 102, 100, 259};
        sortArray(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void sortArray(int[] arr) {
        //定义一个二维数组
        int[][] tempArr = new int[10][arr.length];//里面的一维数组的长度最大就和待排序的数组长度一样
        //定义一个统计的一维数组,可以统计二维数组每个桶中放了多少数字
        int[] counts = new int[10];//长度和二维数组长度保持一样
        //获取数组中最大的数
        int max = getMax(arr);
        //计算数组中最大的数的有几位,这就是我们需要比较的轮次
        int len = String.valueOf(max).length();
        for (int i = 0, n = 1; i < len; i++, n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                //获取每个位上的数字
                int ys = arr[j] / n % 10;
                //我们找一个二维数组,数组中放10个桶,这个桶就是一位数组
               // counts[ys]++ 意思是,二维数组的桶中放一个数字,那么统计数组对于的位置就统计一下
                tempArr[ys][counts[ys]++] = arr[j];
            }
            //我们遍历统计数组,取出二维数组中的元素,放回原数组
            int index = 0;
            for (int k = 0; k < counts.length; k++) {
                if (counts[k] != 0) {
                    for (int h = 0; h < counts[k]; h++) {
                        arr[index] = tempArr[k][h];
                        index++;
                    }
                    //情况一轮过后统计的个数
                    counts[k] = 0;
                }
            }
        }
    }

    private static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}