几种排序的方法

已于 2024-05-12 12:07:43 修改
阅读量285 收藏
点赞数 8
分类专栏： 数据结构 文章标签： 排序算法 算法 java
于 2024-05-12 11:24:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73735141/article/details/138470274
版权

 1.冒泡排序

package 排序;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = {2,7,4,3,5,8,6,1,9,0};
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	//冒泡排序
	public static void sort(int[] arr) {
		for(int j=0;j<arr.length;j++) {
			for(int i=0;i<arr.length-1;i++) {
				if(arr[i]>arr[i+1]) {
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}
	}

}

 2.堆排序

package 排序;

import java.util.Arrays;

public class HeapSort {
     public static void main(String[] args) {
    	 int[] arr = {5,7,4,2,0,3,-3,1,-2,9,6,10,8,-1};
    	 //第一大步 大顶堆构造完成
    	 for(int p = arr.length-1;p>=0;p--) {
    		 adjust(arr,p,arr.length);
    	 }
    	 
    	 //第二大步 交换堆顶和堆底值，去掉堆底值，剩余继续构造大顶堆
    	 for(int i = arr.length-1;i>=0;i--) {
    		 int temp = arr[i];
        	 arr[i] = arr[0];
        	 arr[0] = temp;
        	 adjust(arr,0,i);
    	 }
    	 System.out.println(Arrays.toString(arr));
     }
	//维护
	public static void adjust(int[] arr,int parent,int length) {
		int child = 2*parent+1;
		while(child<length) {
			//定义右孩子
			int rchild = child+1;
			if(rchild<length&&arr[rchild]>arr[child]) {
				child++;
			}
			//parent和child所指向的节点进行比较
			if(arr[parent]<arr[child]){
				//父子节点进行交换
				int temp = arr[parent];
				arr[parent] = arr[child];
				arr[child] = temp;
				
				//parent向下指，child指向其左右孩子最大值
				parent = child;
				child = child*2+1;
			}
			else {
				//结束
				break;
			}
		}
	}
}

 3.插入排序


package 排序;

import java.util.Arrays;

public class InsertSort {
	public static void main(String[] args) {
		int[] arr = { 5, 7, 4, 2, 0, 3, -3, 1, -2, 9, 6, 10, 8, -1 };
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	//插入排序
	public static void sort(int[] arr) {
		for(int i=1;i<arr.length;i++) {
			for(int j=i-1;j>=0;j--) {
				if(arr[j]>arr[j+1]) {
					int temp  = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
				else {
					break;
				}
			}
		}
	}
}

 4.快速排序

package 排序;

import java.util.Arrays;

public class QuickSort {
	public static void main(String[] args) {
		int[] arr = { 5, 7, 4, 2, 0, 3, -3, 1, -2, 9, 6, 10, 8, -1 };
		sort(arr, 0, arr.length-1);
		System.out.println(Arrays.toString(arr));
	}

	public static void sort(int[] arr, int left, int right) {
		// 递归出口
		if (left >= right) {
			return;
		}
		// 定义变量保存基本数
		int base = arr[left];

		// 定义i和j游标
		int i = left;
		int j = right;

		while (i != j) {
			// j从后往前找比基准数小的，找到后停下
			while (arr[j] >= base && i < j) {
				j--;
			}
			// i游标从前往后找比基准数大的，找到后停下
			while (arr[i] <= base && i < j) {
				i++;
			}
			// i和j进行交换
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		// i和j相遇，基准数和相遇位置数据进行交换
		arr[left] = arr[i];
		arr[i] = base;
		// 拆分左边
		sort(arr, left, i - 1);
		// 拆分右边
		sort(arr, i + 1, right);
	}
}

 5.选择排序

package 排序;

import java.util.Arrays;

public class SelectSort {
	public static void main(String[] args) {
		int[] arr = { 5, 7, 4, 2, 0, 3, -3, 1, -2, 9, 6, 10, 8, -1 };
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void sort(int[] arr) {
		for(int j = 0;j<arr.length;j++) {
			int min = arr[j];//记录最小值
			int minIndex = j;//记录最小值下标
			for(int i=j+1;i<arr.length;i++) {
				if(arr[i]<min) {
					min=arr[i];
					minIndex=i;
				}
			}
			//最小值和待排序数组的第一个数进行交换
			arr[minIndex] = arr[j];
			arr[j] = min;
		}
	}
}

 6.希尔排序

package 排序;

import java.util.Arrays;

public class ShellSort {
	public static void main(String[] args) {
		int[] arr = { 5, 7, 4, 2, 0, 3, -3, 1, -2, 9, 6, 10, 8, -1 };
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	//希尔排序
	public static void sort(int[] arr) {
		for(int grp = arr.length/2;grp>=1;grp/=2) {
			for(int i = grp;i<arr.length;i++) {
				for(int j=i-grp;j>=0;j-=grp) {
					if(arr[j+grp]<arr[j]) {
						int temp = arr[j];
						arr[j] = arr[j+grp];
						arr[j+grp] = temp;
					}
					else {
						break;
					}
				}
			}
			
		}
	}
}

 7.基数排序

package 排序;

import java.util.Arrays;

public class RadixSort {
	public static void main(String[] args) {
		int[] arr = { 4202, 2355, 13, 54, 84, 9, 234, 121, 32, 0 };
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}

	// 基数排序
	public static void sort(int[] arr) {
		// 找数组当中的最大值
		int max = arr[0];
		for (int j = 0; j < arr.length; j++) {
			if (arr[j] > max) {
				max = arr[j];  
			}
		}
		// 获取最大值的位数
		int maxLength = (max + "").length();
		// 定义桶
		int[][] bucket = new int[10][arr.length];
		// 定义桶记录工具
		int[] bucketCounts = new int[10];
		int n = 1;
		for (int h = 0; h < maxLength; h++) {
			// 将输入放入桶内
			for (int i = 0; i < arr.length; i++) {
				// 放到哪个桶
				int element = arr[i] / n % 10;// 获取对应数位数值
				// 读取桶记录工具，确定放到桶内哪个位置
				int count = bucketCounts[element];
				// 数据放入
				bucket[element][count] = arr[i];
				// 桶记录+1
				bucketCounts[element]++;
			}
			// 数据取出
			// 遍历数组
			int index = 0;
			// 遍历桶记录 (总共只有十个桶，所以k<10即可)
			for (int k = 0; k < 10; k++) {
				if (bucketCounts[k] != 0) {
					for (int l = 0; l < bucketCounts[k]; l++) {
						arr[index] = bucket[k][l];
						index++;
					}
				}
				bucketCounts[k] = 0;
			}
			n = n * 10;
		}

	}
}

 8.归并排序

package 排序;

import java.util.Arrays;

public class MergeSort {
	// 归并排序
	public static void main(String[] args) {
		int[] arr = { 5, 7, 4, 2, 0, 3, -3, 1, -2, 9, 6, 10, 8, -1 };
		split(arr, 0, arr.length - 1);
		System.out.println(Arrays.toString(arr));
	}

	// 拆分
	public static void split(int[] arr, int left, int right) {
		if (left == right) {
			return;
		}
		int i = (left + right) / 2;
		// 向左递归
		split(arr, left, i);
		// 向右递归
		split(arr, i + 1, right);
		// 合并
		merge(arr, left, i, right);
	}

	public static void merge(int[] arr, int left, int mid, int right) {
		int s1 = left;
		int s2 = mid + 1;
		// 临时数据
		int temp[] = new int[right - left + 1];
		// 临时数组的下标
		int index = 0;

		//将数据在临时数组中排序
		while (s1 <= mid && s2 <= right) {
			if (arr[s1] < arr[s2]) {
				temp[index] = arr[s1];
				index++;
				s1++;
			} else {
				temp[index] = arr[s2];
				index++;
				s2++;
			}
		}
		// 判断s1当中是否还有数据
		while (s1 <= mid) {
			temp[index] = arr[s1];
			index++;
			s1++;
		}
		// 判断s2当中是否还有数据
		while (s2 <= right) {
			temp[index] = arr[s2];
			index++;
			s2++;
		}

		// 临时数组当中的数值放回原数组
		for (int j = 0; j < temp.length; j++) {
			arr[left + j] = temp[j];
		}
	}
}

Zhu_S W
关注
  • 8
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
常见的几种排序方法
learning_web的博客
06-01 6294
【常见的几种排序方法】 1.背景介绍 在计算机科学与数学中，一个排序算法（英语：Sorting algorithm）是一种能将一串资料依照特定排序方式进行排列的一种算法。 最常用到的排序方式是数值顺序以及字典顺序。有效的排序算法在一些算法（例如搜寻算法与合并算法）中是重要的， 如此这些算法才能得到正确解答。 排序算法也用在处理文字资料以及产生人类可读的输出结果。 基本上，排序算法的输出必须遵守下列...
几种排序方法
10-15
C++中的几种排序方法介绍，并给出相关代码。包括冒泡排序法，简单排序法，希尔排序法和快速排序法
C语言 几种排序方法（冒泡、选择、插入、归并、快速）
weixin_44636409的博客
08-11 9516
1.冒泡排序 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 算法步骤 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 执行过程： # include <s
c语言中的几种排序方法
m0_62767005的博客
11-13 2680
c语言中的几种排序方法一、冒泡排序原理代码二、插入排序1.有序数组的插入排序原理代码2.无序数组的插入排序三、选择排序原理代码四、总结 排序问题可以说比较大小问题的升级版，自然就会多种不同的操作办法，但是他们的原理和复杂程度却稍有不同，在不同的题目中选择不同的方法可以大大提高我们的效率，以及减少代码的复杂程度。 一、冒泡排序 原理 冒泡排序的原理就是，假设数组中有n个元素，首先每次将相邻两个数比较,则将大的数放到后面,再重复这个过程继续和下一个数比较，那么一次循环过后，就会将整个数组中最大的数放在最后，第二
list排序的几种方法
热门推荐
hans的博客
06-11 6万+
List<Integer> list = new ArrayList<>(); list.add(3); list.add(5); list.add(1); Collections工具类，升序排: Collections.sort(list); System.out.println(list); Console： [1, 3, 5] Collecti...
排序算法之基本几种排序方法
m0_57614828的博客
03-17 1922
排序算法 什么是排序算法 基本都排序算法有哪些 怎么衡量排序算法的优劣 冒泡排序的思想与c语言代码 插入排序的思想与c语言代码 1.什么是排序算法。 当你有一堆数据的时候，看着他们杂乱无章，无序的时候是不是看着特别不爽。是不是特想看着它们是从小到大，或者从大到小排列的，看着就舒服多了。还有哦，排序可不止是让你看着舒服，还有一部分是查找。在一堆数据中查找是否存在一个数据，如果是一堆杂乱无章的数据，我们就只能一个个比较，是否是你要的那个数据，...
数组的几种排序方法
Yurken的博客
05-04 1万+
数组的排序方法有很多，效率也各不相同，下面简单介绍一下几种常见的排序算法。 1.选择排序法：将要排序的数组分成两部分，一部分是从大到小已经排好序的，一部分是无序的，从无序的部分取出最小的放到已经排序的最后面。实现如下： public int[] choiceSort(int[] arr){ for(int i = 0;i < arr.length;i++){ ...
列表中元素的几种排序方法
ymeng9527的博客
06-30 9298
一般的排序方法sort(),属于python的内置方法 names = ['alice','Bob','coco','Harry'] print(names.sort()) 将列表打乱 li = list(range(10)) import random random.shuffle(li) print(li) ...
常见的几种排序方法（冒泡排序、选择排序、插入排序、快速排序等）
qq_38769551的博客
10-17 4819
排序算法有很多，包括插入排序，冒泡排序，堆排序，归并排序，选择排序，计数排序，基数排序，桶排序，快速排序等。 插入排序，堆排序，选择排序，归并排序，快速排序，冒泡排序都是比较排序，它们通过对数组中的元素进行比较来实现排序，其他排序算法则是利用非比较的其他方法来获得有关输入数组的排序信息。 冒泡排序 冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元...
数据结构：常用的几种排序方法
weixin_45054387的博客
03-01 8524
1.冒泡排序 2.选择排序 3.插入排序 4.快速排序 5.希尔排序 6.堆排序
C语言的5种简单排序算法
Finecsr的博客
04-27 5万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
java几种排序方法代码
03-20
使用java实现的选择、冒泡、插入、快速、希尔排序以及折半查找
Java—选择排序
qq_56725871的博客
05-22 258
它的基本思想是从待排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），然后再从剩余未排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），以此类推，直到全部元素排序完成。选择排序的时间复杂度为O(n^2)，其中n为待排序数组的长度。尽管选择排序的时间复杂度较高，但它简单易懂，适用于小规模数据的排序。对于大规模数据，更高效的排序算法如快速排序和归并排序更为常用。以上代码通过遍历整个数组，找到剩余未排序部分的最小值，并将其与当前位置的元素交换，重复这个过程直到数组排序完成。
java第十三课 —— 二维数组 排序
Liuxu 的博客
05-18 1461
数组 排序 查找
如何实现一个高效的排序算法？
xy520521的博客
05-21 277
快速排序时间复杂度为O(nlogn)，空间复杂度为O(logn)，适用于大规模数据排序。例如，对于小规模的数据可以选择插入排序或选择排序，而对于大规模数据可以选择归并排序或快速排序。5.使用适当的数据结构：对于某些特殊类型的数据，选择合适的数据结构可以提高排序效率。例如，对于链表结构可以选择归并排序，而对于数组结构可以选择快速排序。例如，归并排序和插入排序是稳定的，而快速排序是不稳定的。综上所述，实现一个高效的排序算法需要根据具体需求选择合适的算法，并根据实际情况进行优化和改进。
质数和约数
2302_77099705的博客
05-21 1118
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
算法训练营36
最新发布
stmfresher的博客
05-22 176
代码随想录上的思路，让加油 - 耗油，如果所有的总和都<0 那肯定跑不完，然后用一个currsum 统计从 0 开始到当前i 的 剩余油之和，如果 < 0 说明 起始位置肯定在为 i + 1，然后currsum 置零，在重复上面操作，最后返回 start 就行。这道题从两边开始算就好，先从左向右只考虑右边小孩比左边小孩大，然后从右向左考虑，最后取两次糖果数组里大的，然后最后求和即可。根据通过情况反复挑战最终AC过了，这里和原来的差别是他的排序是用绝对值排序的，这样的思路会很简单。
每日一题（PTA Advanced1003）：Emergency-dfs
m0_75015083的博客
05-22 121
【代码】每日一题（PTA Advanced1003）：Emergency-dfs。
unity排序方法有几种
03-28
在Unity中，常用的排序方法有以下几种： 1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果前一个比后一个大，则交换它们的位置，一直重复，直到没有任何一对数字需要交换为止。 2. 快速排序（Quick Sort）：选取...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值