八大内部排序算法总结

最新推荐文章于 2021-06-07 18:06:32 发布
最新推荐文章于 2021-06-07 18:06:32 发布
阅读量769 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法学习 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/teaandnoodle/article/details/52243985

插入排序：直接插入排序

思想：将数据分为两组，一组为已排序序列，另一组为待排序序列，不断的将待排序序列加入已排序序列。最终得到的是已排序序列。

public class InsertionSort implements Sort{

	public void sort(int a[]){
		for(int i = 1; i < a.length; i++){
			int t = a[i], j = i-1;
			while(j >= 0 && a[j] > t){
				a[j+1] = a[j];
				j--;
			}
			a[j+1] = t;
		}
		SortUtils.print(a);
	}
	public static void main(String[] args) {
		new InsertionSort().sort(SortUtils.generate(10));
	}
}

插入排序：Shell排序

思想：带有间隔的插入排序，插入排序每次的消耗都在比较当前元素在已排序元素中的位置，所以希尔排序要减少这种比较，它使用带有间隔的插入排序方式，每次选取n/2作为间隔，然后跳着比较数据，直到间隔为1结束。

public class ShellSort implements Sort{

	public static void shellNSort(int a[], int k) {
		for (int t = 0; t < k; t++) {
			for (int i = t + k; i < a.length; i += k) {
				int p = a[i], j = i - k;
				while (j >= 0 && p < a[j]) {
					a[j + k] = a[j];
					j -= k;
				}
				a[j + k] = p;
			}
		}
	}

	public void sort(int a[]) {
		int k = a.length / 2;
		while (k >= 1) {
			shellNSort(a, k);
			k /= 2;
		}
		SortUtils.print(a);
	}

	public static void main(String[] args) {
		new ShellSort().sort(new int[] { 49, 38, 65, 97, 76, 13, 27, 48, 55, 4 });
	}

}
选择排序：直接选择排序

思想：每次选择最大或者最小的元素，直到数据结尾，之后再交换最大元素和末尾元素，这之后按照同样的方法找到次小元素，直到只剩下一个元素为止。

public class SelectionSort implements Sort{

	public void sort(int a[]){
		for(int i = 1; i < a.length;i++){
			int max = 0;
			for(int j = 1; j <= a.length-i;j++){
				if(a[j] > a[max]){
					max = j;
				}
			}
			SortUtils.swap(a, max, a.length-i);
			//SortUtils.print(a);
		}
		SortUtils.print(a);
	}
	public static void main(String[] args) {
		new SelectionSort().sort(SortUtils.generate(4091,10));
	}
}

选择排序：堆排序

思想：构建堆数据结构，每次从堆中选出堆顶元素放到堆的末尾，这样当所有的堆顶元素都被放到末尾过一次，整体就是有序的。此外如果是大顶堆，则会是从小到大的顺序，如果是小顶堆，则会是从大到小的顺序。

public class HeapSort implements Sort{
	private static int left(int i) {
		return 2 * i + 1;
	}

	private static int right(int i) {
		return 2 * i + 2;
	}

	public static void maxHeapIFY(int a[], int size, int index) {
		int l = left(index), r = right(index);
		int largest = index;
		if (l < size && a[l] > a[index]) {
			largest = l;
		}
		if (r < size && a[r] > a[largest]) {
			largest = r;
		}
		if (largest != index) {
			SortUtils.swap(a, index, largest);
			maxHeapIFY(a, size, largest);
		}
	}

	public static void buildMaxHeap(int a[]) {
		for (int i = a.length / 2; i >= 0; i--) {
			maxHeapIFY(a, a.length, i);
		}
	}

	public void sort(int a[]) {
		buildMaxHeap(a);
		for (int i = a.length - 1; i > 0; i--) {
			SortUtils.swap(a, 0, i);
			maxHeapIFY(a, i, 0);
		}
		SortUtils.print(a);
	}

	public static void main(String[] args) {
		new HeapSort().sort(new int[] { 9, 9, 7, 6, 5, 4, 3, 2, 1 });
	}

}

交换排序：冒泡排序

思想：每次比较相邻的元素，如果第一个元素比第二个大，那么交换它们的顺序，依次如此，直到末尾，下一次对从头到倒数第二个元素做这些操作，直到最后只剩下一个元素为止。

public class BubbleSort implements Sort {

	public void sort(int a[]) {
		for (int i = a.length - 1; i > 0; i--) {
			boolean flag = false;
			for (int j = 0; j < i; j++) {
				if (a[j] > a[j + 1]) {
					SortUtils.swap(a, j, j + 1);
					flag = true;
				}
			}
			if (!flag) {
				break;
			}

		}
		SortUtils.print(a);
	}

	public static void main(String[] args) {
		new BubbleSort().sort(new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 });
	}

}

交换排序：快速排序

思想：从数据中选出一个元素，每次找到这个元素应该在的位置，使得这个元素左边都比它小，右边都比它大，然后将数据分两组，这个元素左边一组，右边一组，按照这个方式，每次都能找到一个元素应该在的位置，最终所有元素就在自己的位置了。

public class QuickSort implements Sort{

	public static int partition(int a[], int low, int high) {
		int p = a[low];
		while (low < high) {
			while (low < high && a[high] >= p) high--;
			a[low] = a[high];
			while (low < high && a[low] <= p) low++;
			a[high] = a[low];
		}
		a[low] = p;
		return low;
	}

	public static void quicksort(int a[], int low, int high) {
		if (low < high) {
			int p = partition(a, low, high);
			quicksort(a, low, p - 1);
			quicksort(a, p + 1, high);
		}
	}

	public void sort(int a[]) {
		quicksort(a, 0, a.length - 1);
		SortUtils.print(a);
	}

	public static void main(String[] args) {
		new QuickSort().sort(new int[] { 4, 1, 2, 3, 5, 7, 8, 5, 9 });
	}

}

归并排序

思想：每次将数据分为两部分，左边一部分右边一部分，分别做归并排序，然后将两部分合并起来，递归的做这个操作，最终整个数组就是已排序序列。 

public class MergeSort implements Sort{

	public static void merge(int a[], int low, int p, int high){
		int lenC = p-low+1;
		int lenD = high-p;
		int c[] = new int[lenC+1];
		int d[] = new int[lenD+1];
		
		for(int i = 0; i < lenC;i++){
			c[i] = a[low + i];
		}
		for(int i = 0; i < lenD;i++){
			d[i] = a[p + 1 + i];
		}
		c[lenC] = d[lenD] = Integer.MAX_VALUE;
		
		int indexC = 0, indexD = 0;
		for(int i = low; i <= high; i++){
			if(c[indexC] < d[indexD]){
				a[i] = c[indexC++];
			} else {
				a[i] = d[indexD++];
			}
		}
	}
	public static void mergesort(int a[], int low, int high){
		if(low < high){
			int mid = (low + high) / 2;
			mergesort(a, low, mid);
			mergesort(a, mid+1, high);
			
			merge(a, low, mid, high);
		}
	}
	public void sort(int a[]){
		mergesort(a, 0, a.length-1);
		SortUtils.print(a);
	}
	public static void main(String[] args) {
		new MergeSort().sort(new int[]{4,3,2,1,9,8,7,6,5});
	}

}

基数排序（这个算法写的不太好，效率不高）

思想：按照每个位的数据大小排序，如个位，按照大小排序，按十位的大小排序，按百位的大小排序（注意必须使用稳定的排序算法，也就是说排序过程中元素的相对顺序不变），这样排序后，从头到尾取出所有的元素即排序好的序列。

public class RadixSort implements Sort{

	public static class Entry {
		int value;
		Entry next;
		Entry pre;

		public Entry(int value) {
			this(value, null, null);
		}

		public Entry(int value, Entry pre, Entry next) {
			this.value = value;
			this.pre = pre;
			this.next = next;
		}

		public void addNext(Entry e) {
			e.next = next;
			e.pre = this;
			if (next != null)
				next.pre = e;
			next = e;
		}

		public void addPre(Entry e) {
			e.next = this;
			e.pre = pre;
			if (pre != null)
				pre.next = e;
			pre = e;
		}

		public Entry remove() {
			if (pre != null)
				pre.next = next;
			if (next != null)
				next.pre = pre;
			pre = null;
			Entry n = next;
			next = null;
			return n;
		}

		public void clear() {
			while (next != null) {
				next = next.remove();
			}
		}

		public void swap(Entry e) {
			if (e == null)
				return;
			value = (e.value + value) - (e.value = value);
		}

		public String toString() {
			return String.valueOf(value);
		}
	}

	private static Entry bucketsA[] = new Entry[10];
	private static Entry bucketsB[] = new Entry[10];
	static {
		for (int i = 0; i < 10; i++) {
			bucketsA[i] = new Entry(0);
			bucketsB[i] = new Entry(0);
		}
	}

	public static void addToList(Entry head, Entry e, int t) {
		Entry p = head;
		while (p.next != null) {
			if ((p.next.value / t) % 10 > (e.value / t) % 10) {
				p.next.addPre(e);
				break;
			}
			p = p.next;
		}
		if (p.next == null && (p.value / t) % 10 <= (e.value / t) % 10) {
			p.addNext(e);
		}
	}

	public static int[] CollectResult(int a[]) {
		int index = 0;
		for (int j = 0; j < bucketsA.length; j++) {
			Entry p = bucketsA[j].next;
			while (p != null) {
				a[index++] = p.value;
				p = p.next;
			}
		}
		return a;
	}

	public void sort(int a[], int radix) {
		for (int j = 0; j < bucketsA.length; j++) {
			bucketsA[j].clear();
		}
		for (int i = 0; i < a.length; i++) {
			addToList(bucketsA[a[i] % 10], new Entry(a[i]), 1);
		}

		int t = 10;
		for (int i = 1; i < radix; i++) {
			Entry[] bucketsC = bucketsA;// swap
			bucketsA = bucketsB;
			bucketsB = bucketsC;

			for (int j = 0; j < bucketsA.length; j++) {
				bucketsA[j].clear();
			}
			for (int j = 0; j < bucketsB.length; j++) {
				while (bucketsB[j].next != null) {
					Entry e = bucketsB[j].next;
					bucketsB[j].next.remove();
					addToList(bucketsA[(e.value / t) % 10], e, t);
				}
			}
			t *= 10;
		}

		CollectResult(a);
		SortUtils.print(a);
	}
	
	public void sort(int a[]){
		sort(a, 3);
	}

	public static void main(String[] args) {
		new RadixSort().sort(new int[] { 329, 457, 657, 839, 436, 720, 355 }, 3);
	}
}
这里使用了两组桶，其效果可能会比正常的基数排序要差，但是基数的期望复杂度是O(n)。

总结

类别

排序方法

时间复杂度

空间复杂度

稳定性

平均

最好

最坏

插入排序

直接插入

O(n2)

O(n)

O(n2)

O(1)

稳定

 

Shell排序

O(n1.3)

O(n)

O(n2)

O(1)

不稳定

选择排序

直接选择

O(n2)

O(n2)

O(n2)

O(1)

不稳定

 

堆排序

O(nlgn)

O(nlgn)

O(nlgn)

O(1)

不稳定

交换排序

冒泡排序

O(n2)

O(n)

O(n2)

O(1)

稳定

 

快速排序

O(nlgn)

O(nlgn)

O(n2)

O(nlgn)

不稳定

归并排序

 

O(nlgn)

O(nlgn)

O(nlgn)

n

稳定

基数排序

 

O(d(r+n))

O(d(n+rd))

O(d(r+n))

O(rd+n)

稳定

r表示关键字的基数，d表示长度，n表示关键字个数。

稳定排序包括：直接插入、冒泡排序、归并排序、基数排序；基数排序依赖于稳定的排序方式。

附：

public interface Sort {
	public void sort(int a[]);
}

public class SortUtils {

	public static void swap(int a[], int i, int j){
		a[i] = (a[i] + a[j])-(a[j]=a[i]);
	}
	public static void print(int a[]){
		System.out.println(Arrays.toString(a));
	}
	public static Random static_rand = new Random();
	public static Random rand = new Random(37);
	
	public static int[] generate(int seed, int len){
		static_rand.setSeed(seed);
		int a[] = new int[len];
		for(int i =0 ; i < len; i++){
			a[i] = static_rand.nextInt(1000);
		}
		//System.out.print("Generated: ");
		print(a);
		return a;
	}
	public static int[] generate(int len){
		int a[] = new int[len];
		for(int i =0 ; i < len; i++){
			a[i] = rand.nextInt(1000);
		}
		//System.out.print("Generated: ");
		print(a);
		return a;
	}
}


【排序算法】内部排序算法总结
天才小熊猫的博客
03-12 2734
直接插入排序 折半插入排序 希尔排序 起泡排序 快速排序 归并排序 堆排序 下面的排序算法代码都是基于数组实现的。 1：直接插入排序（Straight Insertion Sort） 直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。 一般情况下，第 i 趟直接插入排序的操作为：在含有 i-1 ...
内部排序算法总结
点滴
03-22 1275
内部排序算法总结 排序算法介绍 排序算法主要可以分为内部排序和外部排序，其中内部排序由可以分为非线性时间比较排序和线性时间非比较排序，前者主要通过比较来决定元素之间的相对次序，都有关键字的比较和记录的移动，其时间复杂度不能突破O(nlogn),后者不需要通过比较来进行,可以以线性时间运行。 排序算法分类 非线性时间比较排序： 插入排序：简单插入排序、折半插入排序、希尔...
数据结构和算法设计专题之---八大内部排序
810364804
07-29 212
摘要： 前几天，看到一篇前辈的博文“程序员必知的8大排序”，不禁的手痒起来，重新翻开严蔚敏老师的《数据结构》复习了一遍，然后一一的用java去实现，其中有不足之处，还望各位道友指正出来。 先来看看8种排序之间的关系： 第一：直接插入排序 1.基本思想：在要排序的一组数中，假设前面(n-1) [n&gt;=2] 个数已经是排好顺序的，现在要把...
最快的排序算法 图解八大排序算法——我见过的最详细的讲解（转），排序算法数据结构
04-07
八大排序算法的比较可以从时间复杂度、空间复杂度和稳定性三个方面进行比较，其中选择排序和冒泡排序的时间复杂度都是 O(n^2)，空间复杂度都是 O(1)；插入排序的时间复杂度是 O(n^2)，空间复杂度是 O(1)；归并排序和...
八大排序算法总结经典
08-19
八大排序算法总结经典 排序算法是计算机科学中的一种基本算法，用于对数据进行排序。排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，...
八大排序算法
04-04
本文主要介绍八大内部排序算法，包括直接插入排序、希尔排序、选择排序、冒泡排序、快速排序、堆排序、归并排序以及基数排序，并对每种算法的基本思想、实现原理、时间复杂度以及应用场景进行详细介绍。 #### 二、...
八大内部排序算法详解
快速排序是一种高效的内部排序算法，由C.A.R. Hoare于1960年提出。它的平均时间复杂度为O(nlog2n)，在实际应用中表现出色，特别是当待排序的关键字分布均匀时，快速排序的性能最佳。它通过选取一个“基准”元素，将...
排序算法总结.docx
04-29
本文将对数据结构常见的八大排序算法进行详细阐述，包括它们的基本思想、工作原理以及适用场景。 1. 直接插入排序： 直接插入排序是一种简单直观的排序算法，它的工作原理类似于我们平时手动排序扑克牌。首先，假设...
内部排序（C语言版！）.c
04-18
内部排序（C语言版！）1、从键盘输入上述8个整数，存放在数组quick[8]中，并输出值。 2、输出直接插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序算法每一趟排序的结果，观察关键字次序的变化。 3、如果上述8个整数按照升序输入，即k1={ 2 , 12 , 12 , 21 , 30 , 33 , 45 , 68 }，输出各种排序算法每一趟排序的结果，观察关键字次序的变化。 4、如果上述8个整数按照降序输入，即k2={ 68 , 45 , 33 , 30 , 21 , 12 , 12 , 2}，输出各种排序算法每一趟排序的结果，观察关键字次序的变化。 5、随机产生3万个数，对其进行排序，观察其结果，并测试各排序算法的执行时间，比较执行效率。
【算法导论】 内部排序算法总结
some demo
05-04 3239
  排序名称 时间复杂度 空间复杂度 稳定性 直接插入排序 O(n^2) O(1) 稳定 折半插入排序 O(n^2) O(1) 稳定 希尔排序 O(n^2) O(1) 不稳定 冒泡排序 O(n^2) O(1) 稳定 快速排序 O(n*logn) O(logn) 栈空间 ...
内部排序算法汇总
醉等佳人归
03-14 587
文章目录1.概述1.插入排序（1）直接插入排序O(n2)（2）希尔排序（小于O(n2)）2.快速排序（1）冒泡排序O(n2)（2）快速排序（two pointers） 1.概述 排序是计算结程序设计中的一种重要操作，它的功能是将一个数据元素的任意序列，重新排列一个换关键字有序的序列。 如果排序中存在着两个和两个以上的关键字相等的记录，那么如果排序后的序列是惟一的，则称用的排序方法是稳定的；反之，...
8种经典排序算法总结
yao_hust_iAC的专栏
01-19 841
1.二分查找 代码： int binarySearch(int arr[],int l,int r,int x) {     while(l     {         int m = l + (r-1)/2;//为了防止（l+r溢出）         if(arr[m] == x)             return m;         if(arr[m]
内部排序算法要点总结
fireflylane的博客
11-25 1155
  本文将对于插入排序、冒泡排序、选择排序、希尔排序、归并排序、快速排序、堆排序、分配排序和基数排序做归纳总结，通过一些题目来掌握各大内部排序算法的过程和特点，而不涉及具体的代码。 1、当排序的序列存在多个具有相同关键码的记录时，经过排序后，如果这些记录的相对顺序仍然保持不变，则这个排序算法称为是稳定的。八种内部排序法哪些是稳定的，如果不稳定，如何修改使之稳定？ 插入排序、冒泡排序是稳定的。 ...
算法 - 内部排序方法总结
热门推荐
了解➔熟悉➔掌握➔精通
03-05 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 各种排序方法的性能比较 排序方法 最好时间复杂度 平均时间复杂度 最坏时间复杂度 空间复杂度 稳定性 直接插入排序 O(n) O(n2) O(n2) O(1) 稳定 简单选择排...
内部排序算法总结-第一篇
hequnwang10的博客
01-03 285
内部排序算法总结-第一篇 首先看一下内部排序分类以及各个算法的时间复杂度、空间复杂度和稳定性 一、插入排序 　　1、直接插入排序 (Straight Insertion Sort)的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一...
八大内部排序
weixin_45009662的博客
06-07 295
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里讲的是内部排序。 1、直接插入排序 将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。 算法实现： //第一种排序算法：直接插入排序：如果数组基本有序，我们就用直接插入排序，越有序，时间复杂度越小，极端情况下为O（n） v
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值