JAVA 九大排序算法

最新推荐文章于 2021-02-22 14:18:56 发布
最新推荐文章于 2021-02-22 14:18:56 发布
阅读量188 收藏 1
点赞数
分类专栏： 算法 排序 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44150902/article/details/106925473
版权

1、冒泡排序

public class Bobble {
    private static void sort(int[] arrays) {
        //一次性读取到高速缓存中，避免cache miss
        int length =  arrays.length;
        for (int i = 1; i < length; i++) {
            for (int j = 0; j < length-i ; j++) {
                if (!less(arrays[j], arrays[j+1])) {
                    cmpxchg(arrays, j, j+1);
                }
            }
        }
    }
//交换数据
    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }
//i是否小于j
    private static boolean less(int i, int j) {
        return i < j;
    }
//测试
    public static void main(String[] args) {
        int[] a = {6,5,4,3,2,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

2、选择排序

public class Select {
    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }
//i是否小于j
    private static boolean less(int i, int j) {

        return i < j;
    }

    private static void sort(int[] arrays) {
        //每次找出最小值与第一个位置交换
        int length = arrays.length;
        for (int i = 0; i < length-1 ; i++) {
            int minIndex = i;
            for (int j = i+1; j < length ; j++) {
                //每次比较O（n）
                if (!less(arrays[minIndex], arrays[j])) {
                    minIndex = j;
                }
            }
            //跟当前位置交换
            cmpxchg(arrays, minIndex, i);
        }

        //时间复杂度 O(n) + O(n^2) = O(n^2)
        //空间复杂度O(n)
    }

    public static void main(String[] args) {
        int[] a = {6,5,4,3,2,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

3、插入排序

public class Insert {


    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }

    private static boolean less(int i, int j) {

        return i < j;
    }

    private static void sort(int[] arrays) {
        int length = arrays.length;
        for (int i = 1; i < length ; i++) {
            //每次都执行O(n)次for
            for (int j = i; j > 0 ; j--) {
                //每次都比较O(n)次
                if (less(arrays[j-1], arrays[j])) {
                    break;
                }
                //每次都交换O(n)次
                cmpxchg(arrays, j, j-1);
            }
        }
        //时间复杂度位O(n^2)
    }

    public static void main(String[] args) {
        int[] a = {6,5,4,3,2,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

4、希维尔排序

public class Shell {
    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }

    private static boolean less(int i, int j) {

        return i < j;
    }

    private static void sort(int[] arrays) {
        int h = 1;
        while (h < arrays.length >> 1)
            h = 2 * h + 1;

        while (h > 0) {
            for (int i = h ; i < arrays.length ; i++) {
                for (int j = i; j > h-1 ; j-=h) {
                    //h==1时就是插入排序
                    if (less(arrays[j], arrays[j - h])) {
                        cmpxchg(arrays, j, j - h);
                    }
                }
            }
            h >>= 1;
        }
    }

    public static void main(String[] args) {
        int[] a = {6,5,4,3,2,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

5、计数排序

public class Count {
    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }

    private static boolean less(int i, int j) {

        return i < j;
    }

    private static void sort(int[] arrays) {
        //适用于0~9
        int length = arrays.length;
        int max = arrays[0];
        //时间复杂度 O(n)
        for (int i = 1; i < length ; i++) {
            if (less(max, arrays[i])) {
                max = arrays[i];
            }
        }

        //时间复杂度 O(n)
        int[] tempArrays = new int[max+1];
        for (int i = 0; i < length ; i++) {
            tempArrays[arrays[i]]++;
        }

        int index = 0;
        //时间复杂度 O(n)
        for (int i = 0; i < tempArrays.length ; i++) {
            if (tempArrays[i]-- > 0) {
                arrays[index++] = i;
            }
        }

        //总时间复杂度 O(n) + O(n) + O(n) = 3O(n) = O(n)
    }

    public static void main(String[] args) {
        int[] a = {6,5,4,3,2,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

6、基数排序

public class Buckets {

    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }

    private static boolean less(int i, int j) {

        return i < j;
    }

    private static void sort(int[] arrays) {

        int length = arrays.length;
        List<List<Integer>> temp = new ArrayList(10);
        for (int i = 0; i < 10 ; i++) {
            temp.add(new ArrayList<>());
        }

        //要找出最大值
        int max = arrays[0];
        //时间复杂度 O(n)
        for (int i = 1; i < length ; i++) {
            if (less(max, arrays[i])) {
                max = arrays[i];
            }
        }
        //
        int len = String.valueOf(max).length();
        //取余，取整
        int balance = 10, adjustment = 1;
        while (len > 0) {
            for (int i = 0; i < length ; i++) {
                int index = arrays[i] % balance / adjustment;
                temp.get(index).add(arrays[i]);
            }
            //第一轮完毕，取出数据
            int index = 0;
            for (List<Integer> list : temp) {
                if (list != null) {
                    for (int i = 0; i < list.size(); i++) {
                        arrays[index++] = list.remove(i--);
                    }
                }
            }
            //
            balance*=10;
            adjustment*=10;
            len--;
        }



    }

    public static void main(String[] args) {
        int[] a = {61,55,43,38,25,14};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

7、归并排序

public class Merge {

    private static int[] temp = new int[6];
    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }

    private static boolean less(int i, int j) {
        return i < j;
    }

    private static void sort(int[] arrays) {
        //每次找出最小值与第一个位置交换
        sort(arrays, 0, arrays.length-1);
    }

    private static void sort(int[] arrays, int i, int j) {
        if (j <= i) {
            return;
        }
        int start = i;
        int end = j;
        int tempMid = start + ((end-start) >> 1);
        sort(arrays, start, tempMid);
        sort(arrays, tempMid + 1, end);
        merge(arrays, start, end, tempMid);
    }

    private static void merge(int[] arrays, int i, int j, int mid) {
        //这里不能从0开始
        int index = i;

        int left = i, right = mid + 1;
        for (; left < right &&  right <= j; ) {
            if(less(arrays[left], arrays[right])) {
                temp[index++] = arrays[left++];
            } else {
                temp[index++] = arrays[right++];
            }
        }

        //判断左边是否已经遍历完毕
        while (left <= mid) {
            temp[index++] = arrays[left++];
        }

        //判断右边是否已经遍历完毕
        while (right <= j) {
            temp[index++] = arrays[right++];
        }

        for (int k = i; k <= j ; k++) {
           arrays[k] = temp[k];
        }

    }


    public static void main(String[] args) {
        int[] a = {6,5,4,3,2,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

8、堆排序

public class Head {
    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }

    private static boolean less(int i, int j) {

        return i < j;
    }

    private static void sort(int[] arrays) {
        buildMaxHead(arrays);
        int length = arrays.length;
        for (int i = length - 1 ; i > 0 ; ) {
            //每次都与最后一个交换
            cmpxchg(arrays, 0, i);
            i--;
            //开始下沉
            int k = 0;
            while (k <= i) {
                int left = (k << 1) + 1;
                if (left > i) {
                    break;
                }
                int value = arrays[left];
                int right = left + 1;
                if (right <= i && less(value, arrays[right])) {
                    value = arrays[left = right];
                }
                if (less(arrays[k], value)) {
                    cmpxchg(arrays, k, left);
                }
                k = left;
            }
        }

    }

    private static void buildMaxHead(int[] arrays) {
        int length = (arrays.length - 1) >>> 1;
        for (int i = length; i >= 0; i--) {
            int k = i;
            while (k <= length) {
                int left = (k << 1) + 1;
                int value = arrays[left];
                 int right = left + 1;
                 if (right < arrays.length && less(value, arrays[right])) {
                     value = arrays[left=right];
                 }
                 if (less(arrays[k], value)) {
                     cmpxchg(arrays, k, left);
                 }
                 k = left;
             }
        }
    }



    public static void main(String[] args) {
        int[] a = {8,7,6,5,4,3,2,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

9、快速排序

public class Quick {
    private static void cmpxchg(int[] arrays, int i, int j) {
        int array = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = array;
    }

    private static boolean less(int i, int j) {

        return i < j;
    }

    private static void sort(int[] arrays) {
        //每次找出最小值与第一个位置交换
        sort(arrays, 0, arrays.length-1);
    }


    private static void sort(int[] arrays, int low, int high) {

        if (low >= high) {
            return;
        }
        int position = position(arrays, low, high);

        sort(arrays, low, position-1);
        sort(arrays, position+1, high);

    }

    private static int position(int[] arrays, int low, int high) {
        int left = low, right = high + 1;
        int comparable = arrays[low];

        while (true) {
            while (less(comparable, arrays[--right])) {
                if (low == right) {
                    break;
                }
            }
            //从左往右扫描
            while (!less(comparable, arrays[++left])) {
                if (left == right) {
                    break;
                }
            }
            if (left >= right) {
                cmpxchg(arrays, low, right);
                break;
            } else {
                cmpxchg(arrays, left, right);

            }
        }
        return right;
    }

    public static void main(String[] args) {
        int[] a = {6,5,4,3,2,1};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}
ヾ一封信
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
9大排序算法java版
04-06
9大排序算法java版
Java实现九大排序算法.rar
05-12
本资源"Java实现九大排序算法.rar"包含的九种排序算法是编程学习的经典内容，对于提升Java程序员的技能非常有帮助。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的排序算法，通过重复遍历数组，比较相邻元素...
java实现9大排序算法
小白
02-28 7703
排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。一般来说外排序分为两个步骤：预处理和合并排序。首先，根据可用内存的大小，将外存上含有n个纪录的文件分成若干长度为t的子文件（或段）；其次，利用内部排序的方法，对每个子文件的t个纪录进行内部排序。这些经过排序的子文件（段）通常称为顺串(run)，顺串生成后即将其写入外存
java的九种排序算法
明月清风
03-31 664
为了便于管理，先引入个基础类：public abstract class SorterE extends ComparableE>> {        public abstract void sort(E[] array,int from ,int len);        public final void sort(E[] array)    {        sort(array,0,ar
九大基础排序总结与对比
hemingway
06-24 677
一、对比分析图 均按从小到大排列 k代表数值中的”数位”个数 n代表数据规模 m代表数据的最大值减最小值　 稳定性：稳定排序算法会让原本有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。 二
Java版-九大排序算法
castleknight的博客
08-09 257
http://blog.csdn.net/d12345678a/article/details/52301743
八大排序-java实现版
03-01
八大排序java实现版本，直接插入排序、折半插入排序、冒泡排序、简单选择排序、希尔插入排序、快速排序 、堆排序、2-路归并排序 、基数排序，并有时间比较，博文...
Java常用8大排序算法
08-02
Java常用8大排序算法，包含每种算法详细介绍，及代码如何实现。
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
Java常见的排序算法
最新发布
03-27
Java中常见的排序算法有以下几种： 冒泡排序（Bubble Sort）：通过比较相邻元素的大小，将较大的元素逐渐向后移动，直到整个序列有序。 选择排序（Selection Sort）：每次遍历数组，找到最小（或最大）的元素，将其...
Java实现九大排序算法
xajh_czbk的博客
01-27 118
 
Java常用的九种排序方法及代码实现
Visant Blog
11-29 871
package com.algorithm.Demo; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class SortRecoder {     public static void main(String[] args) {         SortRe
九大排序算法 java_九大排序算法（Java实现）
weixin_35744163的博客
02-13 100
1、冒泡排序public class Bubble_sort {/*** 公共冒泡排序接口* @param arr 带排序数组*/public static void sort(int[] arr) {if (arr == null) return;int len = arr.length;for (int j = len - 1; j > 0; j--) {for (int i = 0; ...
九大排序算法 java_【Java】九大排序算法实现总结
weixin_36244383的博客
02-22 100
1.直接插入排序思想：每一趟将一个待排的元素作为关键字，按照其关键字的大小插入到已经排好序的部分序列的适当位置上，直到插入完成。实现:public static void insertSort(int arr[]){for (int i=1;iint value=arr[i]; //待插入的元素int post=i;while(post>0 && arr[post-1]&gt...
java实现排序九大算法
aaaaa2428572的博客
08-20 331
直接插入排序 public class AAddB { public static void main(String[] args) { // int a[]={1,2,34,5,6,74,3,2,4523,42,24,4,555,534}; for (int i=1;i<a.length;i++){ //排序 if(a[i]<a[i-1]){//a[i]被插入数据 ，0~i-1默认是已经排好
九种排序算法总结与Java实现
zfyseu1的专栏
01-27 470
一、九种排序算法总结 平均时间复杂度O(n^2): 冒泡排序、选择排序、插入排序 平均时间复杂度O(nln):  快速排序、归并排序、堆排序 时间复杂度介于O(nlgn)和O(n^2)：希尔排序 时间复杂度O(n+k):计数排序 时间复杂度O(d(n+k)):基数排序 稳定排序：冒泡排序、插入排序、归并排序、计数排序、基数排序 不稳定排序：选择排序、快速排序、堆排序、
java数组排序
葉蕖的博客
10-19 199
数字排序 int[] intArray = new int[] { 7, 1, 4, -7 } Arrays.sort(intArray); 输出： [-7, 1, 4, 7] 字符串排序，先大写后小写 String[] strArray = new String[]{ “z”, “a”, “C” }; Arrays.sort(strArray); 输出： [C, a, z] 严格按字母表顺序排...
【排序算法】java实现九个基础排序
weixin_36451489的博客
05-22 121
【冒泡排序】 import java.util.*; //冒泡排序 public class BubbleSort { public int[] bubbleSort(int[] A, int n) { for(int i=0;i<n;++i) { for(int j=1;j<n-i;++j) { if(A[j]&lt...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值