java-数据结构-排序

已于 2022-02-24 18:56:05 修改
阅读量286 收藏
点赞数
分类专栏： java 文章标签： 数据结构 java 排序算法
于 2022-02-15 17:36:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leaarning/article/details/122897767
版权

1.冒泡排序

图示 ：

//冒泡排序
public class BubbleSort extends Sort {
    public BubbleSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        for (int i = 0; i <arr.length ; i++) {
            for (int j = 1; j <arr.length-1 ; j++) {
                if (arr[j]>arr[j+1]){
                    swap(j,j+1);
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

2.选择排序

图示:

//选择排序
public class SelectSort extends Sort {
    public SelectSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        for (int i = 0; i <arr.length-1; i++) {
            int minindex=i;
            for (int j = i+1; j <arr.length ; j++) {
                if (arr[j]<arr[minindex]){
                    minindex=j;
                }
            }
            swap(i,minindex);
    }
        System.out.println(Arrays.toString(arr));
}
}

2.快速排序

2.1单路排序

public class QuickSort extends Sort {

    public QuickSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        sortsort(0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    private void sortsort(int L, int R) {
        if (L>=R){
            return;
        }
        //对数组进行划分，并返回划分后的中点
        int p=partition(L,R)-1;
         sortsort(0,p - 2);
        sortsort(p + 1, R);
    }

    private int partition(int L, int R) {
        int j = R+1;
        int i=L+1;
        int v=L;
        while (i<j){
            if (arr[v]<=arr[i]){
                swap(i,j-1);
                j--;
            }else {
                i++;
            }
        }
        swap(L, j-1);

        return j;

    }
}

2.2双路排序

public class TwoQuickSort extends Sort {
    public TwoQuickSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        onemethod(0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    private void onemethod(int L, int R) {
        if (L >= R) {
            return;
        }
        //中间值
        int p = middlevalue(L, R);
        onemethod(L, p - 1);
        onemethod(p + 1, R);
    }

    private int middlevalue(int L, int R) {
  //避免升序情况，让第一个元素随机和其他位置元素交换
        swap(L, (int) (Math.random() * (R - L + 1) + L));
        int v = arr[L];
        int i = L + 1;
        int j = R;
        while (true) {
            while (i <= R && arr[i] < v) {
                i++;
            }
            while (j >= L + 1 && arr[j] > v) {
                j--;
            }
            if (i > j) {
                break;
            }
            swap(i, j);
            i++;
            j--;
        }
        swap(L, j);
        return j;
    }

2.3三路排序

public class ThreeQuickSort extends Sort {
    public ThreeQuickSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        threequicksort(0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    private void threequicksort(int L, int R) {
        if (L>=R){
            return;
        }
        swap(L, (int) (Math.random() * (R - L + 1) + L));
        int v=arr[L];
        int i=L+1;
        int lt=L;
        int gt=R+1;
        while (i<gt){
            if (v<arr[i]){
                swap(i,gt-1);
                  gt--;
            }else if (v>arr[i]){
                swap(i,lt+1);
                i++;
                lt++;
            }else {
                i++;
            }
        }
        swap(L,lt);
       threequicksort(L,lt-1);
       threequicksort(gt,R);
    }
}

3.插入排序

public class insertSort extends Sort {

    public insertSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        int i = 0;
        while (i <= arr.length-1) {
            int j = i;
            if (i == 0) {
                i++;
            }
            while (j > 0) {
                if (arr[j] < arr[j - 1]) {
                    swap(j, j - 1);
                    j--;
                } else {
                    j--;
                }
            }
            i++;
        }
        System.out.println(Arrays.toString(arr));
    }

4.希尔排序

 如图，如果j-gap所对应值大于j所对应值，则交换值，然后在j指向j-gap，在进行对比，直到j-gap小于0或者j-gap的对应值小于j的对应值，此时i++；这个顺序直到i遍历到数组完，在重新得到gap，是gap/2得到新的，再继续刚所述操作。

//自己写的
public class ShellSort extends Sort {
    public ShellSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        int gap = arr.length / 2;
        int i = gap;
        int j = 0;
        while (true) {
            while (i <= arr.length - 1) {
                j=i;
                if (arr[j - gap] < arr[j]) {
                    i++;

                } else if (arr[j - gap] > arr[j]) {
                    swap(j - gap, j);
                    j=j-gap;
                  while (j-gap>0){
                      if (arr[j-gap]<arr[j]){
                               i++;
                               break;
                      }
                      else if (arr[j-gap]>arr[j]){
                          swap(j-gap,j);
                          j=j-gap;
                      }else {
                          i++;break;
                      }
                  }
                } else {
                    swap(j-gap+1,j);
                    i++;
                }
            }
            gap = gap / 2;
            i = gap;

            if (gap<1){break;}
        }
        System.out.println(Arrays.toString(arr));
    }
}

//正宗写法
public class ShellSort extends Sort{
    public ShellSort(int[] arr){
        super(arr);
    }

    @Override
    public void sort() {
        int len=arr.length;
        for (int gap =len/2; gap >0 ; gap=gap/2) {
            for (int i = gap; i <len ; i++) {
                int e=arr[i];
                int j=i;
                while (j-gap>=0&&arr[j-gap]>e){
                    arr[j]=arr[j-gap];
                    j=j-gap;
                }
                arr[j]=e;
            }
        }
    }
}

5.合并排序

public class MergeSort extends Sort {
    public MergeSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        mergesort(0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    private void mergesort(int l, int r) {
        if (l>=r){
            return;
        }
        int mid=(l+r)/2;
        //递归排序当前层级的右边
        mergesort(l,mid);
        //递归排序当前层级的左边
        mergesort(mid+1,r);
        //左边右边排完，进行合并，
        // 如果左边的最大值小于左边的最小值则不需要合并
        if (arr[mid]>arr[mid+1]){
            merge(l,mid,r);
        }
    }
// 合并操作
    private void merge(int l, int mid, int r) {
        //创建了个新数组，方便比较
        int[] aux=new int[r-l+1];
        //复制数组
        for (int k = l; k <=r ; k++) {
            aux[k-l]=arr[k];
        }
        int i=l,j=mid+1;
        for (int k=l;k<=r;k++){
            //左边完毕
            if (i>mid){
                arr[k]=aux[j-l];
            }else if (j>r){//右边完毕
                arr[k]=aux[i-l];
                i++;
            }else if (aux[i-l]<aux[j-l]){
                arr[k]=aux[i-l];
                i++;
            }else{
                arr[k]=aux[j-l];
                j++;
            }
        }
    }
}

6.桶排序

桶排序顾名思义，就是放几个桶并且桶有范围，然后把数放进去，在桶内进行其他排序。

 

//桶排序
public class bucketSort extends Sort {
    public bucketSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        //1.桶的个数 创建桶
        int max=0,min=0;
        for (int i = 0; i < arr.length ; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
            if (arr[i]<min){
                min=arr[i];
            }
        }
        int bucketnum=(max-min)/ arr.length+1;
        System.out.println(bucketnum+"个桶");
        ArrayList<Integer>[] lists=new ArrayList[bucketnum];
        for (int i = 0; i <bucketnum ; i++) {
            lists[i]=new ArrayList<>();
        }
        //2.分配元素
        for (int i = 0; i <arr.length ; i++) {
            lists[(arr[i]-min)/arr.length].add(arr[i]);
        }
        //3.桶内排序
        for (int i = 0; i < lists.length ; i++) {
            lists[i].sort(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1-o2;
                }
            });
        }
        int index=0;
        for (int i = 0; i < bucketnum ; i++) {
            for (int j = 0; j < lists[i].size(); j++) {
              arr[index++]=lists[i].get(j);
            }
        }
        System.out.println(Arrays.toString(arr));

    }
}

7.基数排序

创建0~9个位桶，每个桶实质相当于一个队列，比如说 ， 排序如图

 我们先取个位排序那么应该是下图排列，然后每个桶一次出队

 变成如下顺序

 然后在按十位排序，继续上述操作。那么到底进行多少轮呢，取决于，原数组最大值的位数。

//基数排序
public class radixSort extends Sort {
    public radixSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
        //1.轮数  获取最大执行几次
        int radixnum=radixmax(arr);
        System.out.println("轮数为："+radixnum);
        //2.创建桶 list所有桶的集合 每一个桶是linkedList（当10个队列用）
        LinkedList<Integer>[] list=new LinkedList[10];
        //每一个桶中有list
        for (int i = 0; i <10 ; i++) {
            list[i]=new LinkedList<>();
        }
        //3.开始 分类-收集
        for (int r = 1; r <=radixnum; r++) {  //轮数
            //分类过程
            for (int i = 0; i < arr.length ; i++) {
               list[getIndex(arr[i],r)].offer(arr[i]);
            }
            //收集 遍历桶
            int index=0;
            //收集过程
            for (int i = 0; i < list.length; i++) {
                while (!list[i].isEmpty()){
                   arr[index++]= list[i].poll();
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }


    private int getIndex(int num, int r) {
        //345
        int count=0;
        for (int i = 1; i <=r ; i++) {
            count=num%10;
            num/=10;
        }
        return count;
    }

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

8.计数排序

指原数组每个元素出现的次数，然后根据统计的次数排序。

 1.先确定原数组最大值和最小值，根据上图最大值为6，最小值为1

2.创建一个计数数组其长度为max-min+1

3.遍历原数组，计算arr[i](当前元素)-min ，这个计算的是当前元素在计数数组的位置，然后出现一次+1.

 4.然后根据次数依次放入到原数组中，num(原数组的数)=index(计数数组的下标)+min，变成

 

//计数排序
public class countSort extends Sort {
    public countSort(int[] arr) {
        super(arr);
    }

    @Override
    public void sort() {
     //1.创建一个计数数组
        int max=0,min=1;
        for (int i = 0; i <arr.length ; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
            if (arr[i]<min){
                min=arr[i];
            }
        }
        System.out.println("最大值:"+max);
        System.out.println("最小值:"+min);
        int[] countarr=new int[max-min+1];
        System.out.println("计数数组长度："+countarr.length);
        //2.开始计数
        for (int i = 0; i < arr.length ; i++) {
            countarr[arr[i]-min]++;
        }
        //3.按照计数，开始排序   num=index+min
      int k=0;
        for (int index = 0; index <countarr.length ; index++) {
            for (int count = 0; count <countarr[index] ; count++) {
                int num=index+min;
                arr[k++]=num;
            }

            }

        System.out.println(Arrays.toString(arr));


    }
}

附：排序接口

public abstract  class Sort {
    public int[] arr;
    public Sort(){}
    public  Sort(int[] arr){
        this.arr=new int[arr.length];
        for (int i = 0; i <arr.length ; i++) {
            this.arr[i]=arr[i];
        }
    }
    public abstract void sort();
    public void swap(int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

秃头泥猴
关注
专栏目录
Java数据结构之排序
海恩的博客
04-30 802
Comparable接口 源码： public interface Comparable<T>{ int compareTo(T other); } 主要用于比较 基本类型的包装类、String、File和URL类都实现了这个接口，所以写排序方法时入参可以定义为Comparable[]数组，这样可以接收多个类型的数组 其中浮点数的比较技巧是扩大为长度...
数据结构（Java）--排序
雨ゆこ
07-03 520
排序的基本概念 （1）排序的数据序列与关键字 n数据序列指待排序的数据元素集合，排序是以关键字为基准进行的， n排序过程指将一个数据序列中的元素按照关键字值大小递增（或递减）的次序重新排列。 n升序（正序）：按关键字从小到大排列得到的序列。 n降序（反序） ：按关键字从大到小排列得到的序列。 （2） 排序算法的性能评价 （a）
数据结构之排序（java）
qq_48382240的博客
06-08 425
介绍其中数据结构基本排序思想及其算法实现
Java数据结构中的排序
JavaPeak的专栏
08-28 588
 package first;import java.util.*;public class DataStructureSort { public DataStructureSort() { } public DataStructureSort(String name) { } /**  * 选择排序  *   * @param a  */ public void choi
java数据结构-------排序
weixin_64634186的博客
10-24 705
快速排序、冒泡排序、排序
随手笔记--数据结构与算法（Java）排序
09-15
内容概要：这是本人在复习数据结构排序算法所写的markdown文档，对各个算法进行了比较，分析其稳定性。通过对六种排序算法的介绍，了解其中的核心原理，手写源码过程中对其代码进行注释讲解。 适用人群：本人文档是...
Java-Java数据结构二十讲
最新发布
10-25
本文将深入探讨Java数据结构的二十个核心主题，包括数组、简单排序算法、栈与队列、链表、递归、树以及图。这些概念不仅在日常编程中常见，也是面试和技术评估的重要内容。 首先，我们从基础的数组开始。数组是存储...
java-数据结构代码实现
11-15
本资料包“java-数据结构代码实现”提供了使用Java语言实现数据结构的实例，旨在帮助开发者加深对数据结构的理解并提升编程技能。 1. **链表**：链表是一种动态数据结构，其元素在内存中不是顺序排列的。Java中的...
MissionInterview:面试准备-Java-算法-数据结构
04-30
面试准备-Java-算法-数据结构 排序 Bubble Sort Selection Sort Insertion Sort Shell Sort Heap Sort Merge Sort Quick Sort Counting Sort Radix Sort MSD Vs LSD Bucket Sort ####快速排序 QuickSort...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip
09-15
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip”中，包含的是一个Java编程项目，主要目的是通过代码实践来理解和掌握数据结构、排序算法以及经典的计算机算法。...
Java数据结构—排序算法
我们都是被分成两半的人，一边热爱生活，一边憎恨生活。面对生活，我们总是在矛盾的两端摇摆，在反复的矛盾和犹豫中，一边踉跄前行，一边重振旗鼓。我渴望改变，渴望变得更好，渴望找到出口……就像一个溺水人的挣扎，就像一个救生圈。我是一个矛盾集合体，想要变得快乐，但是
10-25 443
排序算法选择排序选择排序代码实现插入排序选择排序代码算法希尔排序法希尔排序代码实现快速排序快速排序代码实现代码归并排序归并排序代码实现 选择排序 基本介绍 选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到 排序的目的。 选择排序思想 选择排序(select sorting)也是一种简单的排序方法。它的基本思想是:第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，第二次从ar[1]-ar[n-1]中选取最小值， 与ar[1]交换,第三次从r
Java结构体排序
fly_tzf的博客
01-21 328
使用ArrayList容器存放数据。 使用Collections.sort()方法排序。 class Node{ String name; int grade; Node(String name, int grade){ this.name = name; this.grade = grade; } } 例如对Node结构体按grade大小排序 升序 Collection
数据结构--Java实现几种常见排序
LcritZ的博客
06-10 1022
第一次在CSDN上写博客，今天晚上刚好复习了一下排序相关的东西，就写一写这个吧。（话说markdown还不熟悉。。）冒泡排序：复杂度o(n^2) 可以增加一个flag标记减少比较趟数 稳定public static void bubbleSort(int[] arr) { //时间复杂度：O(n*2) int count = 0; for(int i =
数据结构中的几种排序及Java实现
weixin_44379477的博客
08-05 225
冒泡排序 思想：由数组头部开始，一次比较两个元素，如果他们的顺序错误就把他们交换过来。每次交换完成后，当前数组最大值就会被放在最后。 时间复杂度：O(n2) private void bubbleSort(int[] array) { for (int i = 0; i < array.length; i++) { for (int j = 0; j &l...
java数据结构之排序篇
m0_37672942的博客
01-06 172
先来看看8种排序之间的关系：   1，  直接插入排序    （1）基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例 （3）用java实现 [plain] view plai
Java数据结构—排序
TY_JUST的博客
10-31 425
Java数据结构—排序 一、简单排序 1.Comparable接口 Java提供了一个接口Comparable就是用来定义排序顺序规则的。 **需求：**通过Comparable接口提供比较规则，来判断哪个学生年龄大(Student(name,age)) Student类 public class Student implements Comparable<Student>{ private String name; private int age; public
Java数据结构----排序
m0_61801103的博客
04-06 1721
稳定性定义 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持 不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳 定的；否则称为不稳定的。 插入排序 直接插入排序 直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到 一个新的有序序列 。 当插入第i(i>=1)个元素
Java数据结构之 常见排序
huijerry的博客
05-15 1678
一. 冒泡排序二. 选择排序三. 直接插入排序四. 希尔排序是直接插入排序的一种更高效的版本，又称“缩小增量排序”
Java实现数据结构与排序算法精要
"本书以Java语言为背景，深入讲解数据结构和排序算法，内容精炼，适合学习或复习。书中涵盖了线性表、栈、队列以及多种排序算法，如选择排序、堆排序、冒泡排序、快速排序、插入排序、Shell排序、归并排序、桶式排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值