Java中的排序

最新推荐文章于 2024-08-05 02:07:41 发布
最新推荐文章于 2024-08-05 02:07:41 发布
阅读量315 收藏 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丶轩
关注
java中文排序,数字字母汉字排序
02-05
java实现中文排序，按数字字母汉字的顺序进行排序
Java中文中含有数字以数字顺序排序
liuhl0910的专栏
03-11 490
【代码】Java中文中含有数字以数字顺序排序。
java 中文数字排序_java 中文一,二,到十,怎么排序
weixin_35760923的博客
02-13 768
对于这样的情况，我有个建议你可以单独建立一个表用来索引汉字，比如createtableindex_char_Chinese(charIndexintprimarykey,charChinesenotnullunique);insertintoindex_char_Chinesevalues(0,'零');insertintoindex_char_Chinesevalue...
【Java】 包含中文数字的文字排序
也曾是少年
12-06 3440
需排序字段 如：XX八十一局, XX十二局, XX三十四局, XX四局, XX五局, XX一百零六局, XX七局 期望排序结果：XX四局, XX五局, XX七局, XX十二局, XX三十四局, XX八十一局, XX一百零六局 思路：截取 各个字符串的中文数字部分，然后将其转换为阿拉伯数字后进行比较。 截取中文字符串 方法： /** * 截取第一处的中文数字字符串 * @para...
java 根据中文一二三排序
最新发布
weixin_36526838的博客
08-05 163
Java 中文排序的实现方法 在学习Java开发的过程中，处理中文字符串的排序是一个比较常见的需求。本文将教会刚入行的小白如何实现“根据中文一二三排序”。整个流程可以分为以下步骤： 步骤 描述 1 准备一个包含中文文本的字符串数组 2 使用Collator类进行中文排序 3 打印排序后的结果 接...
java 中文姓氏 排序
11-15
本文将详细介绍如何在 Java 中对包含中文姓氏的对象列表或字符串列表进行排序。 #### 二、基本概念 1. **Collator 类**：这是 Java 中用于文本排序和检索的标准类。`Collator` 类提供了与语言环境相关的字符串排序...
java中排序报：Comparison method violates its general contract异常的解决
08-30
在Java编程中，当执行排序操作时，可能会遇到一个特定的异常：“Comparison method violates its general contract”。这个异常通常发生在使用`Arrays.sort()`或`Collections.sort()`方法时，尤其是在从Java 6升级到...
java数组排序
09-04
在Java编程语言中，数组排序是一项基础且重要的任务。它涉及到不同的算法，这些算法通过比较和交换元素来达到数组元素的有序状态。本篇将详细探讨几种常见的排序算法及其在Java中的实现。 首先，让我们从最简单的...
JAVA对数字+字符串,中文一二三四等特殊格式字符串进行特殊排序
weixin_45409897的博客
02-10 1008
提示：对数字+字符串,中文一二三四…格式字符串去重,排序,重组. 可以对customSort 类的46,53行进行修改,查看新排序效果。
JAVA 中文数字转阿拉伯数字并排序
weixin_44021888的博客
03-01 528
JAVA 中文数字转阿拉伯数字并排序
【Java】字符串列表List＜String＞数字、字母、汉字混合排序（按中国人使用习惯排序）
winrar_rar的博客
02-25 3180
【代码】【Java】字符串列表List＜String＞数字、字母、汉字混合排序（按中国人使用习惯排序）
Java中文进行排序
Shine的专栏
04-02 1985
import java.text.Collator;import java.util.Arrays;import java.util.Comparator;/*** @author leon* 所谓中文排序就是按照汉语拼音的顺序进行排序，* 在Java中进行排序其实不需要自己来写算法，* java.util.Arrays类中提供的sort方法可以直接实现这个功能。*/public class So
java 中文数字排序_java 中文数字排序方法
weixin_31022203的博客
02-13 2289
直接上代码：首先做个比较器public Comparator compareByName;然后就是比较的主要方法compareByName = new Comparator() {public int compare(String arg0, String arg1) {arg1=arg1.replaceAll("-","");//过滤掉文件里的这个符号arg0=arg0.replaceAll("...
Java对中文进行排序
Charge8的博客
11-01 7429
Java对中文进行排序
[改善Java代码]对字符串排序 持一种宽容的心态
weixin_33721427的博客
07-11 186
在Java中一涉及到中文处理就会冒出很多的问题来,其中的排序也是一个让人头疼的问题,看代码: 1 import java.util.Arrays; 2 3 public class Client { 4 public static void main(String[] args){ 5 String[] strs = {"张三(Z)","李四(L)...
java 中文数字排序_Java 将数字123对应于中文的一二三
weixin_28273593的博客
02-24 1680
需求： 如何将数字123对应于中文的一二三private final static char[] cs = "零一二三四五六七八九".toCharArray();/*** @param args*/public static void main(String[] args) {int num = 123;//调用方法String str=NumberToString(num);//转成字符数组c...
第三周：用java实现数字排序
kr20021127的博客
03-12 1425
用java实现数字排序
java中根据集合中的汉字进行排序（汉字数字）
weixin_44928129的博客
06-17 349
new LegLists("平安-来源", "第一千三百一十四赛段"),new LegLists("来源-西宁", "第三百一十四赛段"),new LegLists("平安-西宁", "第六十三赛段")根据第二个字段，第几赛段进行排序。
java 中文排序错乱
01-05
在Java中，对中文进行排序时可能会出现错乱的情况。这是因为Java默认使用的是Unicode编码进行排序，而Unicode编码将中文字符按照拼音的顺序进行排序，而不是按照中文的笔画顺序。因此，如果你想要按照中文的笔画顺序...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值