程序员没有理由不知道的8大排序

最新推荐文章于 2022-09-17 19:41:51 发布
最新推荐文章于 2022-09-17 19:41:51 发布
阅读量1.1k 收藏 1
点赞数 7
分类专栏： Java Java基础中容易忽视的东西 文章标签： 8大排序 程序员 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gdkyxy2013/article/details/76768815
版权

       排序有内部排序和外部排序，内部排序只使用内存，外部排序内存与外存结合使用。其中，内部排序又分为5大类，分别是：插入排序（直接插入排序、希尔排序），选择排序（简单选择排序、堆排序），交换排序（冒泡排序、快速排序），归并排序和基数排序（又叫分配排序）。归并排序是所需辅助空间最多的排序，堆排序是所需辅助空间最少的排序，快速排序是平均速度最快的排序。

1.直接插入排序

       基本思想：在排好序的n（n>=1）个数中，要把第n+1个数排到前面的n个数中，使之成为n+1个有序的数。如此反复循环，直到全部排好序。

代码实现：

package com.xzw.xzw;

import java.util.Arrays;

/**
 * 直接插入排序
 * @author 象在舞
 *
 */
public class InsertSort {
	//待排序的数
	private static final int[] NUMBERS =  
		{59, 48, 75, 107, 86, 23, 37, 88, 44, 22, 54, 5, 14, 52, 79, 98, 54, 15};
	//直接插入排序方法
	public static void insertSort(int[] array) {  
		for (int i = 1; i < array.length; i++) {  
			int temp = array[i];  
			int j = i - 1;  
			for (; j >= 0 && array[j] > temp; j--) {  
				array[j + 1] = array[j];  
			}  
			array[j + 1] = temp;  
		}  
		System.out.println("排序结果为：" + Arrays.toString(array));  
	}
	public static void main(String[] args) {
		insertSort(NUMBERS);
	}
}
 2.希尔排序

       希尔排序是非稳定的排序算法，效率高，也称递减增量排序算法。

       基本思想：取一个正整数n1<n，把所有相隔n1的待排序数放到一组，每个组内进行直接插入排序；然后取n2<n1，重复上述分组和排序操作，直到ni=1，即所有的待排序数放到一个组中进行排序。

代码实现：

package com.xzw.xzw;

import java.util.Arrays;

/**
 * 希尔排序
 * @author 象在舞
 *
 */
public class ShellSort {
	//待排序的数
	private static final int[] NUMBERS =  
		{59, 48, 75, 107, 86, 23, 37, 88, 44, 22, 54, 5, 14, 52, 79, 98, 54, 15};
	//希尔排序方法
	public static void shellSort(int[] array) {  
		int i, j, temp, index = 1, length = array.length;  
		while (index < length / 3) { 
			index = index * 3 + 1;
		}  
		for (; index > 0; index /= 3) {  
			for (i = index; i < length; i++) {  
				temp = array[i];  
				for (j = i - index; j >= 0 && array[j] > temp; j -= index) {  
					array[j + index] = array[j];  
				}  
				array[j + index] = temp;  
			}  
		}  
		System.out.println("排序结果为：" + Arrays.toString(array));  
	}  
	public static void main(String[] args) {
		shellSort(NUMBERS);
	}
}
3.简单选择排序

       基本思想：在要排序的一组数中，选出最小的那个数与一个数进行位置交换，在剩下的数中选出最小的数与第二个数进行位置交换，如此循环，直至结束。

代码实现：

package com.xzw.xzw;

import java.util.Arrays;

/**
 * 简单选择排序
 * @author 象在舞
 *
 */
public class SelectSort {
	//待排序的数
	private static final int[] NUMBERS =  
		{59, 48, 75, 107, 86, 23, 37, 88, 44, 22, 54, 5, 14, 52, 79, 98, 54, 15};
	//简单选择排序方法
	public static void selectSort(int[] array) {  
		int pos = 0;  
		for (int i = 0; i < array.length; i++) {  
			int j = i + 1;  
			pos = i;  
			int temp = array[i];  
			for (; j < array.length; j++) {  
				if (array[j] < temp) {  
					temp = array[j];  
					pos = j;  
				}  
			}  
			array[pos] = array[i];  
			array[i] = temp;  
		}  
		System.out.println("排序结果为：" + Arrays.toString(array));  
	}  
	public static void main(String[] args) {
		selectSort(NUMBERS);
	}
}
4.堆排序

       基本思想：堆排序是一种树形选择排序，首先是要建堆，然后从堆中找出最大的数作为堆顶，然后剩余的数再建堆，找出最大的数，以此类推，直至排序完成。

代码实现：

package com.xzw.xzw;

import java.util.Arrays;

/**
 * 堆排序
 * @author 象在舞
 *
 */
public class HeapSort {
	//待排序的数
	private static final int[] NUMBERS =  
		{59, 48, 75, 107, 86, 23, 37, 88, 44, 22, 54, 5, 14, 52, 79, 98, 54, 15};
	//堆排序方法
	public static void heapSort(int[] array) {  
		/** 
		 *  第一步：将数组堆化 
		 *  beginIndex = 第一个非叶子节点。 
		 *  从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。 
		 *  叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。 
		 */  
		int len = array.length - 1;  
		int beginIndex = (len - 1) >> 1;  
		for (int i = beginIndex; i >= 0; i--) {  
			maxHeapify(i, len, array);  
		}  
		/* 
		 * 第二步：对堆化数据排序 
		 * 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。 
		 * 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。 
		 * 直至未排序的堆长度为 0。 
		 */  
		for (int i = len; i > 0; i--) {  
			swap(0, i, array);  
			maxHeapify(0, i - 1, array);  
		}  
		System.out.println("排序结果为：" + Arrays.toString(array));
	}  
	//交换数组元素
	private static void swap(int i, int j, int[] array) {  
		int temp = array[i];  
		array[i] = array[j];  
		array[j] = temp;  
	}  
	/** 
	 * 调整索引为 index 处的数据，使其符合堆的特性。 
	 * @param index 需要堆化处理的数据的索引 
	 * @param len   未排序的堆（数组）的长度 
	 */  
	private static void maxHeapify(int index, int len, int[] arr) {  
		int li = (index << 1) + 1; // 左子节点索引  
		int ri = li + 1;           // 右子节点索引  
		int cMax = li;             // 子节点值最大索引，默认左子节点。  
		if (li > len) {  
			return;       // 左子节点索引超出计算范围，直接返回。  
		}  
		if (ri <= len && arr[ri] > arr[li]) { // 先判断左右子节点，哪个较大。  
			cMax = ri; 
		}  
		if (arr[cMax] > arr[index]) {  
			swap(cMax, index, arr);      // 如果父节点被子节点调换，  
			maxHeapify(cMax, len, arr);  // 则需要继续判断换下后的父节点是否符合堆的特性。  
		}  
	} 
	public static void main(String[] args) {
		heapSort(NUMBERS);
	}
}
5.冒泡排序

       基本思想：在要排序的一组数中，当相邻两个数比较之后，较小的数往上冒，较大的数往下沉，以此类推，直至将所有的数排序完成。

代码实现：

package com.xzw.xzw;

import java.util.Arrays;

/**
 * 冒泡排序
 * @author 象在舞
 *
 */
public class BubbleSort {
	//待排序的数
	private static final int[] NUMBERS =  
		{59, 48, 75, 107, 86, 23, 37, 88, 44, 22, 54, 5, 14, 52, 79, 98, 54, 15};
	//冒泡排序方法
	public static void bubbleSort(int[] array) {  
		int temp = 0;  
		for (int i = 0; i < array.length - 1; i++) {  
			for (int j = 0; j < array.length - 1 - i; j++) {  
				if (array[j] > array[j + 1]) {  
					temp = array[j];  
					array[j] = array[j + 1];  
					array[j + 1] = temp;  
				}  
			}  
		}  
		System.out.println("排序结果为：" + Arrays.toString(array));
	} 
	public static void main(String[] args) {
		bubbleSort(NUMBERS);
	}
}
6.快速排序

       基本思想：从待排序的数中选出一个基准元素，通过比较，将待排序的数分成两部分：一部分比基准元素小，一部分比基准元素大（包括与基准元素相等的数）。然后再用相同的方法递归的排序划分好的两部分，直至排序结束。

代码实现：

package com.xzw.xzw;

import java.util.Arrays;

/**
 * 快速排序
 * @author 象在舞
 *
 */
public class QuickSort {
	//待排序的数
	private static final int[] NUMBERS =  
		{59, 48, 75, 107, 86, 23, 37, 88, 44, 22, 54, 5, 14, 52, 79, 98, 54, 15};
	//快速排序方法
	public static void quickSort(int[] array) {  
		_quickSort(array, 0, array.length - 1);  
		System.out.println("排序结果为：" + Arrays.toString(array));
	}  
	//得到基准元素
	private static int getMiddle(int[] list, int low, int high) {  
		int tmp = list[low]; 
		while (low < high) {  
			while (low < high && list[high] >= tmp) {  
				high--;  
			}  
			list[low] = list[high]; 
			while (low < high && list[low] <= tmp) {  
				low++;  
			}  
			list[high] = list[low];
		}  
		list[low] = tmp;            
		return low;                 
	}  


	private static void _quickSort(int[] list, int low, int high) {  
		if (low < high) {  
			int middle = getMiddle(list, low, high);  
			_quickSort(list, low, middle - 1);      //对低字表进行递归排序  
			_quickSort(list, middle + 1, high);      //对高字表进行递归排序  
		}  
	}
	public static void main(String[] args) {
		quickSort(NUMBERS);
	}
}
7.归并排序

       基本思想：把待排序的数分成若干个有序的子序列，然后把有序的子序列合并成一个整体有序的序列。

代码实现：

package com.xzw.xzw;

import java.util.Arrays;

/**
 * 归并排序
 * @author 象在舞
 *
 */
public class MergingSort {
	//待排序的数
	private static final int[] NUMBERS =  
		{59, 48, 75, 107, 86, 23, 37, 88, 44, 22, 54, 5, 14, 52, 79, 98, 54, 15};
	//归并排序方法
	public static void mergingSort(int[] array) {  
		sort(array, 0, array.length - 1);  
		System.out.println("排序结果为：" + Arrays.toString(array));
	}  
	//排序方法
	private static void sort(int[] data, int left, int right) {  
		if (left < right) {  
			//找出中间索引  
			int center = (left + right) / 2;  
			//对左边数组进行递归  
			sort(data, left, center);  
			//对右边数组进行递归  
			sort(data, center + 1, right);  
			merge(data, left, center, right);  
		}  
	}  
	//合并方法
	private static void merge(int[] data, int left, int center, int right) {  
		int[] tmpArray = new int[data.length];  
		int mid = center + 1;  
		//third记录中间数组的索引  
		int third = left;  
		int tmp = left;  
		while (left <= center && mid <= right) {  
			//从两个数组中取出最小的放入中间数组  
			if (data[left] <= data[mid]) {  
				tmpArray[third++] = data[left++];  
			} else {  
				tmpArray[third++] = data[mid++];  
			}  
		}  
		//剩余部分依次放入中间数组  
		while (mid <= right) {  
			tmpArray[third++] = data[mid++];  
		}  
		while (left <= center) {  
			tmpArray[third++] = data[left++];  
		}  
		//将中间数组中的内容复制回原数组  
		while (tmp <= right) {  
			data[tmp] = tmpArray[tmp++];  
		}  
	}  
	public static void main(String[] args) {
		mergingSort(NUMBERS);
	}
}
8.基数排序

       将所有待排序的数统一为同样的数位长度，数位较短的前面补零。然后从最低位开始依次进行一次排序。这样从最低位到最高位排序完成以后，待排序的数就会变成一个有序的数列。

代码实现：

package com.xzw.xzw;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * 基数排序
 * @author 象在舞
 *
 */
public class RadixSort {
	//待排序的数
	private static final int[] NUMBERS =  
		{59, 48, 75, 107, 86, 23, 37, 88, 44, 22, 54, 5, 14, 52, 79, 98, 54, 15};
	//基数排序方法
	public static void radixSort(int[] array) {  
		//首先确定排序的趟数;  
		int max = array[0];  
		for (int i = 1; i < array.length; i++) {  
			if (array[i] > max) {  
				max = array[i];  
			}  
		}  
		int time = 0;  
		//判断位数;  
		while (max > 0) {  
			max /= 10;  
			time++;  
		}  
		//建立10个队列;  
		ArrayList<ArrayList<Integer>> queue = new ArrayList<>();  
		for (int i = 0; i < 10; i++) {  
			ArrayList<Integer> queue1 = new ArrayList<>();  
			queue.add(queue1);  
		}  
		//进行time次分配和收集;  
		for (int i = 0; i < time; i++) {  
			//分配数组元素;  
			for (int anArray : array) {  
				//得到数字的第time+1位数;  
				int x = anArray % (int)Math.pow(10, i + 1) / (int)Math.pow(10, i);  
				ArrayList<Integer> queue2 = queue.get(x);  
				queue2.add(anArray);  
				queue.set(x, queue2);  
			}  
			int count = 0;//元素计数器;  
			//收集队列元素;  
			for (int k = 0; k < 10; k++) {  
				while (queue.get(k).size() > 0) {  
					ArrayList<Integer> queue3 = queue.get(k);  
					array[count] = queue3.get(0);  
					queue3.remove(0);  
					count++;  
				}  
			}  
		}  
		System.out.println("排序结果为：" + Arrays.toString(array));
	}  
	public static void main(String[] args) {
		radixSort(NUMBERS);
	}
}









象在舞
关注
专栏目录
大模型在电商领域的应用与创业规划
AI天才研究院
09-18 212
近年来，人工智能技术飞速发展，尤其是大模型的出现，为各行各业带来了革命性的变革。作为一名资深的字节跳动程序员架构师，您在AI大模型、消费者电商、企业级数据产品研发、大数据分析等领域有着丰富的经验和深刻的理解。在这个万物互联、数据驱动的时代，利用先进的AI技术结合电商业务进行创新创业，是实现个人价值和财富自由的绝佳途径。大模型的核心是深度学习算法，特别是Transformer架构和自监督学习范式。Transformer利用自注意力机制，建模输入序列中任意两个位置之间的长距离依赖关系；
整理程序员常用英语单词1695个
刘海鑫的博客
11-29 6558
序号 英文 词性和中文 英文和中文 1 file n.文件；v.保存文件 file n.文件；v.保存文件 2 command n.命令，指令 command n.命令，指令 3 use v.使用，用途 use v.使用，用途 4 program n.程序 program n.程序 5 line n. (数据，程序)行，线路 line n. (数据，程序)行，线路 6 i
UserWarning: image file could not be identified because WEBP support not install
qq_43765237的博客
09-17 1378
运行出现报错：UserWarning: image file could not be identified because WEBP support not install。经过查询是当前pillow版本太低了，所以需要更新pillow。jupyter,再次执行相关代码，就成功运行了。输出为7.0.0版本。
python PIL库image.open()报错cannot identify image file ‘1.jpg‘/WEBP
weixin_50878401的博客
10-05 3737
python PIL库image.open()报错cannot identify image file ‘1.jpg’/WEBP 1.导入库时使用import Image 更改为from PIL import Image 2.pillow版本问题 pip install pillow更新至最新版 3.anconda特有问题 UserWarning: image file could not be identified because WEBP support not installed WEBP支持未被安装
【Python】UserWarning: image file could not be identified because WEBP support not installed
象在舞的技术专栏
05-21 5823
最近在研究使用Python进行图片裁剪的功能，发现Python的PIL模块在处理图片上有不可替代的优势，但是在使用open()方法加载图片时却报了如下的错误： D:\anaconda\lib\site-packages\PIL\Image.py:2860: UserWarning: image file could not be identified because WEBP support not installed warnings.warn(message) Traceback ...
Linux：rsync error: remote command not found (code 127) at io.c(226) [sender=3.1.2
weixin_46117281的博客
10-22 2万+
rsync同步数据报错： 问题描述： bash: rsync: command not found rsync: connection unexpectedly closed (0 bytes received so far) [sender] rsync error: remote command not found (code 127) at io.c(226) [sender=3.1.2] 原因： 之所以会出现这个问题是因为，不仅同步的机器需要安装rsync，而且在被同步的机器上也需要安装rsync。
程序员简历模板-优秀毕业生15.zip
最新发布
05-24
8. **自我评价**：简洁地阐述自己的优势、性格特点以及与应聘职位匹配的理由。展示出对行业的热情和持续学习的决心。 9. **格式与排版**：简历应保持专业、整洁的格式，避免过多的花哨设计。字体统一，段落间距适中...
程序员技能树的分层分级方法
liinux-Talk is cheap,show me the code.
05-17 1252
版本一 初级—初 掌握java基础，熟悉常用类库。理解java web中的servlet，jsp，并了解常用的框架对java web的封装原理，能够借助框架完成增删改查功能。理解数据库在web开发中的地位。 初级—中 理解java中较为高级的特性，如反射，动态代理，JVM，内存模型，多线程等等。熟练使用框架，对框架中遇到的bug，能够借助日志和搜索引擎分析出问题的原因。在团队中，能够独立完成普通后台业务功能的开发。了解数据库的高级特性，如索引，存储引擎等等。 初级—高 理解java分布式架构，微
安卓软件开发流程图！每个程序员都必须掌握的8种数据结构！已整理成文档
m0_56037919的博客
03-19 1245
前言 最近经常被朋友问到的两个问题。 问题一： “从事IT工作3年了，做技术好累啊，是不是做到30岁就不能继续往下做啊？”问题二： “我已经30岁了，还能不能学编程？” 我给出的答案是： 只要你兴趣还在，可以一直做，什么时候都不会晚；种一棵树最好的时间是十年前，其次是现在。 本人目前在 IT 行业工作了 6 年，做过大大小小的项目，虽然跟网上那些大牛比还差很远。但也确实经历过同样困惑，也迷茫过，踩过很多坑，今后也会继续踩。所以关于这一类问题，也有心得体验，在此算是做个人分享吧。 谈起性能优化，我想问， 什么
【StreamSets】 JDBC_502 - Batch size greater than maximal batch size allowed in sdc.properties
象在舞的技术专栏
06-15 1098
【问题描述】 今天在CDH集群中使用StreamSets的时候报了如下的错误： JDBC_502 - Batch size greater than maximal batch size allowed in sdc.properties, maxBatchSize: 1000 【问题原因】 看错误很明显，默认的maxBatchSize:为1000，咱们从数据源中读取的记录数大于1000，于是会报这个错误。 【解决办法】 CDH监控界面找到Strea...
bash: rsync: command not found报错原因以及解决办法
热门推荐
杨春建的博客
06-24 2万+
原文地址：http://www.21yunwei.com/archives/5184 从一个内网机器往线上一个新服务器1.2.3.4(代替)推送数据，发现无法推送，报如下错误： [root@network ~]$/usr/bin/rsync -avz -P -e ssh test.txt 1.2.3.4:/home/wwwroot/testbash: rsync: command n
Windows安装Pillow错误解决
Q1n6
05-01 8435
因为要使用python进行些图形处理操作，在各种库中挑挑捡捡，找到了Pillow,安装方法看起来也很简单嘛： 然而安装报错了，说是没有zlib包，看官方解释： 什么？？还要去单独安装这两个依赖？？心好累，但是这个肯定不是我一个人的问题： 恩，不管你们信不信，反正我信了（信了你的邪）：）
Webp格式用户Android客户端
学习记录
04-02 8495
今天看淘宝Android客户端的leader分析他们做淘宝客户端的经验的时候，听到了这样一个东西：WEBP，是一种图片格式. 1.百度百科：http://baike.baidu.com/view/4447461.htm WebP (发音"weppy")，一种有损压缩的图形档格式，派生自图像编码格式VP8 。是Google在购买On2 Technologies后发展出来的格式，以BSD授
python Image库 出错
wangqing008的专栏
09-11 3008
False decoder zip not available IOError: cannot identify image file 'tmp_20.png'
Linux上安装Python的PIL和Pillow库处理图片的实例教程
cainiao2013的博客
11-26 5130
图像处理的尝试
bash: rsync: command not found
hwk6155的博客
12-28 3390
rsync
rsync本地及远程复制备份【原创】
weixin_34257076的博客
11-29 369
1、安装rsyncyum instsall rsync   2、本地复制 rsync -auq --progress --delete /tongbu1/ /tongbu2/ rsync -auq --progress --delete --exclude-from='/root/exclude.txt' /opt/mysql/data/ /mysqlbak/binlog/   3、配...
"Java程序员必备：8大排序及其关系
总结：本文介绍了java程序员必须知道的8大排序算法，包括直接插入排序、希尔排序、简单选择排序、堆排序、归并排序、快速排序、计数排序和桶排序。每种排序算法都具有不同的基本思想和实现方法，并且有不同的适用...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

象在舞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值