六大排序算法的总结

最新推荐文章于 2025-02-22 23:23:44 发布
最新推荐文章于 2025-02-22 23:23:44 发布
阅读量865 收藏 3
点赞数 1
分类专栏： java 文章标签： 排序算法 希尔排序 快速排序 插入排序 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30643987/article/details/70792856
版权
六大排序算法：冒泡排序，快速排序，插入排序，希尔排序，并归排序，堆排序
1.冒泡排序
冒泡排序采用逐个比较的方式，可谓是最原始的排序方式。通过逐次比较 ，把最大值或最小子搬运到数组的最前端或最末端，不难分析出，冒泡排序的时间复杂度是O（n^2）。
优点：不需要额外的空间，写起来比较简单，稳定性强（然而并没有什么意义）。

缺点：时间复杂度太高了。

代码实现：

public void BubbleSort(){
		for(int i=len-2;i>=0;i--){
			for(int j=0;j<=i;j++){
				if(arr[j].compareTo(arr[j+1])>0){
					swap(j,j+1);
				}
			}
		}
	}
2.快速排序

快速排序就是名气很大的快排，之所以能有这个名字是因为它的时间复杂度是O(n*logn)。但其实质上是对于冒泡排序的一种改良。快排的核心思想是从数组中找一个数，然后把数组分成两份，前一份比这个数小，后一份比这个数大，然后用相同的方法来处理前一部分和后一部分。其实不得不说快排的思想和并归排序的思想如出一辙，只能说并归排序是快排的逆过程。

优点：速度快，代码简单，不需要额外空间

缺点：不稳定（需注意的是快排时间复杂的上界等于冒泡排序的时间复杂度O(n^2）

代码实现

public void QuickSort(){
		if(arr==null) return;
		QuickSort(0,len-1);
	}
	private void QuickSort(int start,int end){
		if(start>=end)return;
		int index = start+1;
		int index_end = end;
		anytype partition = arr[start];
		for(int i=start+1;i<=end;i++){
			if(arr[index].compareTo(partition)<0){
				swap(index,index-1);
				index++;
			}else{
				swap(index,index_end);
				index_end--;
			}
		}
		index--;
		QuickSort(start,index-1);
		QuickSort(index+1,end);
	}
3.插入排序

插入排序的核心思想是将一个数插入已经排好序的数组速度是十分的快，插入一个数的时间复杂度是上界是n下界是1。于是你只需要把待排序的数组中的数一个一个的拿出来插到一个空的数组中（当然并不是真的是要新建一个数组），于是这个空的数组就变成一个排好序的数组。

优点：我能说是代码简介吗？不需要额外空间，稳定

缺点：速度慢（O(n^2)）

代码实现：

public void insertSort(){
		for(int i=1;i<len;i++){
			if(arr[i].compareTo(arr[i-1])<0){
				int j=i;
				while(j>=1){
					if(arr[j].compareTo(arr[j-1])<0){
						swap(j,j-1);
						j--;
					}else{
						break;
					}
				}
				
			}
		}
	}
4.希尔排序

希尔排序是插入排序的升级版，它的核心思想和插入排序一样，把数插到一个有序数组的速度很快，所以希尔排序的策略便是人为造成这种有序性。它通过对数组分成n个部分，进行插入排序，然后再分组，这次组数相对于上一次减少，再排序，再分组，知道组数为1。可以看出希尔排序的分组策略对算法的效率有一定的影响，一般我采用初始间隔为len/2的分法。

优点：速度快（平均速度是n^1.3），不需要额外空间

缺点：不稳定

代码实现

public void ShellSort(){
		int gap = len/2;
		while(gap>0){
			for(int i=0;i<gap;i++){
				for(int j=i+gap;j<len;j+=gap){
					int z = j;
					while(z-gap>=0&&arr[z].compareTo(arr[z-gap])<0){
						swap(z,z-gap);
						z=z-gap;
					}
				}
			}
			gap/=2;
		}
	}
5.并归排序

并归排序之前说过了，是倒过来的快排，它的核心思想是把两个排好序的数组合并速度很快。于是它先把数组分成两份，然后对着两部分递归做相同的操作得到排好序的两个数组，然后对他们进行合并。

优点：速度快，稳定

缺点：需要额外空间，代码复杂

代码实现：

public anytype[] MergeSort(Class<anytype> type){
		this.type = type;
		arr = MergeSort(0,len-1);
		return arr;
	}
	private anytype[] MergeSort(int start,int end){
		if(end==start){
			anytype[] tmp = getCopyArr(end-start+1);
			tmp[0] = arr[start];
			return tmp;
		} 
		int mid = (end+start)/2;	
		anytype[] left = MergeSort(start, mid);
		anytype[] right = MergeSort(mid+1, end);
		anytype[] tmp = getCopyArr(end-start+1);
		int leftLen = left.length;
		int rightLen = right.length;
		int leftId = 0;
		int rightId = 0;
		int id=0;
		while(leftId<=leftLen-1&&rightId<=rightLen-1){
			if(left[leftId].compareTo(right[rightId])<0){
				tmp[id] = left[leftId];
				id++;
				leftId++;
			}else{
				tmp[id] = right[rightId];
				id++;
				rightId++;
			}
		}
		if(leftId==leftLen){
			for(int i=rightId;i<rightLen;i++){
				tmp[id] = right[i];
				id++;
			}
		}else{
			for(int i=leftId;i<leftLen;i++){
				tmp[id] = left[i];
				id++;
			}
		}
		return tmp;
		
		
		
	}
6.堆排序

要了解堆排序首先要知道堆这个数据结构，堆排序实际上就是对于堆的deleteMin操作。什么是堆？堆就是一个完全的二叉树，它保证树的根一定是最小值，并且父亲一定比儿子小。于是你只要把堆的根取出来，在恢复堆的结构，再把根取出来。。。就能得到一个有序数组。

优点：速度快且速度大体稳定（O(n*logn)），不需要额外空间

缺点：基本没有缺点，只是速度会有很小的波动，只是最坏情况和最优情况都是O(n*logn)

代码实现

public void HeapSort(){
		//模拟插入 上滤
		heap_insert();
		//模拟删除 下滤
		heap_delete();

	}
	private void heap_insert(){
		for(int i=0;i<len;i++){
			int node = i;
			while(node!=0){
				int father = (node+1)/2-1;
				if(arr[node].compareTo(arr[father])<0){
					swap(node,father);
					node = father;
				}else{
					break;
				}
			}
		}
	}
	private void heap_delete(){
		for(int i=len-1;i>=0;i--){
			swap(i,0);
			int node = 0;
			int left = (node+1)*2-1;
			int right = (node+1)*2;
			while(left<i){
				if(right<i){
					int tmp = arr[right].compareTo(arr[left])<0?right:left;
					if(arr[node].compareTo(arr[tmp])>0){
						swap(node,tmp);
						node = tmp;
						left=(node+1)*2-1;
						right = (node+1)*2;
					}else{
						break;
					}
				}else{
					if(arr[node].compareTo(arr[left])>0){
						swap(node,left);
						node = left;
						left=(node+1)*2-1;
						right = (node+1)*2;
					}else{
						break;
					}
				}
			}
		}
	}


最后是SortFactory代码 整合了六种排序方法 

package xperdit.util;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;

public class SortFactory<anytype extends Comparable<? super anytype>> {
	private anytype[] arr = null;
	private int len = 0;
	private Class<anytype> type;
	public SortFactory(anytype[] arr) {
		this.arr = arr;
		len = arr.length;
	}
	/*
	 * 快排 O(n*logn)
	 */
	public void QuickSort(){
		if(arr==null) return;
		QuickSort(0,len-1);
	}
	private void QuickSort(int start,int end){
		if(start>=end)return;
		int index = start+1;
		int index_end = end;
		anytype partition = arr[start];
		for(int i=start+1;i<=end;i++){
			if(arr[index].compareTo(partition)<0){
				swap(index,index-1);
				index++;
			}else{
				swap(index,index_end);
				index_end--;
			}
		}
		index--;
		QuickSort(start,index-1);
		QuickSort(index+1,end);
	}
	/*
	 * 冒泡排序 O(n^2)
	 */
	public void BubbleSort(){
		for(int i=len-2;i>=0;i--){
			for(int j=0;j<=i;j++){
				if(arr[j].compareTo(arr[j+1])>0){
					swap(j,j+1);
				}
			}
		}
	}
	/*
	 * 堆排序 倒序 O(n)
	 */
	public void HeapSort(){
		//模拟插入 上滤
		heap_insert();
		//模拟删除 下滤
		heap_delete();

	}
	private void heap_insert(){
		for(int i=0;i<len;i++){
			int node = i;
			while(node!=0){
				int father = (node+1)/2-1;
				if(arr[node].compareTo(arr[father])<0){
					swap(node,father);
					node = father;
				}else{
					break;
				}
			}
		}
	}
	private void heap_delete(){
		for(int i=len-1;i>=0;i--){
			swap(i,0);
			int node = 0;
			int left = (node+1)*2-1;
			int right = (node+1)*2;
			while(left<i){
				if(right<i){
					int tmp = arr[right].compareTo(arr[left])<0?right:left;
					if(arr[node].compareTo(arr[tmp])>0){
						swap(node,tmp);
						node = tmp;
						left=(node+1)*2-1;
						right = (node+1)*2;
					}else{
						break;
					}
				}else{
					if(arr[node].compareTo(arr[left])>0){
						swap(node,left);
						node = left;
						left=(node+1)*2-1;
						right = (node+1)*2;
					}else{
						break;
					}
				}
			}
		}
	}
	/*
	 * 并归排序
	 */
	public anytype[] MergeSort(Class<anytype> type){
		this.type = type;
		arr = MergeSort(0,len-1);
		return arr;
	}
	private anytype[] MergeSort(int start,int end){
		if(end==start){
			anytype[] tmp = getCopyArr(end-start+1);
			tmp[0] = arr[start];
			return tmp;
		} 
		int mid = (end+start)/2;	
		anytype[] left = MergeSort(start, mid);
		anytype[] right = MergeSort(mid+1, end);
		anytype[] tmp = getCopyArr(end-start+1);
		int leftLen = left.length;
		int rightLen = right.length;
		int leftId = 0;
		int rightId = 0;
		int id=0;
		while(leftId<=leftLen-1&&rightId<=rightLen-1){
			if(left[leftId].compareTo(right[rightId])<0){
				tmp[id] = left[leftId];
				id++;
				leftId++;
			}else{
				tmp[id] = right[rightId];
				id++;
				rightId++;
			}
		}
		if(leftId==leftLen){
			for(int i=rightId;i<rightLen;i++){
				tmp[id] = right[i];
				id++;
			}
		}else{
			for(int i=leftId;i<leftLen;i++){
				tmp[id] = left[i];
				id++;
			}
		}
		return tmp;
		
		
		
	}
	/*
	 * 插入排序
	 */
	public void insertSort(){
		for(int i=1;i<len;i++){
			if(arr[i].compareTo(arr[i-1])<0){
				int j=i;
				while(j>=1){
					if(arr[j].compareTo(arr[j-1])<0){
						swap(j,j-1);
						j--;
					}else{
						break;
					}
				}
				
			}
		}
	}
	/*
	 * 希尔排序
	 */
	public void ShellSort(){
		int gap = len/2;
		while(gap>0){
			for(int i=0;i<gap;i++){
				for(int j=i+gap;j<len;j+=gap){
					int z = j;
					while(z-gap>=0&&arr[z].compareTo(arr[z-gap])<0){
						swap(z,z-gap);
						z=z-gap;
					}
				}
			}
			gap/=2;
		}
	}
	
	
	
	
	
	
	private anytype[] getCopyArr(int length){
		anytype[] tmp = (anytype[]) Array.newInstance(type, length);
		return tmp;
	}
	
	
	
	
	
	private void swap(int i,int j){
		anytype tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}
}










JavaScript数组排序的六种常见算法总结
10-14
在JavaScript编程中，数组排序是一项常见的操作，本文将详细介绍六种常见的排序算法，它们分别是希尔排序、sort排序、桶排序、冒泡排序，以及另外两种未在内容中具体提及的排序算法：快速排序和选择排序。...
面试常问的六大排序算法（代码+动画图解）
01-20
文章目录初级排序算法选择排序插入排序希尔排序冒泡排序高级排序算法归并排序快速排序 初级排序算法 选择排序 动画演示 代码实现 public class selectSort { public static void main(String[] args) { int[] ...
六大排序算法总结
L_smartworld的博客
05-06 545
１.冒泡排序 图解冒泡 　　我们以[8,2,5,9,7]这组数字来做示例，上图来战： 　　我们从左往右依次冒泡，将小的往右移动 　　首先比较第一个数和第二个数的大小，我们发现2比8要小，那么保持原位，不做改动。位置还是8,2,5,9,7。 　　指针往右移动一格，接着比较： 　　比较第二个数和第三个数的大小，发现2比5要小，所以位置交换，交换后数组更新为：[8,5,2,9,...
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 67万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
【排序算法】六大比较类排序算法——插入排序、选择排序、冒泡排序、希尔排序、快速排序、归并排序【详解】
最新发布
2401_87820834的博客
02-22 1707
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减地排列起来地操作。稳定性：假定在待排序地记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i] = r[j]，且 r[i] 在 r[j] 之前，而在排序后的序列中。r[i] 仍在 r[j] 之前。则称这种排序算法是稳定的。否则称为不稳定的。内部排序：数据元素全部放在内存中的排序。（我们下面讲的排序都是属于内部排序）外部排序。
六大排序算法
NeverWA的博客
03-20 1万+
排序 1.冒泡排序 　冒泡排序是一种极其简单的排序算法，也是我所学的第一个排序算法。它重复地走访过要排序的元素，依次比较相邻两个元素，如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，排序完成。这个算法的名字由来是因为越小(或越大)的元素会经由交换慢慢“浮”到数列的顶端。 　　冒泡排序算法的运作如下： 比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。 对每一对相...
六大排序算法精讲（SelectSort、BubbleSort、InsertSort、MergeSort、QuickSort、HeapSort）
少渊的博客
12-25 2198
一、前言 最近在看算法公开课，听了很多老师讲了不少很有用的东西，但是只听不练很快就忘了，所以我还是选择以博客的方式巩固自己的学习。 二、排序算法概述 今天主要讲的是比较经典的六大排序算法：选择排序、冒泡排序、插入排序、归并排序、快速排序和堆排序，除此之外还有一个比较重点的基数排序，但是因为它是不基于比较的排序，所以用法不是很广泛，所以我也只讲解它的实现原理，不多做阐述，并且，在讲解之余，我也会穿插一些其他内容。 三、选择排序 选择排序是最基础的一...
六大排序(算法详解+模板+例题)
Alex_Fufu的博客
09-01 1306
排序算法（Sorting Algorithms）是一种数据结构操作，它的目的是将一串元素按照特定的顺序规则组织起来。常见的排序算法有升序（从小到大）和降序（从大到小）排列，如冒泡排序、希尔排序、插入排序、选择排序、快速排序、归并排序等。排序的主要目的是为了方便查找、分析数据，提高数据处理效率。在计算机科学中，数组、列表或数据库查询结果等都可以通过排序来进行整理。每种排序算法的时间复杂度和空间复杂度都有所不同，选择哪种算法取决于实际应用场景的需求和性能要求。步骤：1.从第一个元素开始，该元素可以认为已经被排序
常用排序算法总结
11-06
### 常用排序算法总结 #### 一、冒泡排序 冒泡排序是一种简单的排序算法，它重复地遍历待排序的数列，依次比较相邻的两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复进行的，直到没有再需要...
六大排序算法（插冒归堆选择快排）
Kobe Bryant的专栏
06-11 1324
计划花一个月时间刷刷数据结构与算法，先拿排序热热身吧。import java.util.Random;public class Sort { /** * 插入排序 * */ public void insertSort(int[]a,int len){ if(len<=0){ return; }
六大排序算法：冒泡、插入、希尔、选择、堆排序、快速排序（附源码）
qq_51216031的博客
02-29 1460
向下调整建堆：倒着往上调整，而叶子节点是不需要向下调整的，所以调整位置从最后一个节点的父亲节点开始向上，逐个进行向下调整我们的数据序列在物理结构上是一个数组，逻辑上是一个二叉树，从最后一个节点的父亲节点开始，依次向前，对数组的每一个数据进行向下调整，这样就保证了每一个节点都进行了向下调整建堆因此，比较重要的是向下调整的逻辑：
六大常见排序算法（插入、堆排、希尔、选择、冒泡、快速）
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
09-04 2510
六大排序算法，有图有真相！！！
六种排序算法详解（含代码演示）
Guqing_f的博客
04-28 460
1. 冒泡排序 2. 选择排序 3. 插入排序 4. 基数排序 5. 快速排序 6. 归并排序 1.冒泡排序 时间复杂度：O(n^2) 空间复杂度：O(1) **核心思路：**每次比较相邻的元素，将大的元素交换至后面，每一堂操作会将最大值“冒泡”到数组后面。操作次数=待排序数组长度-1 代码演示： #include<stdio.h> #include <stdlib.h> #include <string.h> #define swap(a, b) {__typeof(
6大排序算法总结
the_conquer_zzy的专栏
12-19 487
5大排序算法—老生常谈的问题，我却不精通 很遗憾虽然排序算法作为最基本的算法，然而我自以为我也会这种算法，但是我忽略的一个事实，我只知道这种算法的思想，真正实现或者使用的次数却屈指可数。但是我一直认为我是会的……， 直到有一天，有人给我一张纸说，来写个快排吧，我说快排的主要思想是……，他说：先写出来吧，于是我写了，大概5分钟，他看了看说，这是谁教你的……，我能感受的到，他并没有满意我写的快
六种排序算法的JavaScript实现以及总结
weixin_34090643的博客
05-24 123
最近几天在系统的复习排序算法，之前都没有系统性的学习过，也没有留下过什么笔记，所以很快就忘了，这次好好地学习一下。 首先说明为了减少限制，以下代码通通运行于Node V8引擎而非浏览器，源码在我的GitHub，感兴趣的话可以下载来然后运行试试。 为了方便对比各个排序算法的性能，这里先写了一个生成大规模数组的方法——generateArray： exports.generateArray = fun...
6种排序算法
zc461346605的博客
07-16 406
6种排序算法插入排序原理代码冒泡排序原理代码选择排序原理代码归并排序原理代码快速排序原理代码堆排序原理代码 插入排序 原理 插入排序，顾名思义肯定是已插入为主，将待排序的数组分为已排序（数组前部分）和未排序（数组后部分），这里我们已从小到大排序，数组为num[0–end]刚开始排序时，固定第一个数num[0]为已经排序好的数，从第二个数num[1]开始，从后往前比较已排序中的数据，如果小于num[...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值