Java之美[从菜鸟到高手演变]之常见的几种排序算法-插入、选择、冒泡、快排、堆排等 .

最新推荐文章于 2016-06-28 14:59:55 发布
最新推荐文章于 2016-06-28 14:59:55 发布
阅读量725 收藏
点赞数

Java面试宝典系列之基础排序算法

作者：egg

邮箱：xtfggef@gmail.com

微博：http://weibo.com/xtfggef

博客：http://blog.csdn.net/zhangerqing（转载请说明出处）


本文就是介绍一些常见的排序算法。排序是一个非常常见的应用场景，很多时候，我们需要根据自己需要排序的数据类型，来自定义排序算法，但是，在这里，我们只介绍这些基础排序算法，包括：插入排序、选择排序、冒泡排序、快速排序（重点）、堆排序、归并排序等等。看下图：


给定数组：int data[] = {9,2,7,19,100,97,63,208,55,78}

一、直接插入排序(内部排序、O(n2)、稳定)

原理：从待排序的数中选出一个来，插入到前面的合适位置。

[java] view plain copy print ?
  1. package com.xtfggef.algo.sort;  
  2.   
  3. public class InsertSort {  
  4.   
  5.     static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };  
  6.   
  7.     public static void insertSort() {  
  8.         int tmp, j = 0;  
  9.         for (int k = 0; k < data.length; k++) {//-----1-----  
  10.             tmp = data[k];  
  11.             j = k - 1;  
  12.             while (j >= 0 && tmp < data[j]) {//-----2-----  
  13.                 data[j + 1] = data[j];  
  14.                 j--;  
  15.             }  
  16.             data[j + 1] = tmp;//------3-------  
  17.         }  
  18.     }  
  19.   
  20.     public static void main(String[] args) {  
  21.         print();  
  22.         System.out.println();  
  23.         insertSort();  
  24.         System.out.println();  
  25.         print();  
  26.     }  
  27.   
  28.     static void print() {  
  29.         for (int i = 0; i < data.length; i++) {  
  30.             System.out.print(data[i] + " ");  
  31.         }  
  32.     }  
  33.   
  34. }  
package com.xtfggef.algo.sort;

public class InsertSort {

	static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };

	public static void insertSort() {
		int tmp, j = 0;
		for (int k = 0; k < data.length; k++) {//-----1-----
			tmp = data[k];
			j = k - 1;
			while (j >= 0 && tmp < data[j]) {//-----2-----
				data[j + 1] = data[j];
				j--;
			}
			data[j + 1] = tmp;//------3-------
		}
	}

	public static void main(String[] args) {
		print();
		System.out.println();
		insertSort();
		System.out.println();
		print();
	}

	static void print() {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + " ");
		}
	}

}
我简单的讲解一下过程：思路上从待排序的数据中选出一个，插入到前面合适的位置，耗时点在插入方面，合适的位置意味着我们需要进行比较找出哪是合适的位置，举个例子：对于 9,2,7,19,100,97,63,208,55,78这组数，第一个数9前面没有，不做操作，当第一个数完后，剩下的数就是待排序的数，我们将要从除去9开始的书中选出一个插入到前面合适的位置，拿到2后，放在tmp上，进行注释中的2处的代码，2处的代码就是通过循环找出这个合适的位置，发现比tmp大的数，立即将该数向后移动一位（这样做的目的是：前面需要空出一位来进行插入），最后通过注释3处的代码将数插入。

 

 

 

 

 

 

 

 

本排序适合：基本有序的数据

二、选择排序（O(n2)、不稳定）
与直接插入排序正好相反，选择排序是从待排序的数中选出最小的放在已经排好的后面，这个算法选数耗时。

[java] view plain copy print ?
  1. package com.xtfggef.algo.sort;  
  2.   
  3. public class SelectSort {  
  4.   
  5.     static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };  
  6.   
  7.     public static void selectSort() {  
  8.         int i, j, k, tmp = 0;  
  9.         for (i = 0; i < data.length - 1; i++) {  
  10.             k = i;  
  11.             for (j = i + 1; j < data.length; j++)  
  12.                 if (data[j] < data[k])  
  13.                     k = j;  
  14.             if (k != i) {  
  15.                 tmp = data[i];  
  16.                 data[i] = data[k];  
  17.                 data[k] = tmp;  
  18.             }  
  19.         }  
  20.     }  
  21.     public static void main(String[] args) {  
  22.         print();  
  23.         System.out.println();  
  24.         selectSort();  
  25.         System.out.println();  
  26.         print();  
  27.     }  
  28.   
  29.     static void print() {  
  30.         for (int i = 0; i < data.length; i++) {  
  31.             System.out.print(data[i] + " ");  
  32.         }  
  33.     }  
  34.   
  35. }  
package com.xtfggef.algo.sort;

public class SelectSort {

	static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };

	public static void selectSort() {
		int i, j, k, tmp = 0;
		for (i = 0; i < data.length - 1; i++) {
			k = i;
			for (j = i + 1; j < data.length; j++)
				if (data[j] < data[k])
					k = j;
			if (k != i) {
				tmp = data[i];
				data[i] = data[k];
				data[k] = tmp;
			}
		}
	}
	public static void main(String[] args) {
		print();
		System.out.println();
		selectSort();
		System.out.println();
		print();
	}

	static void print() {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + " ");
		}
	}

}

通过循环，找出最小的数的下标，赋值于k，即k永远保持待排序数据中最小的数的下标，最后和当前位置i互换数据即可。

三、快速排序（O(nlogn)、不稳定）

快速排序简称快排，是一种比较快的排序，适合基本无序的数据，为什么这么说呢？下面我说下快排的思路：

设置两个指针：i和j，分别指向第一个和最后一个，i像后移动，j向前移动，选第一个数为标准（一般这样做，当然快排的关键就是这个“标准”的选取），从后面开始，找到第一个比标准小的数，互换位置，然后再从前面，找到第一个比标准大的数，互换位置，第一趟的结果就是标准左边的都小于标准，右边的都大于标准（但不一定有序），分成两拨后，继续递归的使用上述方法，最终有序！代码如下：

[java] view plain copy print ?
  1. package com.xtfggef.algo.sort;  
  2.   
  3. public class QuickSortTest {  
  4.   
  5.     static class QuickSort {  
  6.   
  7.         public int data[];  
  8.   
  9.         private int partition(int array[], int low, int high) {  
  10.             int key = array[low];  
  11.             while (low < high) {  
  12.                 while (low < high && array[high] >= key)  
  13.                     high--;  
  14.                 array[low] = array[high];  
  15.                 while (low < high && array[low] <= key)  
  16.                     low++;  
  17.                 array[high] = array[low];  
  18.             }  
  19.             array[low] = key;  
  20.             return low;  
  21.         }  
  22.   
  23.         public int[] sort(int low, int high) {  
  24.             if (low < high) {  
  25.                 int result = partition(data, low, high);  
  26.                 sort(low, result - 1);  
  27.                 sort(result + 1, high);  
  28.             }  
  29.             return data;  
  30.         }  
  31.     }  
  32.   
  33.     static void print(int data[]) {  
  34.         for (int i = 0; i < data.length; i++) {  
  35.             System.out.print(data[i] + " ");  
  36.         }  
  37.     }  
  38.   
  39.     public static void main(String[] args) {  
  40.         int data[] = { 20, 3, 10, 9, 186, 99, 200, 96, 3000 };  
  41.         print(data);  
  42.         System.out.println();  
  43.         QuickSort qs = new QuickSort();  
  44.         qs.data = data;  
  45.         qs.sort(0, data.length - 1);  
  46.         print(data);  
  47.     }  
  48. }  
package com.xtfggef.algo.sort;

public class QuickSortTest {

	static class QuickSort {

		public int data[];

		private int partition(int array[], int low, int high) {
			int key = array[low];
			while (low < high) {
				while (low < high && array[high] >= key)
					high--;
				array[low] = array[high];
				while (low < high && array[low] <= key)
					low++;
				array[high] = array[low];
			}
			array[low] = key;
			return low;
		}

		public int[] sort(int low, int high) {
			if (low < high) {
				int result = partition(data, low, high);
				sort(low, result - 1);
				sort(result + 1, high);
			}
			return data;
		}
	}

	static void print(int data[]) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + " ");
		}
	}

	public static void main(String[] args) {
		int data[] = { 20, 3, 10, 9, 186, 99, 200, 96, 3000 };
		print(data);
		System.out.println();
		QuickSort qs = new QuickSort();
		qs.data = data;
		qs.sort(0, data.length - 1);
		print(data);
	}
}


看看上面的图，基本就明白了。


四、冒泡排序（稳定、基本有序可达O(n)，最坏情况为O(n2)）

冒泡排序是一种很简单，不论是理解还是时间起来都比较容易的一种排序算法，思路简单：小的数一点一点向前起泡，最终有序。

[java] view plain copy print ?
  1. package com.xtfggef.algo.sort;  
  2.   
  3. public class BubbleSort {  
  4.   
  5.     static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };  
  6.   
  7.     public static void bubbleSort() {  
  8.         int i, j, tmp = 0;  
  9.         for (i = 0; i < data.length - 1; i++) {  
  10.             for (j = data.length - 1; j > i; j--) {  
  11.                 if (data[j] < data[j - 1]) {  
  12.                     tmp = data[j];  
  13.                     data[j] = data[j - 1];  
  14.                     data[j - 1] = tmp;  
  15.                 }  
  16.             }  
  17.         }  
  18.     }  
  19.   
  20.     public static void main(String[] args) {  
  21.         print();  
  22.         System.out.println();  
  23.         bubbleSort();  
  24.         System.out.println();  
  25.         print();  
  26.     }  
  27.   
  28.     static void print() {  
  29.         for (int i = 0; i < data.length; i++) {  
  30.             System.out.print(data[i] + " ");  
  31.         }  
  32.     }  
  33.   
  34. }  
package com.xtfggef.algo.sort;

public class BubbleSort {

	static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };

	public static void bubbleSort() {
		int i, j, tmp = 0;
		for (i = 0; i < data.length - 1; i++) {
			for (j = data.length - 1; j > i; j--) {
				if (data[j] < data[j - 1]) {
					tmp = data[j];
					data[j] = data[j - 1];
					data[j - 1] = tmp;
				}
			}
		}
	}

	public static void main(String[] args) {
		print();
		System.out.println();
		bubbleSort();
		System.out.println();
		print();
	}

	static void print() {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + " ");
		}
	}

}


文章最后，给大家推荐一个数据结构学习的网站，有flash演示的：http://www.tyut.edu.cn/kecheng1/site01/index.asp

本章的所有代码我已经上传到了我的资源，有需要的自己去下载：http://download.csdn.net/detail/zhangerqing/5288624 没有积分的，微博上私信我。

作者：egg

邮箱：xtfggef@gmail.com

微博：http://weibo.com/xtfggef

博客：http://blog.csdn.net/zhangerqing（转载请说明出处）

欢迎大家持续阅读本博客，同时提出好的意见和建议！

 

killerlv
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java之美[从菜鸟到高手演变]之设计模式
03-02
总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式...
Python实战-从菜鸟到大牛的进阶之路
07-22
资源名称：Python 实战-从菜鸟到大牛的进阶之路资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
Java之美[从菜鸟到高手演变]之常见的几种排序算法-插入、选择、冒泡、快排、堆排等
热门推荐
智慧演绎，无处不在
04-22 2万+
解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。设置两个指针：i和j，分别指向第一个和最后一个，i像后移动，j向前移动，选第一个数为标准（一般这样做，当然快排的关键就是这个“标准”的选取），从后面开始，找到第一个比标准小的数，互换位置，然后再从前面，找到第一个比标准大的数，互换位置，第一趟的结果就是标准左边的都小于标准，右边的都大于标准（但不一定有序），分成两拨后，继续递归的使用上述方法，最终有序！
Java之美[从菜鸟到高手演变]之常见的几种排序算法-插入、选择、冒泡、快排、堆排等---转载...
weixin_30302609的博客
04-25 37
本文就是介绍一些常见的排序算法。排序是一个非常常见的应用场景，很多时候，我们需要根据自己需要排序的数据类型，来自定义排序算法，但是，在这里，我们只介绍这些基础排序算法，包括：插入排序、选择排序、冒泡排序、快速排序（重点）、堆排序、归并排序等等。看下图： 给定数组：int data[] = {9,2,7,19,100,97,63,208,55,78} 一、直接插入排序(内部排序、O...
Java之美[从菜鸟到高手演变]系列之博文阅读导航
帅性而为1号的博客
06-28 505
在阅读的过程中有任何问题，请联系：egg。 邮箱：xtfggef@gmail.com    微博：http://weibo.com/xtfggef   QQ群：169480361 原文：http://blog.csdn.net/zhangerqing/article/details/8245560#comments Java 初级篇   Java之美[从菜鸟
Java之美[从菜鸟到高手演变]系列
tony的专栏
12-04 661
随着博文越来越多，为博客添加一个导航很有必要！本博客将相继开通Java、CloudFoundry、Linux、Ruby等专栏，都会设立目录，希望读者朋友们能更加方便的阅读！ 在阅读的过程中有任何问题，请联系：egg。 邮箱：xtfggef@gmail.com    微博：http://weibo.com/xtfggef   QQ群：169480361（请在本博文下面留言，验证信息为CSDN
Java之美[从菜鸟到高手演变]系列之博文阅读导航 .
kucaozhuzhu的专栏
02-10 824
http://blog.csdn.net/zhangerqing/article/details/8245560 Java 初级篇   Java之美[从菜鸟到高手演变]之Java学习方法                   Java之美[从菜鸟到高手演变]之字符串的处理 Java之美[从菜鸟到高手演变]之类与对象(一)                     Java之美[从菜鸟到高手演变
大厂真题之菜鸟网络-Java初级.pdf
01-29
Java 基础知识点总结 以下是关于 Java 基础知识点的总结，包括 ==、equals 和 hashCode 的区别、基本数据类型、多态、字符串类、内部类等。 1. ==、equals 和 hashCode 的区别 在 Java 中，==、equals 和 ...
《Java程序员-从笨鸟到菜鸟》PDF下载
07-22
资源名称：《Java程序员-从笨鸟到菜鸟》PDF 下载资源目录：作者简介：..........................................................................................................................................
kettle spoon 免安装包
08-01
kettle spoon 免安装包
2024江西省行政区划矢量图层-省市县乡镇四级行政区划数据下载-带python代码
最新发布
08-01
2024最新江西省行政区划矢量图层数据，包含省、市、县、乡镇四级行政区划数据下载，附带shp转geojson的python代码
大数据中心建设方案.pptx
08-01
大数据中心建设方案.pptx
《通信原理(第6版)》教案.doc
08-01
《通信原理(第6版)》教案
竞争对手消费费用结果分析.xlsx.xlsx
08-01
销售管理，客户类型，客户满意度，客户登记，进销存，客户记录 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
大学生电子设计大赛-无线呼叫系统的设计.rar
08-01
大学生电子设计大赛-无线呼叫系统的设计.rar
雾凇算法RIME优化Transformer-LSTM负荷数据回归预测【含Matlab源码 6406期】.zip
08-01
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化Transformer-LSTM预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化Transformer-LSTM预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化Transformer-LSTM预测 4.4.3 灰狼算法GWO/狼群算法WPA优化Transformer-LSTM预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化Transformer-LSTM预测 4.4.5 萤火虫算法FA/差分算法DE优化Transformer-LSTM预测 4.4.6 其他优化算法优化Transformer-LSTM预测
智能制造的桥梁：CODESYS与SCADA系统集成全解析
08-01
CODESYS是一个可编程逻辑控制器（PLC）的完整开发环境，是Controlled Development System的缩写。它为IEC语言提供了一个简单的编程方法，具有类似于高级编程语言的编辑器和调试器功能，例如Visual C++。CODESYS软件可以编辑显示器界面，具有控制模块，可以放置图片等强大功能 。最新版本是CODESYS V3，它在软件架构上有很大改善，正在申请TUV关于EN 61508的SIL认证 。 CODESYS软件集团专注于工业智能技术、PLC控制器编程开发工具包套件、复杂运动控制及数字化工厂解决方案的研发、销售和技术服务。它基于.NET架构和IEC 61131-3国际编程标准，提供开发PLC控制器的完整解决方案 。 CODESYS软件分为Development System和Runtime System两部分。Development System是编程界面，用于设计、调试和编译PLC程序；Runtime System是程序运行的软件环境，通常安装在硬件设备上。CODESYS Runtime具有强大的适应性，支持大多数操作系统和硬件芯片架构 。 此外，
项目源码-maste笔记
08-01
项目源码-maste笔记
《JAVA程序员晋级之路：从菜鸟到笨鸟》实战指南
"这是一本由曹胜欢编写的，针对Java初学者的指南，旨在帮助学生和开发者从入门到进阶。作者通过自身的学习经历，分享了从‘笨鸟’到‘菜鸟’的过程，尤其专注于SSH框架的深入探讨。书中虽然不涉及所有基础知识的详尽...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值