java实现各种排序算法

最新推荐文章于 2022-08-01 12:02:59 发布
最新推荐文章于 2022-08-01 12:02:59 发布
阅读量301 收藏
点赞数 1
分类专栏： 笔记 文章标签： 排序算法 java 算法 快速排序 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Elon15/article/details/108169819
版权

1.冒泡排序：就像冒泡一样，每次将本趟最大的那个数“浮”到数组最末。
时间复杂度为O（N^2）
原理：n个数需要跑n-1趟就可以排好序，n-1个数都放好了之后最后一个数顺序也正确了。
（1）第一层循环控制趟数
（2）第二层循环控制本趟需要两两相互比较的元素个数；每跑一趟，两两相互比较的个数少一。

public class 简单排序 {
public static void main(String[] args) {
	int []a= {5,0,12,3,6,45,1};
	BubbleSort(a);
}
//冒泡排序
private static void BubbleSort(int[] a) {
	// TODO Auto-generated method stub
	for(int i=0;i<a.length-1;i++)//需要跑的趟数，n个数跑n-1趟就行，每趟的目的就是把当前最大的数放到最后
	{
		for(int j=0;j<(a.length-i-1);j++)//本趟需要两两比较的元素个数
		{
			if(a[j]>a[j+1])
			{
				int term=a[j];
				a[j]=a[j+1];
				a[j+1]=term;
			}
		}
	}
	System.out.println("冒泡排序结果");
	for(int i=0;i<a.length;i++)
	{
		System.out.print(a[i]+" ");
	}
}
}

在这里插入图片描述
2.选择排序：每次选择当前最小的数，放到顺序数组中。
时间复杂度为O（N^2）
原理：从数组第0个元素开始，选定第0个元素为本趟最小的数，然后从数组中第1个数开始比较，有比它还小的数就交换。跑完第一趟下来，数组中第0个元素即为数组最小的元素。依此类推，跑n-1趟就可以使数组顺序排列。
（1）第一层循环，i控制的是选定a[i]为本趟最小的数
（2）第二层循环，控制从选定值之后要比较的个数

public class 简单排序2 {
public static void main(String[] args) {
	int []a= {3,5,0,1,2,9};
	SelectSort(a);
}
//选择排序
private static void SelectSort(int[] a) {
	// TODO Auto-generated method stub
	for(int i=0;i<a.length-1;i++)//选定此时数组下标为i的位置为最小的数
	{
		for(int j=i+1;j<a.length;j++)//从选定值的下一位开始比较，直到数组最末
		{
			if(a[j]<a[i])//有比他还小的数，就和他换
			{
				int term=a[i];
				a[i]=a[j];
				a[j]=term;
			}
		}
	}
	System.out.println("选择排序");
	for(int i=0;i<a.length;i++)
	{
		System.out.print(a[i]+" ");
	}
}
}

在这里插入图片描述
3.简单插入排序：在前面序列有序的情况下，将本次的数放到前面有序数列的合适位置。
时间复杂度为O（N^2）
原理：选定一个数，与前面的有序数列从后往前依次比较，放到合适的位置（选定x，之后，与a[i]…a[0]依次比较，如果比x大就后移，x前移）
（1）第一层循环控制选定第i+1个数
（2）第二层循环控制与前面的有序序列（第i个到第0个）依次比较

public class 简单排序3 {
public static void main(String[] args) {
	int []a= {9,0,12,3,6,22};
	SimpleInsertSort(a);
}
//简单插入排序
private static void SimpleInsertSort(int[] a) {
	// TODO Auto-generated method stub
	for(int i=0;i<a.length-1;i++)
	{
		int x=a[i+1];
		for(int j=i;j>=0;j--)
		{
			if(x<a[j])
			{
				a[j+1]=a[j];
				a[j]=x;
			}
		}
	}
	System.out.println("简单插入排序");
	for(int i=0;i<a.length;i++)
	{
		System.out.print(a[i]+" ");
	}
}
}

在这里插入图片描述
4.快速排序：利用分治的思想，确定一个主元将一堆数分成两波，将主元放到数组中合适位置。不断递归，直到排好序为止。
时间复杂度：O(N*logN)

public class 简单排序4 {
public static void main(String[] args) {
	int []a= {9,0,12,3,6,22};
	QuickSort(a,0,a.length-1);//后两个参数表示要排序的数组的前后边界
	System.out.println("快速排序");
	for(int i=0;i<a.length;i++)
	{
		System.out.print(a[i]+" ");
	}
}
//快速排序
private static void QuickSort(int[] a,int p,int r) {
	// TODO Auto-generated method stub
	if(p<r)
	{
		int n=index(a,p,r);
		QuickSort(a, p, n-1);
		QuickSort(a, n+1, r);
	}
}
//单向扫描分区
private static int index(int[] a, int p, int r) {
	// TODO Auto-generated method stub
	int x=a[p];//定主元
	int left=p+1;//左指针
	int right=r;//右指针
	while(left<=right)
	{
		if(a[left]<=x)
		{
			left++;
		}
		else
		{
			int  term=a[right];
			a[right]=a[left];
			a[left]=term;
			right--;
		}
	}
	int term=a[right];
	a[right]=a[p];
	a[p]=term;
	return right;
}
}

在这里插入图片描述

5.归并排序：定主元位置直接就是数组中间下标，然后和快排一样，利用分治不断一分为二；再不断递归到有序，但是只是左侧和右侧各自有序，并不整体有序。这时需要归并两个数组为一个完整有序的数组。
时间复杂度：O(N*logN)

public class 简单排序5 {
public static void main(String[] args) {
	int []a= {8,4,0,12,13,6,9};
	MergeSort(a,0,a.length-1);
	System.out.println("归并排序");
	for(int i=0;i<a.length;i++)
	{
		System.out.print(a[i]+" ");
	}
}
//归并排序
private static void MergeSort(int[] a, int p, int r) {
	// TODO Auto-generated method stub
	if(p<r)
	{
		int mid=p+((r-p)>>1);
		MergeSort(a, p, mid);//左侧有序
		MergeSort(a, mid+1, r);//右侧有序
		Merge(a,p,mid,r);
	}
}
//归并
private static void Merge(int[] a,int p,int mid,int r) {
	// TODO Auto-generated method stub
	int help[]=new int[a.length];
	for(int i=0;i<a.length;i++)
	{
		help[i]=a[i];
	}
	int current=p;
	int left=p;
	int right=mid+1;
	while(left<=mid&&right<=r)
	{
		if(help[left]<=help[right])
		{
			a[current]=help[left];
			current++;
			left++;
		}
		else
		{
			a[current]=a[right];
			current++;
			right++;
		}
	}
	//如果右侧数组有剩余，他本身便在数组对应位置，所以不用管
	while(left<=mid)//如果左侧数组有剩余，全部放到数组末
	{
		a[current]=help[left];
		current++;
		left++;
	}
}
}

在这里插入图片描述
6.堆排序：
1.将待排序数组转化成完全二叉树或者近似完全二叉树
2.大顶堆化：父节点的值均大于子节点值
3.排序：每趟把本趟最大的数（大顶堆顶点）与本趟数组最后一个数交换，然后重新大顶堆化。所有节点都到顶点一次，就把所有数排好了顺序。
时间复杂度：O(N*logN)

public class 堆排序 {
public static void main(String[] args) {
	int []a= {12,7,11,3,6,8,9};
	HeapSort(a);//堆排序
	System.out.println("堆排序后");
	for(int i=0;i<a.length;i++)
	{
		System.out.print(a[i]+" ");
	}
}

private static void HeapSort(int[] a) {
	// TODO Auto-generated method stub
	//1.堆化成大顶堆
	MaxHeap(a);
	int n=a.length;//数组长度
	//2.排序
	for(int i=n-1;i>=0;i--)
	{
		int term=a[i];
		a[i]=a[0];
		a[0]=term;
		MaxHeapFixDown(a, 0, i);//向下堆化
	}
	
}
//大顶堆化
private static void MaxHeap(int[] a) {
	// TODO Auto-generated method stub
	int n=a.length;
	for(int i=n/2-1;i>=0;i--)//从倒数第二层的最后一个节点开始往上不断调整，因为最底的一层是叶子节点，不需要调整
	{
		MaxHeapFixDown(a,i,n);
	}
}
//大顶堆化向下调整
private static void MaxHeapFixDown(int[] a, int i, int n) {
	// TODO Auto-generated method stub
	int left=2*i+1;//左儿子
	int right=2*i+2;//右儿子
	if(left>=n)
	{
		return;//下标越界，意味着没有儿子
	}
	//走到这里了，意味着有左儿子
	int max=left;//暂时定此时两者中数值较大的是左儿子下标
	if(right>=n)
	{
		max=left;//此时不存在右儿子，所以两者中较大的那个数的下标是左儿子---------实锤
	}
	else {//此时左右儿子都存在
		if(a[right]>a[left])
		{
			max=right;//如果右儿子大，便取代max
		}
	}
	//至此，儿子中数值最大的儿子已经求出
	if(a[max]>a[i])//儿子中较大的那个与本来顶部比较，有比顶部大的才交换
	{
	int term=a[i];
	a[i]=a[max];
	a[max]=term;
	}
	MaxHeapFixDown(a, max, n);//递归地将此棵树下面的子树也调整一下,因为你调换之后，只能保证最近的三个节点满足大顶堆
	
}
}

在这里插入图片描述7.计数排序：开辟一个辅助数组，数组下标代表相对于min的相对大小，辅助数组中的内容代表这个值出现次数；扫描一遍原数组，其大小对应相对大小，每出现一次统计数值加一。最后扫描一遍辅助数组，恢复原来大小，输出即排好序。
时间复杂度：O（n）
计数排序适用于数值相对集中的区间，因为辅助空间的大小取决于最大值与最小值之差。如果范围大，需要开辟极大空间，但是很稀疏，浪费空间。对于范围相对集中的数来说，计数排序很快。
还有一种思路，戳这里

public class 完善以后的计数排序 {
public static void main(String[] args) {
	int []a= {5,2,2,1,33,12,-2};
	CountSort(a);
}
//计数排序
private static void CountSort(int[] a) {
	// TODO Auto-generated method stub
	//求最大值max
	int max=0;
	int min=0;
	for(int i=0;i<a.length;i++)
	{
		if(a[i]>max)
		{
			max=a[i];//最大值
		}
		if(a[i]<min)
		{
			min=a[i];//最小值
		}
	}
	int []help=new int[max-min+1];
	for(int i=0;i<a.length;i++)
	{
		int position=a[i]-min;//算出在辅助数组中的相对位置（相对于min）
		help[position]++;//统计出现次数
	}
	int current=0;//相当于回填原数组的指针
	for(int i=0;i<help.length;i++) 
	{
		for(int j=help[i];j>0;j--)
		{
			a[current]=min+i;//恢复原来值：方法是min+数组下标（数组下标是相对于min的大小）
			current++;
		}
	}
	System.out.println("计数排序");
	for(int i=0;i<a.length;i++)
	{
		System.out.print(a[i]+" ");
	}

}
}

在这里插入图片描述
8.桶排序：将数组中的值分成不同的区间（视为桶），然后对各个桶内数值进行排序，最后输出即可。计数排序可以看作是每个数值占一个桶的特殊桶排序。桶排序适用于数值稀疏的区间，如果数值太过于集中，数值会挤到一个桶里，桶排序失效。

import java.util.ArrayList;
import java.util.Collections;

public class 桶排序1 {
public static void main(String[] args) {
	int []a= {12,3,6,6,0,-7,10,-9};
	BucketSort(a);
}
//桶排序
private static void BucketSort(int[] a) {
	// TODO Auto-generated method stub
	//求最大值和最小值
	int max=0;
	int min=0;
	for(int i=0;i<a.length;i++)
	{
		if(a[i]>max)
		{
			max=a[i];
		}
		if(a[i]<min)
		{
			min=a[i];
		}
	}
	int sum=(max-min)/a.length+1;//需要的桶数
	ArrayList<ArrayList<Integer>> BucketArr=new ArrayList<>();//建立可变长的桶数组
	for(int i=0;i<sum;i++)//确定了桶的数量 
	{
		BucketArr.add(new ArrayList<Integer>());//挨个把桶放入可变长桶数组
	}
	for(int i=0;i<a.length;i++)
	{
		int num=(a[i]-min)/a.length;//算出每一个数值对应的桶号
		BucketArr.get(num).add(a[i]);//通过桶号找到对应的桶，然后将数值放进去	
	}
	for(int i=0;i<BucketArr.size();i++)
	{
		Collections.sort(BucketArr.get(i));
	}
	//最后输出排序后的结果
	System.out.println("桶排序后");
	System.out.println(BucketArr.toString());
}
}

在这里插入图片描述
9.基数排序：基数排序是一种特殊的桶排序，将待排序数组的数值，按个、十、百…位分别分类放入数值为0—9这10个桶中，每次按位数的值分一次后，都要将桶中排了一次的数值按顺序放回到原数组中，并且把桶清空以便只有使用。遍历最后的数组就是排了的顺序。
时间复杂度：O（n）

import java.util.ArrayList;

public class 基数排序1 {
public static void main(String[] args) {
	int []a= {15,3,0,6,12,15,-3,-1,-18,123};
	BaseSort(a);
}
//基数排序
private static void BaseSort(int[] a) {
	// TODO Auto-generated method stub
	//求最小值
	int min=0;
	for(int i=0;i<a.length;i++)
	{
		if(a[i]<min)
		{
			min=a[i];
		}
	}
	//使最小值至少为0
	int distance=0-min;
	if(distance>=0)//有负数再加
	{
	for(int i=0;i<a.length;i++)//每个值都加上差距，使最小值也为自然数，所有值都大于等于0
	{
		a[i]=a[i]+distance;
	}
	}
	//求最大值
	int max=0;
	for(int i=0;i<a.length;i++)
	{
		if(a[i]>max) 
		{
			max=a[i];
		}
	}
	int n=0;
	while(max>0)
	{
		max=max/10;
		n++;//算出最大值的位数，也就是需要进行的几轮
	}
//	System.out.println("最大值为"+max);
	ArrayList<ArrayList<Integer>> BucketArr=new ArrayList<ArrayList<Integer>>();//建立桶数组
	for(int i=0;i<10;i++)
	{
		BucketArr.add(new ArrayList<Integer>());//在可变长的桶数组中放上10个桶
	}
	for(int i=0;i<n;i++)//进行的轮数
	{
		for(int j=0;j<a.length;j++)
		{
			//提取本轮需要的位数值
			int term=a[j];
			for(int r=0;r<i;r++)
			{
				term=term/10;
			}
			int c=term%10;//本轮提取的位数值
			//根据位数值，将对应的值放到对应的桶中
			switch(c)
			{
				case 0:BucketArr.get(0).add(a[j]);break;
				case 1:BucketArr.get(1).add(a[j]);break;
				case 2:BucketArr.get(2).add(a[j]);break;
				case 3:BucketArr.get(3).add(a[j]);break;
				case 4:BucketArr.get(4).add(a[j]);break;
				case 5:BucketArr.get(5).add(a[j]);break;
				case 6:BucketArr.get(6).add(a[j]);break;
				case 7:BucketArr.get(7).add(a[j]);break;
				case 8:BucketArr.get(8).add(a[j]);break;
				case 9:BucketArr.get(9).add(a[j]);break;
			}
			
		}
		//将本轮桶中的数再放回数组中（入桶）
		int current=0;//原数组指针
		for(int v=0;v<BucketArr.size();v++)
		{
			for(int b=0;b<BucketArr.get(v).size();b++)
			{
				a[current]=BucketArr.get(v).get(b);
				current++;
			}
		}
		//每入桶出桶一次，清空所有的桶
		for(int y=0;y<BucketArr.size();y++)
		{
			BucketArr.get(y).clear();
		}
	}
	//恢复原来的值
	for(int i=0;i<a.length;i++)
	{
		a[i]=a[i]-distance;
	}
	//输出排序后的结果
	System.out.println("基数排序后");
	for(int i=0;i<a.length;i++)
	{
		System.out.print(a[i]+" ");
	}
	
}
}

在这里插入图片描述

时代&信念
关注
专栏目录
四种常用排序方式(Java实现)
Valishment的博客
08-02 333
插入排序 排序原理： 1.把所有的元素分为两组，已经排序的和未排序的； 2.找到未排序的组中的第一个元素，向已经排序的组中进行插入； 3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位； 原理如图: 第一次操作: 指针指向第二个元素, 将其与前一个元素进行比较 如果满足条件, 则进行交换, 同时指针前移一位, 重复上述步骤, 直到指针到达数组的头 否则说明已经成有序列, 退出当前循环; 第二次操作: 指针指向第
Java中的自然排序
smallrain6的博客
01-27 411
自然排序 java
java 参数排序_java – 如何按不同的参数在不同的时间排序列表
weixin_31574891的博客
02-21 143
我认为你的枚举方法基本上是声音，但switch语句真的需要一个更面向对象的方法。考虑：enum PersonComparator implements Comparator {ID_SORT {public int compare(Person o1, Person o2) {return Integer.valueOf(o1.getId()).compareTo(o2.getId());}},N...
【简单】自然数数组的排序－Java：解法一
了解➔熟悉➔掌握➔精通
01-30 548
package live.every.day.ProgrammingDesign.CodingInterviewGuide.ArrayAndMatrix; import java.util.Arrays; /** * 自然数数组的排序 * * 【题目】 * 给定一个长度为N的整型数组arr，其中有N个互不相等的自然数1~N，请实现arr的排序，但是不要把下标0~N-1位置上的数通过直接 * 赋值的方式替换成1~N。 * * 【要求】 * 时间复杂度为O(N)，额外空间复杂度为O(1)。
JAVA - 自然排序 Comparable
jc15274630894的博客
08-01 630
JAVA --- 自然排序 Comparable
Java实现各种排序算法
03-30
Java作为广泛应用的编程语言，提供了丰富的工具来实现各种排序算法。本文将深入探讨在Java中实现几种经典的排序算法，包括插入排序、归并排序和选择排序。 ### 插入排序（Insertion Sort） 插入排序是一种简单直观...
JAVA实现各种排序算法.pdf
07-14
在Java等编程语言中，实现不同的排序算法可以帮助我们理解数据处理的基本原理，同时也对解决实际问题，尤其是在大数据处理和性能优化中起到关键作用。以下将详细介绍几种常见的排序算法及其Java实现。 1. **直接...
\\(^_^)/ Java实现各种排序算法
08-04
本篇博客将深入探讨如何使用Java实现几种经典的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序以及堆排序。 1. **冒泡排序**： 冒泡排序是一种简单直观的排序算法，通过不断交换相邻的逆序元素...
Java实现快速排序算法+编程知识+技术开发
最新发布
06-14
Java实现快速排序算法+编程知识+技术开发； Java实现快速排序算法+编程知识+技术开发； Java实现快速排序算法+编程知识+技术开发； Java实现快速排序算法+编程知识+技术开发； Java实现快速排序算法+编程知识+技术...
java 调用排序,使用Java对点列表进行排序
weixin_39695954的博客
02-12 99
I have a list of point objects, which I want to sort by a certain coordinate, say the x-values. Does Java provide any useful mechanisms or should I avail myself of one of the common sort algorithms?解决...
java之8大排序（一）---冒泡排序，自然排序
YIN_csdn的博客
09-21 571
5.冒泡排序（1）基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。（2）实例：（3）用java实现[java] view plain copypublic class bubbleSort { public bubbleSort(){
一些简单的java编程题(11) ————三个正整数排序
那就去巴黎的博客
02-11 626
版权声明：保留个人权利，可转载，请注明出处(http://blog.csdn.net/wlsgdsb)。  如程序有不当之处，敬请指正。/* (程序头部注释开始) 版权声明：保留个人权利，可转载，请注明出处(http://blog.csdn.net/wlsgdsb)。 如程序有不当之处，敬请指正。 * 文件名称： 《一些简单的java编程题(11) ————三个正整数排序》 ...
java方法声明中的参数有四类_Java基础（五）Java中的参数传递机制
weixin_42184548的博客
02-28 606
通过前一篇文章的介绍，我们从整体上明白了，Java类中变量的差异性、不同变量在内存中的存储位置，以及变量的生命周期等。今天，我们来看一下Java中参数传递的机制。形参：方法声明时包含的参数声明实参：调用方法时，实际传给形参的参数值Java方法的参数传递机制：Java方法的参数传递只有一种：值传递。所谓值传递，就是将实际参数值的副本，传入方法内，而参数本身不会收到任何影响。PS：传入方法的时实际参数...
java学习总结：Set集合
kior的博客
07-12 127
用HashSet存储字符串并遍历 package com.heima.set; import java.util.HashSet; public class Demo_1Hashset { /* * set集合，无索引，不可以重复，无序（存取不一致） */ public static void main(String[] args) { // TODO Auto-genera...
Java 对象的比较，多个参数进行排序
DeMonnnnnn
01-16 3655
模拟处理器进程的实体类import java.io.Serializable; public class ProcessInfo implements Serializable { private int name;//进程标识符 private int status;//进程状态 private int pri;//进程优先数 private int time;//
java输入四个数排序_java输入几个数，有多少种排序方法
weixin_42506706的博客
02-13 1073
package com.yq1012.test;import java.util.Scanner;import java.util.Vector;/*** @author Administrator** 1算法是这样的，如果给定N个不同字符，将这N个字符全排列，最终的结果将会是N!种。如：给定* A、B、C三个不同的字符，则结果为：ABC、ACB、BAC、BCA、C...
Java自然排序（个人总结-求赞）
Monster__Day的博客
07-20 5920
这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时，比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式，但当我们对多个对象进行排序时，如何比较两个对象的“大小”呢？这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题，JDK提供了两个接口 java.lang.Comparabl
[JAVA]排序
m0_59155415的博客
05-25 642
题目描述：定一个长度为 n 的数组，请你编写一个函数，返回该数组按升序排序后的结果。 1.冒泡排序 首先拿第一个元素和后面的所有一个个比较，如果比后面的大就交换，所以始终会保证第一个元素是最小的，然后再从第二个第三个，以此类推，swap方法表示交换两个数字的值。
Java实现常见排序算法整理
"这篇资源包含了Java实现的各种排序算法，包括插入排序、冒泡排序和选择排序。由作者treeroot于2006年2月2日创建，版本1.0。" 在软件开发中，排序算法是核心的算法之一，它们在处理大量数据时起到关键作用。这里...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值