经典排序算法总结(java代码实现含注释)

0.排序算法和时间复杂度简介

0.1 排序算法简介

0.1.1 排序算法定义

排序算法 (Sort Algorithm)是将一组数据按照指定顺序进行排列的过程。

0.1.2排序算法分类

(1) 内部排序:
     将需要处理的所有数据都加载到内部存储器(内存)中进行排序。
(2) 外部排序法:
     数据量过大,无法全部加载到内存中,需要借助外部存储(文件等)进行排序。
(3)常见排序算法
在这里插入图片描述

0.2 时间复杂度简介

0.2.1 时间频度

算法中语句执行次数称为语句频度或时间频度。记为 T(n)

//计算1-100累加
int n=100;
int sum=0;
for(int i=0;i<n;i++)
    sum+=i;
// T(n)=n+1  时间复杂度O(n)

0.2.2 时间复杂度

算法中的基本操作语句的重复执行次数是问题规模 n 的某个函数,用 T(n)表示。
若有某个辅助函数 f(n),使得当 n 趋近于无穷大时,T(n) / f(n) 的极限值为不等于零的常数,则称 f(n)是 T(n)的同数量级函数。
记作 T(n)=O( f(n) ),称O( f(n) ) 为算法的渐进时间复杂度,简称时间复杂度。

eg:T(n)=n^2+7n+3              O(n)=n2

0.2.3常见时间复杂度

(1) 常数阶 O(1)
(2) 对数阶 O(logn)
(3) 线性阶 O(n)
(4) 线性对数阶 O(nlogn)
(5) k 次方阶 O(nk )
(6) 指数阶 O(2n )
(7)阶乘阶(n!)
上述时间复杂度逐渐增大

0.3 排序算法比较

在这里插入图片描述
术语说明
(1) 稳定:如果 a 原本在 b 前面,且a=b,排序之后 a 仍然在 b 的前面。
(2) 不稳定:如果 a 原本在 b 的前面,且 a=b,排序之后 a 可能会出现在 b 的后面。
(3) 内排序:所有排序操作都在内存中完成。
(4) 外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行。
(5) 时间复杂度: 一个算法执行所耗费的时间。
(6) 空间复杂度:运行完一个程序所需内存的大小。
(7) n: 数据规模。
(8) k: “桶”的个数。
(9) In-place: 不占用额外内存。
(10) Out-place: 占用额外内存

1.冒泡排序

1.1 思路简介

通过对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。

1.2 图解

在这里插入图片描述

1.3 代码实现(优化版本)

public static void bubble(int arr[])
	{
		int len=arr.length;
		boolean flag=true;
		for(int i=0;i<len-1;i++) //第i趟 将相应的值放在相应的位置
		{
			for(int j=0;j<len-1-i;j++)
			{
				int temp=0;
				if(arr[j]>arr[j+1])
				{
					flag=false;
					temp=arr[j+1];
					arr[j+1]=arr[j];
					arr[j]=temp;	
				}
			}
			if(flag)   //某趟排序后 如果没有发生排序 则说明当前顺序是正确的
			{
				break;
			}
			else //如果某趟排序发生了交换 flag=false 再将flag 置为true 便于下趟循环判断
				flag=true;
		}
	}

2.选择排序

2.1 思路简介

第一次从 arr[0]~arr[n-1]中选取最小值,与 arr[0]交换,第二次从 arr[1]~arr[n-1]中选取最小值,与 arr[1]交换,第三次从 arr[2]~arr[n-1]中选取最小值,与 arr[2]交换…第 i 次从 arr[i-1]~arr[n-1]中选取最小值,与 arr[i-1]交换,第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值,与 arr[n-2]交换,总共通过 n-1 次,得到一个按排序码从小到大排列的有序序列。

2.2 图解

在这里插入图片描述

2.3 代码实现

public static void select(int []arr)
	{
		int len=arr.length;
		int temp=0;
		for(int i=0;i<len-1;i++)
		{
			int MinNum=arr[i];
			int MinIndex=i;
			for(int j=i+1;j<len;j++)//一次循环后 找出最小值和最小值对应的下标 (注意 j=i+1)
			{
				if(arr[j]<MinNum)
				{
					MinNum=arr[j];
					MinIndex=j;
				}
			}
			if(MinIndex!=i) //如果MinIndex==i 说明不用交换 否则将最小值赋值给相应的位置
			{
				arr[i]=MinNum;
				arr[MinIndex]=temp;
			}
		}
	}

3.插入排序

3.1 思路简介

把 n 个待排序的元素看成为一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有 n-1 个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表。

3.2 图解

在这里插入图片描述

3.3 代码实现

public static void insert(int []arr)
	{
		int len=arr.length;
		for(int i=1;i<len;i++)
		{
			int InsertValue = arr[i]; //待插入的数据
			int InsertIndex = i - 1;  //初始化待插入数据的初始下标
			if (InsertValue < arr[InsertIndex])
			{
				while (InsertIndex >= 0 && InsertValue < arr[InsertIndex])
				{
					arr[InsertIndex + 1] = arr[InsertIndex];
					InsertIndex--;
				}
				if (InsertIndex + 1 != i)
				{
					arr[InsertIndex + 1] = InsertValue;
				}
			}
		}
	}

4.Shell(希尔)排序

4.1 思路简介

希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序。希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至 1 时,整个文件恰被分成一组,算法便终止。

4.2 图解

在这里插入图片描述

4.3.1 代码实现(交换法)

public static void shell_exchange(int []arr)
	{
		int len=arr.length;
		int temp=0;
		for(int size=len/2;size>0;size/=2)  //步长
		{
			for(int i=size;i<len;i++) //从步长开始到数组长度
			{
				for(int j=i-size;j>=0;j-=size) //插入排序
				{
					if(arr[j]>arr[j+size])
					{
						temp=arr[j+size];
						arr[j+size]=arr[j];
						arr[j]=temp;
					}
				}
			}
		}

4.3.2 代码实现(移位法)

public static void shell_move(int[]arr)
	{
		int len=arr.length;
		int InsertNum=0;
		int InsertIndex=0;
		for(int size=len/2;size>0;size/=2)
		{
			for (int i = size; i < len; i++)
			{
				InsertNum = arr[i];
				InsertIndex = i-size;
				if (InsertNum < arr[InsertIndex])
				{
					while (InsertIndex >= 0 && InsertNum < arr[InsertIndex])
					{
						arr[InsertIndex+size] = arr[InsertIndex];
						InsertIndex -= size;
					}
					arr[InsertIndex+size]=InsertNum;
				}
			}
		}
	}

5.快速排序

5.1 思路简介

通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

5.2 图解

在这里插入图片描述

5.3 代码实现

public static void quickSort(int[] arr, int left, int right)
	{
		int l = left; // 左下标
		int r = right; // 右下标
		int pivot = arr[(left + right) / 2];  // pivot 中轴值
		int temp = 0;   // 临时变量,作为交换时使用
		
		// while 循环的目的是让比 pivot 值小放到左边 比 pivot 值大放到右边
		while (l < r)
		{
			// 在 pivot 的左边一直找,找到大于等于 pivot 值,才退出
			while (arr[l] < pivot)
			{
				l += 1;
			}
			// 在 pivot 的右边一直找,找到小于等于 pivot 值,才退出
			while (arr[r] > pivot)
			{
				r -= 1;
			}
			// 如果 l >= r 说明 pivot 的左右两的值,已经按照左边全部是小于等于 pivot 值,右边全部是大于等于 pivot 值
			if (l >= r)
			{
				break;
			}
			// 交换
			temp = arr[l];
			arr[l] = arr[r];
			arr[r] = temp;
			// 如果交换完后,发现这个 arr[l] == pivot 值 相等 r--, 前移
			if (arr[l] == pivot)
			{
				r -= 1;
			}
			// 如果交换完后,发现这个 arr[r] == pivot 值 相等 l++, 后移
			if (arr[r] == pivot)
			{
				l += 1;
			}
		}
		// 如果 l == r, 必须 l++, r--, 否则为出现栈溢出
		if (l == r)
		{
			l += 1;
			r -= 1;
		}
		// 向左递归
		if (left < r)
		{
			quickSort(arr, left, r);
		}
		// 向右递归
		if (right > l)
		{
			quickSort(arr, l, right);
		}
	}

6.归并排序

6.1 思路简介

采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之)。

6.2 图解


在这里插入图片描述
在这里插入图片描述

6.3 代码实现

public static void mergrSort(int []arr,int left,int right,int []temp)
	{
	    //递归具体运行示意图请往后翻
		if(left<right)
		{
			int mid=(left+right)/2;
			mergrSort(arr, left, mid, temp);//左递归
			mergrSort(arr, mid+1, right, temp);//右递归
			merge(arr, left, mid, right, temp);
		}
	}
/**
	 * @param arr 要排序的数组
	 * @param left 数组左索引
	 * @param mid  中间索引
	 * @param right 数组右索引
	 * @param temp  临时数组
	 */
	public static void merge(int []arr,int left,int mid,int right,int []temp)
	{
		int i=left;
		int j=mid+1;
		int t=0;
		
		//1.
		//先把左右两边(有序)的数据按照规则填充到 temp 数组
		//直到左右两边的有序序列,有一边处理完毕为止
		while(i<=mid && j<=right) 
		{
			//如果左边的有序序列的当前元素,小于等于右边有序序列的当前元素 就将左边当前元素填充到 temp 数组
			//然后将索引++
			if(arr[i]<=arr[j])
			{
				temp[t]=arr[i];
				i++;
				t++;
			}
			else
			{
				temp[t]=arr[j];
				j++;
				t++;
			}
		}
		
		//2.
		//将剩余数据的一边的数据依次全部填充到 temp
		while(i<=mid) //左边的有序序列还有剩余的元素,就全部填充到 temp
		{
			temp[t]=arr[i];
			i++;
			t++;
		}
		while(j<=right) //右边的有序序列还有剩余的元素,就全部填充到 temp
		{
			temp[t]=arr[j];
			j++;
			t++;
		}
		
		//3.
		//将temp元素copy到arr数组
		t=0;
		int tempLeft=left;
		while(tempLeft<=right)
		{
			arr[tempLeft]=temp[t];
			tempLeft++;
			t++;
		}
	}

在这里插入图片描述

7.基数排序

7.1 思路简介

将所有待比较数值统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

7.2 图解

在这里插入图片描述

7.3 代码实现

public static void radixSort(int[] arr)
	{
		// 获取最大位数(先获取最大数 再获取最大数对应的位数)
		int len = arr.length;
		int max = arr[0]; // 先 假定 max 是数组第一个值
		for (int i = 0; i < len; i++)
		{
			if (arr[i] > max)
			{
				max = arr[i];
			}
		}
		int maxLength = (max + "").length();// 最大位数

		// 定义桶 每个桶是二维数组 为了防止每个桶数据溢出 将每个桶大小设置为数据长度(空间换时间)
		final int num = 10; //因为每次获取的数字只有0-9 所以定义10
		int[][] bucket = new int[num][len];
		int[] bucketIndex = new int[num];// 每个桶放了多少数据的索引
		for (int i = 0, n = 1; i < maxLength; i++, n *= 10)
		{
			for (int j = 0; j < len; j++)
			{
				int digit = arr[j] / n % 10; // 获取对应的位数(个位 十位 ...)
				bucket[digit][bucketIndex[digit]] = arr[j];
				bucketIndex[digit]++;
			}

			// 遍历所有桶 依次取出数据 放回原来数组
			int arrIndex = 0;
			for (int buck = 0; buck < num; buck++)
			{
				if (bucketIndex[buck] != 0)
				{
					for (int k= 0; k < bucketIndex[buck]; k++)
					{
						arr[arrIndex] = bucket[buck][k];
						arrIndex++;
					}
					bucketIndex[buck] = 0;// 将该桶所有数据放回原数组后 将该桶索引置0 否则下次将数据放回桶的时候 就会继续上次的位置
				}
			}
		}
	}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值