Java中的排序

最新推荐文章于 2023-02-10 11:04:14 发布
最新推荐文章于 2023-02-10 11:04:14 发布
阅读量260 收藏 23
点赞数 6
文章标签： java 排序算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuanzui/article/details/120894205
版权

标题1.冒泡排序

img

import java.util.Arrays;

public class Main {
    static int temp;
    public static void main(String[] args) {
        int[] nums = {12,15,13,46,87,164,454,22,45,65};
        Bubbing(nums);//调用BBubbing方法
    }
    public static void Bubbing(int[] nums){
        //排序前的数组
        System.out.println("排序前数组序列：");
        System.out.println(Arrays.toString(nums));//[12, 15, 13, 46, 87, 164, 454, 22, 45, 65]
        //冒泡排序
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length-i-1; j++) {
                if(nums[j]>nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
        //遍历输出排序后的数组
        System.out.println("排序后数组序列：");
        System.out.println(Arrays.toString(nums));//[12, 13, 15, 22, 45, 46, 65, 87, 164, 454]
    }
}

2.选择排序

img

import java.util.Arrays;

public class Main {
    static int temp;
    public static void main(String[] args) {
        int[] nums = {12,15,13,46,87,164,454,22,45,65};
        Select(nums, nums.length);
    }
    public static void Select(int [] nums,int len){
        for (int i = 0; i < len-1; i++) {
            int index =i;
            int j;
            for (j = i+1; j < len; j++) {
                if(nums[j] < nums[index]){
                    index = j;
                }
            }
            int temp = nums[index];
            nums[index] = nums[i];
            nums[i] = temp;
            System.out.println(Arrays.toString(nums));
            //[12, 15, 13, 46, 87, 164, 454, 22, 45, 65]
            //[12, 13, 15, 46, 87, 164, 454, 22, 45, 65]
            //[12, 13, 15, 46, 87, 164, 454, 22, 45, 65]
            //[12, 13, 15, 22, 87, 164, 454, 46, 45, 65]
            //[12, 13, 15, 22, 45, 164, 454, 46, 87, 65]
            //[12, 13, 15, 22, 45, 46, 454, 164, 87, 65]
            //[12, 13, 15, 22, 45, 46, 65, 164, 87, 454]
            //[12, 13, 15, 22, 45, 46, 65, 87, 164, 454]
            //[12, 13, 15, 22, 45, 46, 65, 87, 164, 454]
        }
    }
}

3.插入排序

img

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] num = {45,12,3,56,78,13,456,123,2};
        insertionSort(num);
        System.out.println(Arrays.toString(num));
    }
    public static int[] insertionSort(int []arr) {
        int len = arr.length;
        int preIndex, current;
        for (int i = 1; i < len; i++) {
            //获取下标前一个值
            preIndex = i - 1;
            //获取当前下标的值
            current = arr[i];
            //判断，下标大于零，按升序排序
            while (preIndex >= 0 && arr[preIndex] > current) {
                //因为已经取出当前下标的值，这里只需就前面的值往后移动
                arr[preIndex + 1] = arr[preIndex];
                //每次赋值完成，下标进行--；进行下一次的判断，赋值
                preIndex--;
            }
            arr[preIndex + 1] = current;
        }
        return arr;
    }
}

[12, 45, 3, 56, 78, 13, 456, 123, 2]
[3, 12, 45, 56, 78, 13, 456, 123, 2]
[3, 12, 45, 56, 78, 13, 456, 123, 2]
[3, 12, 45, 56, 78, 13, 456, 123, 2]
[3, 12, 13, 45, 56, 78, 456, 123, 2]
[3, 12, 13, 45, 56, 78, 456, 123, 2]
[3, 12, 13, 45, 56, 78, 123, 456, 2]
[2, 3, 12, 13, 45, 56, 78, 123, 456]

4.快速排序

public static void main(String[] args) {
        int[] arr = new int[]{45,12,3,56,78,13,456,123,2};
        //快速排序，传入数组，最开始的位置
        quickSort(arr,0,arr.length-1);
        //打印输出
        printArr(arr);
    }

    public static void quickSort(int[] arr,int left,int right){
        //判断左边的下标是否和右边的相等，等于的时候就结束程序
        if (left < right){
            //将数组分为两个部分，arr[left..pivot]和arr[pivot...right]，pivot为基准数
            //接收基准数所在的下标
            int mid = get_mid(arr, left, right);
            //递归的对左边序列进行排序，使有序
            quickSort(arr,left,mid-1);
            //递归的对右边序列进行排序，使有序
            quickSort(arr,mid+1,right);
        }
    }
    public static int get_mid(int[] arr,int left,int right){
        //以left下标的值为基准数，此时left的位置相当于是空的，可以往里面赋值
        int pivot = arr[left];
        //当left与right相遇的时候，循环结束
        while (left < right){
            //遍历右边的数
            //如果右边的数大于基准数，说明符合，将下标right--
            while (arr[right] >= pivot && left < right)right--;
            //当右边的数没有大于基准数时，将aa[right]的值赋给上面的挖空的位置
            arr[left] = arr[right];
            //遍历左边的数
            //如果左边的数小于基准数，说明符合，将left++
            while (arr[left] <= pivot && left < right)left++;
            //如果左边的数大于基准数，说明这个应该出现在基准数的右边，将arr[left]的值赋给arr[right]的位置
            arr[right] = arr[left];
        }
        //循环结束后，中间的一个位置的值是空的，这时候就需要将基准数的值赋到这个位置，可以满足左边的数都比基准数小
        arr[left] = pivot;
        //返回left小标，作为下一次循环的基准数的下标
        return left;
    }
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

5.希尔排序

image-20211006200724601

public class Test3 {
    public static void main(String[] args) {
        int[] arr = new int[]{11,2,54,55,122,1,4,54,5,12};
        shellSort(arr);
    }
    private static void shellSort(int[] arr){
        for (int gap = arr.length/2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[i];
                if (arr[j] < arr[j-gap]) {
                    while (j-gap >= 0 && temp < arr[j-gap]) {
                        arr[j] = arr[j-gap];
                        j -= gap;
                    }
                    arr[j] = temp;
                }
            }
            System.out.println(Arrays.toString(arr));
        }
    }
}

6.归并排序

img

public class Test3 {
    public static void main(String[] args) {
        //需要进行排序的数组
        int[] array=new int[]{8,3,2,1,7,4,6,5};
        //输出原数组的内容
        printResult(array);
        //归并排序操作
        sort(array,0,array.length-1);
        //输出排序后的相关结果
        printResult(array);
    }
    private static void sort(int[] array,int i,int j) {
        if(i<j)
        {
            int middle=(i+j)/2;
            //递归处理相关的合并事项
            sort(array,i,middle);
            sort(array,middle+1,j);
            merge(array,i,middle,j);
        }
    }
    private static void merge(int[] array, int i, int middle, int j) {
        //创建一个临时数组用来存储合并后的数据
        int[] temp=new int[array.length];
        int m=i;
        int n=middle+1;
        int k=i;
        while(m<=middle&&n<=j)
        {
            if(array[m]<array[n])
                temp[k++]=array[m++];
            else
                temp[k++]=array[n++];
        }
        //处理剩余未合并的部分
        while(m<=middle)
        {
            temp[k++]=array[m++];
        }
        while(n<=j)
        {
            temp[k++]=array[n++];
        }
        //将临时数组中的内容存储到原数组中
        while(i<=j)
        {
            array[i]=temp[i++];
        }
    }
    private static void printResult(int[] array) {
        for(int value:array)
            System.out.print(" "+value+" ");
        System.out.println();
    }
}

7.堆排序

public static void main(String[] args) {
    int[] array = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
	// 只需要修改成对应的方法名就可以了
    heapSort(array);

    System.out.println(Arrays.toString(array));
}

public static void heapSort(int[] array) {
	if (array == null || array.length <= 1) {
		return;
	}

	int length = array.length;

	//1.构建大顶堆
	for (int i = length / 2 - 1; i >= 0; i--) {
		//从第一个非叶子结点从下至上，从右至左调整结构
		adjustHeap(array, i, length);
	}
	//2.调整堆结构+交换堆顶元素与末尾元素
	for (int j = length - 1; j > 0; j--) {
		//将堆顶元素与末尾元素进行交换
		swap(array, 0, j);
		//重新对堆进行调整
		adjustHeap(array, 0, j);
	}

}

private static void adjustHeap(int[] array, int i, int length) {
	//先取出当前元素i
	int temp = array[i];
	//从i结点的左子结点开始，也就是2i+1处开始
	for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
		//如果左子结点小于右子结点，k指向右子结点
		if (k + 1 < length && array[k] < array[k + 1]) {
			k++;
		}
		//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
		if (array[k] > temp) {
			array[i] = array[k];
			i = k;
		} else {
			break;
		}
	}
	//将temp值放到最终的位置
	array[i] = temp;
}


private static void swap(int[] array, int a, int b) {
	int temp = array[a];
	array[a] = array[b];
	array[b] = temp;
}

8.计数排序

计数排序

public static void countingSort(int[] array) {
	if (array == null || array.length <= 1) {
		return;
	}

	int length = array.length;

	int max = array[0];
	int min = array[0];
	for (int i = 0; i < length; i++) {
		if (max < array[i]) {
			max = array[i];
		}
		if (min > array[i]) {
			min = array[i];
		}
	}
	// 最大最小元素之间范围[min, max]的长度
	int offset = max - min + 1;
	// 1. 计算频率，在需要的数组长度上额外加1
	int[] count = new int[offset + 1];
	for (int i = 0; i < length; i++) {
		// 使用加1后的索引，有重复的该位置就自增
		count[array[i] - min + 1]++;
	}
	// 2. 频率 -> 元素的开始索引
	for (int i = 0; i < offset; i++) {
		count[i + 1] += count[i];
	}

	// 3. 元素按照开始索引分类，用到一个和待排数组一样大临时数组存放数据
	int[] aux = new int[length];
	for (int i = 0; i < length; i++) {
		// 填充一个数据后，自增，以便相同的数据可以填到下一个空位
		aux[count[array[i] - min]++] = array[i];
	}
	// 4. 数据回写
	for (int i = 0; i < length; i++) {
		array[i] = aux[i];
	}
}
public static void main(String[] args) {
    int[] array = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
	// 只需要修改成对应的方法名就可以了
    countingSort(array);

    System.out.println(Arrays.toString(array));
}

9.桶排序

public static void bucketSort(int[] array) {
	if (array == null || array.length <= 1) {
		return;
	}

	// 建立桶，个数和待排序数组长度一样
	int length = array.length;
	
	LinkedList<Integer>[] bucket = (LinkedList<Integer>[]) new LinkedList[length];

	// 待排序数组中的最大值
	int maxValue = Arrays.stream(array).max().getAsInt();
	// 根据每个元素的值，分配到对应范围的桶中
	for (int i = 0; i < array.length; i++) {
		int index = toBucketIndex(array[i], maxValue, length);
		// 没有桶才建立桶(延时)
		if (bucket[index] == null) {
			bucket[index] = new LinkedList<>();
		}
		// 有桶直接使用
		bucket[index].add(array[i]);
	}

	// 对每个非空的桶排序，排序后顺便存入临时的List，则list中已经有序）
	List<Integer> temp = new ArrayList<>();
	for (int i = 0; i < length; i++) {
		if (bucket[i] != null) {
			Collections.sort(bucket[i]);
			temp.addAll(bucket[i]);
		}
	}

	// 将temp中的数据写入原数组
	for (int i = 0; i < length; i++) {
		array[i] = temp.get(i);
	}
}

private static int toBucketIndex(int value, int maxValue, int length) {
	return (value * length) / (maxValue + 1);
}

public static void main(String[] args) {
    int[] array = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
	// 只需要修改成对应的方法名就可以了
    bucketSort(array);

    System.out.println(Arrays.toString(array));
}

10.基数排序

基数排序

public static void radixSort(int[] array) {
	if (array == null || array.length <= 1) {
		return;
	}

	int length = array.length;

	// 每位数字范围0~9，基为10
	int radix = 10;
	int[] aux = new int[length];
	int[] count = new int[radix + 1];
	// 以关键字来排序的轮数，由位数最多的数字决定，其余位数少的数字在比较高位时，自动用0进行比较
	// 将数字转换成字符串，字符串的长度就是数字的位数，字符串最长的那个数字也拥有最多的位数
	int x = Arrays.stream(array).map(s -> String.valueOf(s).length()).max().getAsInt();

	// 共需要d轮计数排序, 从d = 0开始，说明是从个位开始比较，符合从右到左的顺序
	for (int d = 0; d < x; d++) {
		// 1. 计算频率，在需要的数组长度上额外加1
		for (int i = 0; i < length; i++) {
			// 使用加1后的索引，有重复的该位置就自增
			count[digitAt(array[i], d) + 1]++;
		}
		// 2. 频率 -> 元素的开始索引
		for (int i = 0; i < radix; i++) {
			count[i + 1] += count[i];
		}

		// 3. 元素按照开始索引分类，用到一个和待排数组一样大临时数组存放数据
		for (int i = 0; i < length; i++) {
			// 填充一个数据后，自增，以便相同的数据可以填到下一个空位
			aux[count[digitAt(array[i], d)]++] = array[i];
		}
		// 4. 数据回写
		for (int i = 0; i < length; i++) {
			array[i] = aux[i];
		}
		// 重置count[]，以便下一轮统计使用
		for (int i = 0; i < count.length; i++) {
			count[i] = 0;
		}

	}
}

private static int digitAt(int value, int d) {
	return (value / (int) Math.pow(10, d)) % 10;
}
public static void main(String[] args) {
    int[] array = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
	// 只需要修改成对应的方法名就可以了
    radixSort(array);

    System.out.println(Arrays.toString(array));
}
Nemophilist丶轩
关注
  • 6
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java学习（123）：treeset排序集合
歌谣的博客
09-09 182
import java.util.Comparator; public class GoodsSorts implements Comparator { public int compare(Object o1,Object o2){ Goods g1=(Goods)o1; Goods g2=(Goods)o2; System.out.p...
Java实现三种排序（冒泡排序、选择排序、插入排序）
yrxfight的博客
08-23 607
一、冒泡排序 1、原理： 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 3.针对所有的元素重复以上的步骤，除了最后一个。 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 2、代码 public class BubbleSort{ public static void main(String[] args){ int scores[] = {67, 2, 7
6种常见排序算法(java版)
linpeng123l的专栏
08-25 2284
1、排序算法基本概念1.1、什么是排序算法所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。（摘自百科） 1.2、排序算法稳定性
JAVA 按照第一二三不同条件排序
qq_37567381的博客
05-31 932
package com.zdf.newapp.sort; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class SortTest { /** * @param args ...
java 实现几种常见排序方法
丶附耳聆听的博客
11-22 311
日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
java 中文姓氏 排序
11-15
java 中文姓氏 排序
java中排序报：Comparison method violates its general contract异常的解决
08-30
主要给大家介绍了关于java中排序报：Comparison method violates its general contract异常的解决方法，文中介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面来一起看看吧。
Java中快速排序算法
最新发布
01-15
Java中快速排序算法和经典案例
java中文排序,数字字母汉字排序
02-05
java实现中文排序，按数字字母汉字的顺序进行排序
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
java 中文数字排序_java 中文一,二,到十,怎么排序
weixin_35760923的博客
02-13 719
对于这样的情况，我有个建议你可以单独建立一个表用来索引汉字，比如createtableindex_char_Chinese(charIndexintprimarykey,charChinesenotnullunique);insertintoindex_char_Chinesevalues(0,'零');insertintoindex_char_Chinesevalue...
JAVA对数字+字符串,中文一二三四等特殊格式字符串进行特殊排序
weixin_45409897的博客
02-10 907
提示：对数字+字符串,中文一二三四…格式字符串去重,排序,重组. 可以对customSort 类的46,53行进行修改,查看新排序效果。
Java中文进行排序
Shine的专栏
04-02 1915
import java.text.Collator;import java.util.Arrays;import java.util.Comparator;/*** @author leon* 所谓中文排序就是按照汉语拼音的顺序进行排序，* 在Java中进行排序其实不需要自己来写算法，* java.util.Arrays类中提供的sort方法可以直接实现这个功能。*/public class So
java 中文数字排序_Java 将数字123对应于中文的一二三
weixin_28273593的博客
02-24 1558
需求： 如何将数字123对应于中文的一二三private final static char[] cs = "零一二三四五六七八九".toCharArray();/*** @param args*/public static void main(String[] args) {int num = 123;//调用方法String str=NumberToString(num);//转成字符数组c...
Java8 - 使用 Comparator.comparing 进行排序
weixin_34074740的博客
09-10 5024
2019独角兽企业重金招聘Python工程师标准>>> ...
java 3 9 2 6数字排序_Java常用的九种排序方法及代码实现
weixin_36027195的博客
02-13 470
packagecom.algorithm.Demo;importjava.util.ArrayList;importjava.util.Arrays;importjava.util.List;publicclassSortRecoder{publicstaticvoidmain(String[]args){SortRecoderSR=newSortRecoder()...
java 中文排序错乱
01-05
在Java中，对中文进行排序时可能会出现错乱的情况。这是因为Java默认使用的是Unicode编码进行排序，而Unicode编码将中文字符按照拼音的顺序进行排序，而不是按照中文的笔画顺序。因此，如果你想要按照中文的笔画顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值