java排序算法总结

mksintor

已于 2023-07-22 23:05:01 修改

阅读量52

点赞数 1

文章标签： java 排序算法算法

于 2023-07-21 23:08:44 首次发布

本文链接：https://blog.csdn.net/qq_41958793/article/details/131861632

版权

排序接口

package com.sintor.xxx.sort.service;

public interface Sort {
    int[] sort(int[] arr);
}

归并排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

//归并排序
public class MergeSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int l = arr.length;

        //递归
        split(arr, 0, l - 1);

        return arr;
    }

    private void split(int[] arr, int left, int right) {
        //单个数据不处理
        if (left == right) {
            return;
        }

        //获取中间下标
        int mid = left + ((right - left) >> 1); //关键理解
        split(arr, left, mid);
        split(arr, mid + 1, right);

        //合并两组数据
        merge(arr, left, mid, right);
    }

    private void merge(int[] arr, int left, int mid, int right) {
        int[] ts = new int[right - left + 1];
        int n = 0;

        int lal = left;
        int ral = mid + 1;

        //左右混合处理
        while (lal <= mid && ral <= right) {
            ts[n++] = arr[lal] > arr[ral] ? arr[ral++] : arr[lal++];
        }

        //处理左数组
        while (lal <= mid) {
            ts[n++] = arr[lal++];
        }
        //处理右数组
        while (ral <= right) {
            ts[n++] = arr[ral++];
        }

        //处理原数组
        System.arraycopy(ts, 0, arr, left, ts.length);
    }
}

快速排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

//快速排序
public class QuickSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int l = arr.length;

        //递归
        split(arr, 0, l - 1);

        return arr;
    }

    private void split(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int mid = getMid(arr, left, right);
        split(arr, left, mid - 1);
        split(arr, mid + 1, right);

    }

    private int getMid(int[] arr, int left, int right) {

        //选取中轴
        int mid = arr[left];
        int al = left + 1;
        int ar = right;

        while (true) {
            //向右找第一个大于中轴的元素下标
            while (al <= ar && arr[al] <= mid) {
                al++;
            }

            //向左找第一个小于中轴的元素下标
            while (al <= ar && arr[ar] >= mid) {
                ar--;
            }

            if (al >= ar) {
                break;
            }
            swap(arr, al, ar);
        }
        arr[left] = arr[ar];
        arr[ar] = mid;
        return ar;
    }

    private void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

选择排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

//选择排序
public class SelectSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }

        int l = arr.length;

        for (int i = 0; i < l - 1; i++) {
            for (int j = i + 1; j < l; j++) {
                if (arr[i] > arr[j]) {
                    swap(arr, i, j);
                }
            }
        }


        return arr;
    }

    private void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

冒泡排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

//冒泡排序
public class BubbleSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int l = arr.length;

        for (int i = l - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }

        return arr;
    }

    private void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

}

插入排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

//插入排序
public class InsertSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }

        int l = arr.length;

        for (int i = 1; i < l; i++) {
            insert(arr, i);
        }
        return arr;
    }


    private void insert(int[] arr, int n) {
        int t = arr[n];
        int i;
        for (i = n - 1; i >= 0 && t < arr[i]; i--) {
            arr[i + 1] = arr[i];
        }
        arr[i + 1] = t;
    }
}

希尔排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

//希尔排序
//插入排序变种
public class ShellSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int l = arr.length;
        //分组
        for (int g = l / 2; g > 0; g = g / 2) {
            //处理各个分组
            for (int i = g; i < l; i++) {
                //从i下标元素开始将对应元素插入对应分组
                insert(arr, g, i);
            }
        }

        return arr;
    }

    private void insert(int[] arr, int g, int n) {
        int t = arr[n];
        int i;
        for (i = n - g; i >= 0 && t < arr[i]; i -= g) {
            arr[i + g] = arr[i];
        }
        arr[i + g] = t;
    }
}

计数排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

//计数排序
public class CountSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int l = arr.length;

        //场景:数据是正整数 数据值相差不大

        //获取数组最大值
        int m = arr[0];
        for (int i = 1; i < l; i++) {
            if (m < arr[i]) {
                m = arr[i];
            }
        }

        //计数数组
        int[] ts = new int[m + 1];
        for (int j : arr) {
            ts[j]++;
        }

        //修改原数组
        int n = 0;
        for (int i = 0; i < ts.length; i++) {
            for (int j = ts[i]; j > 0; j--) {
                arr[n++] = i;
            }
        }

        return arr;
    }
}

堆排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

//堆排序
public class HeapSort implements Sort {


    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }

        int l = arr.length;

        //生成大顶堆
        for (int i = l / 2 - 1; i >= 0; i--) {
            adjust(arr, i, l);
        }
        for (int i = l - 1; i > 0; i--) {
            swap(arr, 0, i);
            adjust(arr, 0, i);
        }

        return arr;
    }

    private void adjust(int[] arr, int i, int l) {

        //当前节点值
        int n = arr[i];
        for (int j = i * 2 + 1; j < l; j = j * 2 + 1) {
            //左右节点中最大值的下标
            if (j + 1 < l && arr[j] < arr[j + 1]) {
                j++;
            }
            if (arr[j] > n) {
                arr[i] = arr[j];
                //记录被换最大值的下标
                i = j;
            } else {
                //没有交换就不用继续调整了
                break;
            }

        }
        arr[i] = n;
    }

    private void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

桶排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

//桶排序
public class BucketSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int l = arr.length;

        // 寻找数组的最大值与最小值
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < l; i++) {
            if (min > arr[i]) {
                min = arr[i];
            }
            if (max < arr[i]) {
                max = arr[i];
            }
        }

        //桶的大小可以根据实际情况改变
        int bucketSize = 10;
        //桶的数量
        int bucketNum = (max - min) / bucketSize + 1;

        //创建桶
        List<List<Integer>> buckets = new ArrayList<>(bucketNum);
        for (int i = 0; i < bucketNum; i++) {
            buckets.add(new LinkedList<>());
        }

        //装桶
        for (int a : arr) {
            //桶编号
            int n = (a - min) / bucketSize;
            buckets.get(n).add(a);
        }

        //结合其他排序方法,分别对桶内数据进行排序
        for (int i = 0; i < bucketNum; i++) {
            Collections.sort(buckets.get(i));
        }

        //处理原数组
        int k = 0;
        for (int i = 0; i < bucketNum; i++) {
            for (Integer e : buckets.get(i)) {
                arr[k++] = e;
            }
        }

        return arr;
    }
}

基数排序

package com.sintor.xxx.sort.service.impl;

import com.sintor.xxx.sort.service.Sort;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * 基数排序
 * 时间复杂度 O(n*k)
 * 空间复杂度 O(n+k)
 */
public class RadioSort implements Sort {
    @Override
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int l = arr.length;

        //计数最大位数
        int max = arr[0];
        for (int i = 1; i < l; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        int n = 1;
        while (max / 10 > 0) {
            n++;
            max /= 10;
        }

        //创建桶
        List<List<Integer>> buckets = new ArrayList<>(10);
        for (int i = 0; i < 10; i++) {
            buckets.add(new LinkedList<>());
        }

        //排序
        for (int i = 0; i < n; i++) {
            for (int a : arr) {
                //桶编号
                int k = (a / (int) Math.pow(10, i)) % 10;
                buckets.get(k).add(a);
            }

            //处理原数组
            int c = 0;
            for (int z = 0; z < 10; z++) {
                for (Integer e : buckets.get(z)) {
                    arr[c++] = e;
                }
                buckets.get(z).clear();
            }
        }

        return arr;
    }
}

测试

package com.sintor.xxx.sort;

import com.sintor.xxx.sort.service.Sort;
import com.sintor.xxx.sort.service.impl.*;

import java.util.Arrays;

public class SortMain {

    private static final Sort bubbleSort = new BubbleSort();
    private static final Sort bucketSort = new BucketSort();
    private static final Sort countSort = new CountSort();
    private static final Sort heapSort = new HeapSort();
    private static final Sort insertSort = new InsertSort();
    private static final Sort mergeSort = new MergeSort();
    private static final Sort quickSort = new QuickSort();
    private static final Sort radioSort = new RadioSort();
    private static final Sort selectSort = new SelectSort();
    private static final Sort shellSort = new ShellSort();

    public static void main(String[] args) {
        int[] arr = {4, 6, 8, 5, 9, 4, 7, 9, 1, 2, 3, 7, 4, 33, 87, 2};
        System.out.println("冒泡排序:");
        System.out.println(Arrays.toString(bubbleSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("选择排序:");
        System.out.println(Arrays.toString(selectSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("桶排序:");
        System.out.println(Arrays.toString(bucketSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("计数排序:");
        System.out.println(Arrays.toString(countSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("堆排序:");
        System.out.println(Arrays.toString(heapSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("插入排序:");
        System.out.println(Arrays.toString(insertSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("归并排序:");
        System.out.println(Arrays.toString(mergeSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("快速排序:");
        System.out.println(Arrays.toString(quickSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("基数排序:");
        System.out.println(Arrays.toString(radioSort.sort(Arrays.copyOf(arr, arr.length))));
        System.out.println("希尔排序:");
        System.out.println(Arrays.toString(shellSort.sort(Arrays.copyOf(arr, arr.length))));
    }
}