八大排序算法java代码、复杂度比较以及应用场景

最新推荐文章于 2023-09-01 17:33:02 发布

lumaomao_

最新推荐文章于 2023-09-01 17:33:02 发布

阅读量743

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/lumaomao_/article/details/100762415

版权

java 专栏收录该内容

58 篇文章 0 订阅

订阅专栏

八大排序算法

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

冒泡排序

基本思想：（图片转自这里）

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码如下：

package com.sort;
public class BubbleSort {
	public static void bubblesort(int[] arr) {
		int temp = 0;
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					temp = arr[j + 1];
					arr[j + 1] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}
	public static void main(String[] args) {
		int[] arr = { 10, 5, 8, 9, 4, 3, 1, 6, 7, 2 };
		bubblesort(arr);
		for (int k = 0; k < arr.length; k++)
			System.out.print(arr[k] + " ");
	}
}

堆排序

基本思想：利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。（图片转自这里）

代码如下：

package com.sort;

public class HeapSort {
	public static void heapAdjust(int[] arr, int s, int m) {
		int temp, i, largest;// largest中存关键字较大的记录下标
		temp = arr[s - 1];
		for (i = 2 * s; i < m; i = i * 2) {
			if (arr[i - 1] < arr[i]) {
				largest = i;
				i++;
			} else {
				largest = i - 1;
			}
			if (temp >= arr[largest])
				break;
			arr[s - 1] = arr[largest];
			s = largest + 1;
		}
		arr[s - 1] = temp;
	}
	public static void swap(int[] array, int from, int to) {
		int temp;
		temp = array[from];
		array[from] = array[to];
		array[to] = temp;
	}
	public static void heapsort(int[] arr) {
		for (int i = arr.length / 2; i > 0; i--) {
			heapAdjust(arr, i, arr.length);
		}
		for (int j = arr.length - 1; j > 0; j--) {
			swap(arr, 0, j);
			heapAdjust(arr, 1, j);
		}
	}
	public static void main(String[] args) {
		int[] arr = { 5, 10, 8, 9, 4, 3, 1, 6, 7, 2 };
		heapsort(arr);
		for (int k = 0; k < arr.length; k++)
			System.out.print(arr[k] + " ");
	}
}

插入排序

基本思想：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。类似于打扑克牌的抓牌。（图片转自这里）

代码如下：

package com.sort;

public class InsertSort {
	public static void insertSort(int[] arr) {
		int temp = 0;
		int i, j;
		for (i = 1; i < arr.length; i++) {
			if (arr[i] < arr[i - 1]) {
				temp = arr[i];
				for (j = i; j > 0 && temp < arr[j - 1]; j--) {
					arr[j] = arr[j - 1];
				}
				arr[j] = temp;
			}
		}

	}
	public static void main(String[] args) {
		int[] arr = { 10, 5, 8, 9, 4, 3, 1, 6, 7, 2 };
		insertSort(arr);
		for (int k = 0; k < arr.length; k++)
			System.out.print(arr[k] + " ");
	}
}

归并排序

基本思想（图片转自这里）

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针超出序列尾，然后将另一序列剩下的所有元素直接复制到合并序列尾

代码如下：

package com.sort;
public class MergeSort {
	public static void merge(int[] arr, int start, int mid, int end) {
		int[] temp = new int[arr.length];
		int i = start, j = mid + 1, k = start;
		while (i <= mid && j <= end) {
			if (arr[i] <= arr[j])
				temp[k++] = arr[i++];
			else
				temp[k++] = arr[j++];
		}
		while (i <= mid)
			temp[k++] = arr[i++];
		while (j <= end)
			temp[k++] = arr[j++];
		for (int l = start; l <= end; l++)
			arr[l] = temp[l];
	}

	public static void mergesort(int[] arr, int start, int end) {
		if (start < end) {
			int mid = (start + end) / 2;
			mergesort(arr, start, mid);
			mergesort(arr, mid + 1, end);
			merge(arr, start, mid, end);
		}
	}

	public static void main(String[] args) {
		int[] arr = { 5, 10, 8, 9, 4, 3, 1, 6, 7, 2 };
		mergesort(arr, 0, arr.length - 1);
		for (int k = 0; k < arr.length; k++)
			System.out.print(arr[k] + " ");
	}
}

快速排序

基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。（图片转自这里）

代码如下：

package com.sort;

public class QuickSort {
	public static void quicksort(int[] arr, int start, int end) {
		if (start < end) {
			int index = partition(arr, start, end);
			quicksort(arr, start, index - 1);
			quicksort(arr, index + 1, end);
		}
	}

	private static int partition(int[] arr, int start, int end) {
		int flag = arr[start];
		int i = start, j = end;
		while (i < j) {
			while (i < j && arr[j] >= flag)
				j--;
			if (i < j)
				arr[i++] = arr[j];
			while (i < j && arr[i] <= flag)
				i++;
			if (i < j)
				arr[j--] = arr[i];
		}
		arr[i] = flag;
		return i;
	}

	public static void main(String[] args) {
		int[] arr = { 5, 10, 8, 9, 4, 3, 1, 6, 7, 2 };
		quicksort(arr, 0, arr.length - 1);
		for (int k = 0; k < arr.length; k++)
			System.out.print(arr[k] + " ");
	}
}

基数排序

基本思想：按顺序先排列某一个属性，如扑克牌的花色。（图片转自这里）

代码如下

package com.sort;
public class RadixSort {
	// pos=1表示个位，pos=2表示十位...
	public static int getNumInPos(int num, int pos) {
		int tmp = 1;
		for (int i = 0; i < pos - 1; i++) {
			tmp *= 10;
		}
		return (num / tmp) % 10;
	}
	// 求得最大位数d
	public static int getMaxWeishu(int[] a) {
		int max = a[0];
		for (int i = 0; i < a.length; i++) {
			if (a[i] > max)
				max = a[i];
		}
		int tmp = 1, d = 1;
		while (true) {
			tmp *= 10;
			if (max / tmp != 0) {
				d++;
			} else
				break;
		}
		return d;
	}
	public static void radixsort(int[] a, int d) {
		int[][] array = new int[10][a.length + 1];
		for (int i = 0; i < 10; i++) {
			array[i][0] = 0;// array[i][0]记录第i行数据的个数
		}
		for (int pos = 1; pos <= d; pos++) {
			for (int i = 0; i < a.length; i++) {// 分配过程
				int row = getNumInPos(a[i], pos);
				int col = ++array[row][0];
				array[row][col] = a[i];
			}
			for (int row = 0, i = 0; row < 10; row++) {// 收集过程
				for (int col = 1; col <= array[row][0]; col++) {
					a[i++] = array[row][col];
				}
				array[row][0] = 0;// 复位，下一个pos时还需使用
			}
		}
	}
	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 197, 76, 213, 27, 50, 4 };
		radixsort(arr, getMaxWeishu(arr));
		for (int k = 0; k < arr.length; k++)
			System.out.print(arr[k] + " ");
	}
}

选择排序

基本思想：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。（图片转自这里）

代码如下：

package com.sort;

public class SelectSort {
	public static void selectsort(int[] arr) {
		int n = arr.length;
		for (int i = 0; i < n; i++) {
			int k = i;
			// 找出最小值的下标
			for (int j = i + 1; j < n; j++) {
				if (arr[j] < arr[k]) {
					k = j;
				}
			}
			// 将最小值放到未排序记录的第一个位置
			if (k > i) {
				int tmp = arr[i];
				arr[i] = arr[k];
				arr[k] = tmp;
			}
			for (int l = 0; l < arr.length; l++)
				System.out.print(arr[l] + " ");
			System.out.println();
		}
	}

	public static void main(String[] args) {
		int[] arr = { 5, 10, 8, 9, 4, 3, 1, 6, 7, 2 };
		selectsort(arr);
		for (int k = 0; k < arr.length; k++)
			System.out.print(arr[k] + " ");
	}
}

希尔排序

基本思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。（图片转自这里）

代码如下：

package com.sort;

public class ShellSort {
	private static int items = 2;// 增量变大的时候会有问题
	public static void shellsort(int arr[]) {
		int n = arr.length;
		if (n <= 1)
			return;
		int gapNum = n / items;
		while (gapNum >= 1) {
			for (int i = 0; i < n; i++) {
				for (int j = i; j < n - gapNum; j = j + gapNum) {
					if (arr[j] > arr[j + gapNum]) {
						int temp = arr[j];
						arr[j] = arr[j + gapNum];
						arr[j + gapNum] = temp;
					}
				}
			}
			gapNum = gapNum / items;
		}
	}
	public static void main(String[] args) {
		int[] arr = { 10, 5, 8, 9, 3, 1, 6, 7, 2 };
		shellsort(arr);
		for (int k = 0; k < arr.length; k++)
			System.out.print(arr[k] + " ");
	}
}

算法比较

应用场景

冒泡排序：优化后的冒泡排序可用于当数据已经基本有序，且数据量较小时；
插入排序：若数组基本有序且数据规模较小时，选用插入排序较好；
希尔排序：数据量较小且基本有序时；
选择排序：当数据规模较小时，选择排序性能较好；
堆排序：堆排序适合处理数据量大的情况，数据呈流式输入时用堆排序也很方便；
归并排序：数据量较大且要求排序稳定时；
快速排序：快速排序适合处理大量数据排序时的场景；
基数排序：基数排序虽然时间复杂度较低，但需要满足的条件较多，如果能满足限制条件与空间需求，基数排序自然很快。

lumaomao_

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
八大排序算法java代码、复杂度比较以及应用场景

目录八大排序算法冒泡排序插入排序归并排序快速排序基数排序选择排序希尔排序算法比较应用场景八大排序算法所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。冒泡排序基本思想：（图片转自这里）比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后...
复制链接

扫一扫