九大基础排序算法总结

Posted yccy1230

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了九大基础排序算法总结相关的知识,希望对你有一定的参考价值。

九大基础排序算法小结


一直想做份总结,总是抽不出时间,趁着周末闲着直接用了一整天做一份,一些内容参考了网上的一些博主的总结,还有网络上的一些图片。

好了,接下来就看看内容吧!


排序算法:

排序方法

时间复杂度

空间复杂度

稳定性

选用情况

平均情况

最坏情况

最好情况

Insertion Sort

O(n^2)

O(n^2)

O(n)

O(1)

稳定

n较小时

Selection Sort

O(n^2)

O(n^2)

O(n^2)

O(1)

不稳定

n较小时

Bubble Sort

O(n^2)

O(n^2)

O(n)

O(1)

稳定

n较小时

Shell Sort

O(nlog2n)

O(n^s)

O(nlog2n)

O(1)

不稳定

S是所选组数

Quick Sort

O(nlog2n)

O(n^2)

O(nlog2n)

O(nlog2n)

不稳定

n较大时

Merge Sort

O(nlog2n)

O(nlog2n)

O(nlog2n)

O(1)

稳定

n较大时

Heap Sort

O(nlog2n)

O(nlog2n)

O(nlog2n)

O(1)

不稳定

n较大时

Radix Sort

O((n+r)d)

O((n+r)d)

O((n+r)d)

O(n+r)

稳定

位数少,数据量大

Tree Sort

O(nlog2n)

O(nlog2n)

O(nlog2n)

O(1)

(不允许出现重复数字)

基本无序时

注:Radix Sort中n=数字个数; r=分配后链表的个数;d=数字或字符串的位数.



1.插入排序(Insertion Sort)

1)算法描述:

·         Step1:将待排序数组分为有序和无序两组(初始情况下有序组为第一个元素)

·         Step2:取出无序组第一个元素(First_unsorted)放入临时空间,将first_unsorted与有序组从最后一个元素开始进行比较,如果比有序组小,则将有序组中的该元素向后移一位,直到找到第一个比first_unsorted小的时候,将first_unsorted放入。至此,有序组++,无序组--。

·         Step3:重复step2,直到无序组数量为0.

       

算法结束。

 

2)适用情况分析:

·         稳定 

·         数组,链表均可实现

·         空间复杂度O(1) 

·         时间复杂度O(n2) 

·         最差情况:反序,需要移动n*(n-1)/2个元素 

·         最好情况:正序,不需要移动元素

·         数据量较小,较有序的情况下性能较好

 

 

3)参考代码:

顺序版本↓:

template<class List_entry>
void Sortable_List<List_entry>::insertion_sort()
{
	List_entry current;
	if (count == 0)return;
	for (int first_unsorted = 1; first_unsorted < count; first_unsorted++) {
		if (entry[first_unsorted] >= entry[first_unsorted - 1])continue;
		current = entry[first_unsorted];
		int position = first_unsorted;
		do {
			entry[position] = entry[position - 1];
			position--;
		} while (position > 0 && entry[position - 1] > current);
		entry[position] = current;
	}
}


链式版本↓:


template<class List_entry>
void Sortable_list<List_entry>::insertion_sort()
{
	Node<List_entry> *first_unsorted, *last_sorted, *current, *previous;
	if (head == NULL)return;
	last_sorted = head;
	while (last_sorted->next){
		first_unsorted = last_sorted->next;
		if (first_unsorted->entry < head->entry) {
			last_sorted->next = first_unsorted->next;
			first_unsorted->next = head;
			head = first_unsorted;
		}
		else {
			previous = head;
			current = previous->next;
			while (current->entry < first_unsorted->entry) {
				previous = current;
				current = current->next;
			}
			if (current == first_unsorted)last_sorted = first_unsorted;
			else {
				last_sorted->next = first_unsorted->next;
				first_unsorted->next = current;
				previous->next = first_unsorted;
			}
		}
	}
}


2.选择排序(selection Sort)

1)算法描述:

·         Step1:将待排序数组分为有序和无序两组(初始情况下有序组为空)

·         Step2:从左向右扫描无序组,找出最小的元素,将其放置在无序组的第一个位置。至此有序组++,无序组--;

·         Step3:重复Step2,直至无序组只剩下一个元素。

 

算法结束。

 

2)适用情况分析:

·         不稳定 

·         数组,链表均可实现

·         空间复杂度:O(1) 

·         时间复杂度:O(n2)  

·         最坏情况:O(n2) 第一个元素为最大元素,其余元素正序,需要交换n-1个元素(如:4 3 2 1) 

·         最好情况:O(n2) 正序,不需要交换元素

·         选择排序的最坏情况和最好情况下的实际没有太大区别。即选择排序对于原始记录的顺序不敏感。

 

 

3)参考代码:


template<class List_entry>
void Sortable_List<List_entry>::selection_sort()
{
	for (int i = 0; i < count - 1; i++) {
		int min = min_key(i, count - 1);
		swap(min, i);
	}
}

template<class List_entry>
int Sortable_List<List_entry>::min_key(int low, int high)
{
	int min = low;
	for (int i = low + 1; i <= high; i++) {
		if (entry[min] > entry[i])min = i;
	}
	return min;
}

template<class List_entry>
void Sortable_List<List_entry>::swap(int low, int high)
{
	List_entry tmp = entry[low];
	entry[low] = entry[high];
	entry[high] = tmp;
}

 

3. 冒泡排序(Bubble Sort)

1)算法描述:

·         Step1:比较相邻的元素。如果第一个比第二个大,就交换他们两个

·         Step2:对每一对元素均进行此操作,经过一轮后最大的元素应位于最后一位

·         Step3:从第一个元素重复进行前两步,每一轮最后一个元素都不参与比较,进行n轮

       算法结束。

 

2)适用情况分析:

稳定

·         大部分采取顺序,链式也可实现

·         空间复杂度O(1) 

·         时间复杂度O(n2) 

·         数据顺序对算法影响不大

 

3)参考代码:

 

template<class List_entry>
void Sortable_List<List_entry>::bubble_sort()
{
	for(int i=0;i<count;i++)
		for (int j = 0 ; j < count-i-1; j++) 
			if (entry[j] > entry[j+1]) {
				List_entry tmp = entry[j];
				entry[j] = entry[j + 1];
				entry[j + 1] = tmp;
			}
}

 

4.希尔排序(Shell Sort)---插入排序的优化

1)算法描述:

·         Step1:先将整个待排元素序列分割成若干个子序列(由相隔某个“增量”的元素组成的)分别进行直接插入排序

·         Step2:依次缩减增量再进行排序

·         Step3:待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序

 

算法结束

 

因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的,因此希尔排序相较于前几种方法有较大的提升

 

2)适用情况分析:

·         不稳定

·         采取顺序实现,对下标敏感

·         空间复杂度O(1) 

·         时间复杂度O(nlogn)

·         步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列都可以工作。

·         Donald Shell 最初建议步长选择为N/2并且对步长取半直到步长达到1

·         已知的最好步长序列是由Sedgewick提出的(1, 5, 19, 41, 109,...)

 

3)参考代码:


template<class List_entry>
void Sortable_List<List_entry>::shell_sort()
{
	int increment = count;
	do {
		increment = increment / 3 + 1;
		for (int start = 0; start < increment; start++) 
			sort_interval(start, increment);
	} while (increment > 1);
}

template<class List_entry>
void Sortable_List<List_entry>::sort_interval(int start, int increment)
{
	List_entry current;
	int position;
	for (int first_unsorted = start + increment; first_unsorted < count;
		first_unsorted += increment) {
		if (entry[first_unsorted] < entry[first_unsorted - increment]) {
			position = first_unsorted;
			current = entry[position];
			do {
				entry[position] = entry[position - increment];
				position -= increment;
			} while (position > start&&entry[position - increment] > current);
			entry[position] = current;
		}
	}
}


在网络上看到了简化版本的shell sort,也可作参考:

void shellsort3(int a[], int n)
{
	int i, j, gap;

	for (gap = n / 2; gap > 0; gap /= 2)
		for (i = gap; i < n; i++)
			for (j = i - gap; j >= 0 && a[j] > a[j + gap]; j -= gap)
				swap(a[j], a[j + gap]);
}


5.快速排序(Quick Sort)

1)算法描述:

·         Step1:在待排序列中选取一个轴点(pivot),通常选取中间点

·         Step2:将轴点与其他元素进行比较,将比轴点小的元素放在轴点之前,比轴点大的元素放在轴点之后。至此,pivot已被排好序

·         Step3:对0-(pivot-1)和(pivot+1)-n分别递归进行上述两步。

       算法结束。

 

2)适用情况分析:

·         不稳定。

·         顺序实现

·         空间复杂度:O(1) 

·         时间复杂度:O(nlog2n) 

·         最坏情况:O(n2)要排序数组基本有序,基准值每次取最大(最小)元素,退化为冒泡。 

·         最好情况:O(nlog2n) 基准值两边元素个数基本相同.

 

3)参考代码:


template<class List_entry>
void Sortable_List<List_entry>::quick_sort()
{
	do_quick_sort(0, count - 1);
}

template<class List_entry>
void Sortable_List<List_entry>::do_quick_sort(int low, int high)
{
	int pivot_position;
	if (low < high) {
		pivot_position = partition(low, high);
		do_quick_sort(low, pivot_position - 1);
		do_quick_sort(pivot_position + 1, high);
	}
}

template<class List_entry>
int Sortable_List<List_entry>::partition(int low, int high)
{
	List_entry pivot;
	swap(low, (low + high) / 2);					//将pivot放置到第一位
	pivot = entry[low];
	int last_small = low;
	for (int i = low + 1; i <= high; i++)
		if (entry[i] < pivot)  swap(last_small++, i);		//比pivot小的元素前移
	swap(low, last_small);						//将pivot放回
	return last_small;
}


6.归并排序(Merge Sort)

1)算法描述:

Step1:把待排序的列表划分为分成近似相等的两部分

Step2:分别将两个子列表排序(递归进行)

Step3:然后再合并成一个完整的列表

算法结束。

 

2)使用情况分析:

·         稳定 

·         链式实现

·         空间复杂度:O(n) 

·         时间复杂度:O(nlog2n) 

·         最坏情况:O(nlog2n) 

·         最好情况:O(nlog2n)

 

3)参考代码:


template<class List_entry>
void Sortable_list<List_entry>::mergesort(Sortable_list<List_entry> & list)
{
	Sortable_list secondlist;
	if (list.size() > 1) {
		mergedivide(list, secondlist);
		mergesort(list);
		mergesort(secondlist);
		mergecombine(list, secondlist);
	}
}

template<class List_entry>
void Sortable_list<List_entry>::mergecombine(Sortable_list<List_entry> & firstlist, const Sortable_list<List_entry> & secondlist)
{
	Sortable_list tmp;
	List_entry x, y;
	int n = 0, m = 0, i = 0;
	while (n < firstlist.size() && m < secondlist.size()) {
		firstlist.retrieve(n, x);
		secondlist.retrieve(m, y);
		if (x <= y) {
			tmp.insert(i++, x);
			n++;
		}
		else {
			tmp.insert(i++, y);
			m++;
		}
	}
	while (n < firstlist.size()) {
		firstlist.retrieve(n++, x);
		tmp.insert(i++, x);
	}
	while (m < secondlist.size()) {
		secondlist.retrieve(m++, y);
		tmp.insert(i++, y);
	}
	firstlist = tmp;
}

template<class List_entry>
void Sortable_list<List_entry>::mergedivide(Sortable_list<List_entry>& firstlist, Sortable_list<List_entry>& secondlist)
{
	int mid = (firstlist.size() - 1) / 2 + 1;
	List_entry x;
	for (int i = 0; firstlist.retrieve(mid, x)==success; i++) {
		secondlist.insert(i, x);
		firstlist.remove(mid, x);
	}
}


7.堆排序(Heap Sort)

1)算法描述:

         堆的定义:堆是一棵完全二叉树或者是近似完全二叉树。根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆,又称最小堆。根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者,称为大根堆,又称最大堆。

 

·         Step1:建堆,序列分成无序和有序两组(初始有序为0)

·         Step2:取出堆顶最大的元素,与待排序列的最后一个元素作交换,至此,无序组--,有序组++,并对无序组进行堆调整

·         Step3:重复上述步骤,直至无序组仅剩一个元素

       算法结束。

 





2)使用情况分析:

不稳定

顺序结构实现

时间复杂度:o(nlogn)

空间复杂度:o(1)

由于建初始堆所需的比较次数较多,不建议在数据量小的情况下使用

 

3)参考代码:


template<class List_entry>
void Sortable_List<List_entry>::heap_sort()
{
	build_heap();		//建堆
	for (int last_unsorted = count - 1; last_unsorted > 0; last_unsorted--) {
		List_entry current = entry[last_unsorted];				
		entry[last_unsorted] = entry[0];
		insert_heap(current, 0, last_unsorted - 1);				//将最后一个元素插入堆中,获取下一个最值
	}
}

template<class List_entry>
void Sortable_List<List_entry>::insert_heap(const List_entry & current, int low, int high)
{
	int large = 2 * low + 1;
	while (large <= high) {
		if (large < high&&entry[large] < entry[large + 1])
			large++;		//将下标large调整为最大孩节点
		if (entry[large] < current)break;
		else {				//promote entry[large]
			entry[low] = entry[large];
			low = large;
			large = 2 * low + 1;
		}
	}
	entry[low] = current;
}

template<class List_entry>
void Sortable_List<List_entry>::build_heap()
{
	for (int low = count / 2 - 1; low >= 0; low--) {
		List_entry current = entry[low];
		insert_heap(current, low , count - 1);
	}
}


8.基数排序(Radix Sort)

1)算法描述:

LSD:

Step1:将待排序的元素按照最后一位进行分桶操作(桶按照最后一位排序从大到小)

Step2:按顺序将各个桶中的数据连接起来,形成新的序列

Step3:依次对新序列的倒数第二位至第一位进行上述两步操作

算法结束

 

MSD:

Step1:将待排序的元素按照最高位进行分桶操作

Step2:对每个桶的按照第二位进行再次分桶(递归进行)

Step3:进行至最后一位分桶操作完成后,对每个桶进行合并操作,得到有序序列

算法结束

 

 

2)使用情况分析:

·         稳定

·         链式实现

·         时间复杂度:假设在基数排序中,r为基数,d为位数。则基数排序的时间复杂度为O(d(n+r))

·         空间复杂度:在基数排序过程中,对于任何位数上的基数进行“装桶”操作时,都需要n+r个临时空间

·         数据量大时有明显优势,通常使用LSD法

 

3)参考代码:

MSD:


int alphabetic_order(char c)
{
	if (c == ' ' || c == '\\0') return 0;
	if (c >= 'a'&&c <= 'z')return (c - 'a' + 1);
	if (c >= 'A'&&c <= 'Z')return (c - 'A' + 1);
	return 27;
}

void Sortable_list::rethread(queue<Record> queues[])
{
	Record x;
	for (int i = 0; i < max_char; i++)
	while (!queues[i].empty()) {
		x = queues[i].front();
		insert(size(), x);
		queues[i].pop();
	}
}
void Sortable_list::MSD_radix_sort()
{
	Record data;
	queue<Record> queues;
	while(remove(0,data)==success){
		queues.push(data);
	}
	sort(queues, key_size);
}


LSD:


void Sortable_list::LSD_radix_sort()
{
	Record data;
	queue<Record> queues[max_char];
	for (int position = key_size - 1; position >= 0; position--) {
		// Loop from the least to the most significant position.
		while (remove(0, data) == success) {
			int queue_number = alphabetic_order(data.key_letter(position));
			queues[queue_number].push(data); // Queue operation.
		}
		rethread(queues); // Reassemble the list.
	}
}


9.树排序(Tree Sort)

1)算法描述:

对于一棵二叉查找树,中序遍历的序列即为有序序列。

因此,二叉查找树的插入过程也可以看成是排序的过程。即

·         Step1:将无序序列逐一插入二叉排序树。

·         Step2:对二叉排序树进行中序遍历

算法结束

 

2)适用情况分析:

·         不稳定

·         链式实现

·         时间复杂度:o(nlogn)

·         空间复杂度:o(1)

·         Tree sort比较适合于无序的序列,对于基本有序的序列效率较低

 

 

3)参考代码:


template<class Record>
Error_code Binary_search_tree<Record>::c_insert(const Record & item)
{
	Binary_node<Record> *&tmp=root;
	if(!tmp)root = new Binary_node<Record>(item);
	else {
		while (tmp != NULL) {
			if (tmp->data > item)tmp = tmp->left_child;
			else if (tmp->data < item)tmp = tmp->right_child;
			else return duplicate_error;
		}
		tmp = new Binary_node<Record>(item);
		return success;
	}
}

template<class Entry>
void Binary_tree<Entry>::recursive_inorder(Binary_node<Entry>* sub_root, void(*visit)(Entry &))
{
	if (sub_root) {
		recursive_inorder(sub_root->left_child,visit);
		(*visit)(sub_root->data);
		recursive_inorder(sub_root->right_child, visit);
	}
}

template<class Entry>
void Binary_tree<Entry>::recursive_inorder(Binary_node<Entry>* sub_root, void(*visit)(Entry &))
{
	if (sub_root) {
		recursive_inorder(sub_root->left_child,visit);
		(*visit)(sub_root->data);
		recursive_inorder(sub_root->right_child, visit);
	}
}

 


 做的有些仓促,还望大家指正错误。

 

 

以上是关于九大基础排序算法总结的主要内容,如果未能解决你的问题,请参考以下文章

九大排序算法总结

九大排序算法

九大排序算法Java实现

Java九大排序算法总结(复杂度及应用场景)

九大排序算法

九大排序算法(Python 语言实现)