各类排序总结【代码】

最新推荐文章于 2022-08-21 11:02:09 发布
最新推荐文章于 2022-08-21 11:02:09 发布
阅读量316 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TaoTaoFu/article/details/75152192
版权
JAVA 同时被 2 个专栏收录
26 篇文章 0 订阅
订阅专栏
算法
13 篇文章 0 订阅
订阅专栏

一. 前期准备

1.  利用java.lang.Math.random()生成数据

	public int[] getRandomList_one(int n) {

		int[] data = new int[n];
		for( int i=0 ; i<10 ; i++ ) {
			data[i] = (int)(Math.random()*100);
		}
		return data;
	}

2.  利用java.util.Random生成数据

        import java.util.Random;

	public int[] getRandomList_two(int n) {
		
		int[] data = new int[n];
		Random r = new Random();
		for( int i=0 ; i<10 ; i++ ) {
			data[i] = r.nextInt()%100;
		}
		return data;
	}


3.  打印数据

#数据从0开始

	public void printListData(int[] data) {
		
		for(int d : data)
			System.out.print(d+" ");
		System.out.println();
	}

#数据从1开始

	public void printListData_other(int[] data) {
		
		boolean signal = false;
		for(int d : data) {
			if(signal == false){
				signal = true;
				continue;
			}		
			System.out.print(d+" ");
		}
		System.out.println();
	}

二.算法代码

1.  插入排序

1.1  直接插入排序

	public void InsertSort(int[] data) {
		
		int len = data.length;
		for(int i=1;i<len;i++) {
			if(data[i] > data[i-1]) 
				continue;
			for(int j=i;j>0;j--) {
				if(data[j] < data[j-1]) {
					int tmp = data[j];
					data[j] = data[j-1];
					data[j-1] = tmp;
				}				
			}
		}
		printListData(data);
	}

1.2  折半插入排序 

	public void InsertSort_other(int[] data) {
		
		int len = data.length;
		for(int i=2;i<len;i++) {
			if(data[i]<data[i-1]) {
				data[0] = data[i];
				int j = i-1;
				do {
					data[j+1] = data[j];
					j--;
				}while(data[j]>data[0]);
				data[j+1] = data[0];
			}		
		}
		printListData_other(data);
	}

1.3  希尔排序 

	public void HashSort(int[] data) {
		
		int len = data.length;
		for( int step = len/2; step>0; step/=2 ) {
			for(int i = step; i < len; i++) {
				for(int j = i ; j - step >= 0; j = j - step) {
					if(data[j-step] > data[j]) {
						int tmp = data[j-step];
						data[j-step] = data[j];
						data[j] = tmp;
					}
				}
			}
		}
		printListData(data);	
	}

2.  交换排序

2.1  冒泡排序

	public void BubbleSort_one(int[] data) {
		
		int len = data.length;
		int times = len - 1;
		for (int t = 0; t < times; t++) {
			int signal = 1;
			for( int i = 0 ; i < len - t - 1; i++ ) {
				if( data[i] > data[i+1] ) {
					int tmp = data[i];
					data[i] = data[i+1];
					data[i+1] = tmp;
					signal = 0;
				}
			}
			if(signal == 1)
				break;
		}
		printListData(data);
	}

	
	public void BubbleSort_two(int[] data) {
		
		int len = data.length;
		int times = len - 1;
		for (int t = 0; t < times; t++) {
			int signal = 1;
			for( int i = len-1 ; i > t; i-- ) {
				if( data[i] < data[i-1] ) {
					int tmp = data[i];
					data[i] = data[i-1];
					data[i-1] = tmp;
					signal = 0;
				}
			}
			if(signal == 1)
				break;
		}
		printListData(data);
	}

2.2  快速排序 

	public int getPosition(int[] data, int low ,int high) {
		
		int tmp = data[low];
		while( low < high) {
			while(low < high && data[high]>=tmp) 
				high--;
			data[low] = data[high];
			while(low < high && data[low]<=tmp)
				low++;
			data[high] = data[low];
		}
		data[low] = tmp;	
		return low;
	}
	
	
	public void QuickSort(int[] data,int low,int high) {
		
		if(low<=high) {	
			int position = getPosition(data,low,high);
			QuickSort(data,low,position-1);
			QuickSort(data,position+1,high);
		}
	}

3.  选择排序

3.1  直接选择排序

	public void ChooseSort(int[] data) {
		
		int len = data.length;
		for(int step=0; step < len; step++ ) {
			int position = step;
			for (int i=step+1; i<len; i++) {
				if(data[position] > data[i])
					position = i;
			}
			if( step != position ) {
				int tmp = data[step];
				data[step] = data[position];
				data[position] = tmp;
			}
		}
		printListData(data);	
	}

3.2  堆排序 

	public void buildHeapTree(int[] data,int i) {
		
		for(int j=(i-1)/2;j>=0;j--) {
			int tmp_j = j;
			int left = 2*j+1;
			int right = 2*(j+1);
			int sign = -1;
			while(right <=i  && left<=i) {
				if(right<i && data[right]>data[left]) 
					sign = right;
				else
					sign = left;
				if(data[sign] > data[tmp_j]) {
					int tmp = data[sign];
					data[sign] = data[tmp_j];
					data[tmp_j] = tmp;

					tmp_j = sign;					
					left = 2*tmp_j+1;
					right = 2*(tmp_j+1);
				}
				else 
					break;
			}
		}
	}
	
	public void getMinDataByTree(int[] data,int i) {
		
		int min = data[0];
		data[0] = data[i];
		data[i] = min;
	}
	
	
	public void HeapSort(int[] data) {
		
		int len = data.length;
		buildHeapTree(data,len);
		for(int i=len;i>0;i--) {	
			getMinDataByTree(data,i-1);	
			buildHeapTree(data,i-1);
		}
		printListData(data);	
	}

4.  归并排序

4.1  二路归并排序

	public void Merge(int[] data,int low,int mid,int high) {
		
		int len = high - low + 1;
		int[] tmp_data = new int[len];
		int m = low, n=mid+1, j=0;
		while(m<=mid&&n<=high) {
			if(data[m]<data[n])  
				tmp_data[j++] = data[m++];
			else 
				tmp_data[j++] = data[n++];
		}
		while(m<=mid)
			tmp_data[j++] = data[m++];
		while(n<=high)
			tmp_data[j++] = data[n++];
		for(int i=low,k=0;i<=high;i++,k++) 
			data[i] = tmp_data[k];	
	}
	
	public void TwoMergeSort(int[] data,int low,int high) {
		
		if(low<high){
			int mid = (low+high)/2;
			TwoMergeSort(data,low,mid);
			TwoMergeSort(data,mid+1,high);
			Merge(data,low,mid,high);
		}
	}


三.  完整代码

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;


public class Main {

	public int[] getRandomList_one(int n) {
		
		int[] data = new int[n];
		for( int i=0 ; i<10 ; i++ ) {
			data[i] = (int)(Math.random()*100);
		}
		return data;
	}
	
	
	public int[] getRandomList_two(int n) {
		
		int[] data = new int[n];
		Random r = new Random();
		for( int i=0 ; i<10 ; i++ ) {
			data[i] = r.nextInt()%100;
		}
		return data;
	}	
	
	
	public void printListData(int[] data) {
		
		for(int d : data)
			System.out.print(d+" ");
		System.out.println();
		
	}
	
	public void printListData_other(int[] data) {
		
		boolean signal = false;
		for(int d : data) {
			if(signal == false){
				signal = true;
				continue;
			}		
			System.out.print(d+" ");
		}
		System.out.println();
	}	
	public void BubbleSort_one(int[] data) {
		
		int len = data.length;
		int times = len - 1;
		for (int t = 0; t < times; t++) {
			int signal = 1;
			for( int i = 0 ; i < len - t - 1; i++ ) {
				if( data[i] > data[i+1] ) {
					int tmp = data[i];
					data[i] = data[i+1];
					data[i+1] = tmp;
					signal = 0;
				}
			}
			if(signal == 1)
				break;
		}
		printListData(data);
	}

	
	public void BubbleSort_two(int[] data) {
		
		int len = data.length;
		int times = len - 1;
		for (int t = 0; t < times; t++) {
			int signal = 1;
			for( int i = len-1 ; i > t; i-- ) {
				if( data[i] < data[i-1] ) {
					int tmp = data[i];
					data[i] = data[i-1];
					data[i-1] = tmp;
					signal = 0;
				}
			}
			if(signal == 1)
				break;
		}
		printListData(data);
	}	
	
	
	
	
	public void getCurrentTime() {
		Date date = new Date();
		SimpleDateFormat sdf=new SimpleDateFormat("ss"); 
		sdf.format(date); 
		System.out.println("Time now: "+sdf.format(date));
	}
	
	
	public void InsertSort(int[] data) {
		
		int len = data.length;
		for(int i=1;i<len;i++) {
			if(data[i] > data[i-1]) 
				continue;
			for(int j=i;j>0;j--) {
				if(data[j] < data[j-1]) {
					int tmp = data[j];
					data[j] = data[j-1];
					data[j-1] = tmp;
				}				
			}
		}
		printListData(data);
	}
	
	
	public void InsertSort_other(int[] data) {
		
		int len = data.length;
		for(int i=2;i<len;i++) {
			if(data[i]<data[i-1]) {
				data[0] = data[i];
				int j = i-1;
				do {
					data[j+1] = data[j];
					j--;
				}while(data[j]>data[0]);
				data[j+1] = data[0];
			}		
		}
		printListData_other(data);
	}	
	
	
	public void BinInsertSort(int[] data) {
		int len = data.length;
		for(int i=1;i<len;i++) {
			int low = 0 , high = i-1 , mid = (low+high)/2;
			while(low<=high) {
				if(data[mid] >= data[i]) 
					high = mid - 1;
				else if (data[mid] < data[i]) 
					low = mid + 1;
				
				mid = (low+high)/2;
			}
			
			int d = data[i];
			for(int j = i-1; j>=low ;j--) 
				data[j+1] = data[j];
			
			data[low] = d;
		}
		printListData(data);	
	}
	
	
	public int getPosition(int[] data, int low ,int high) {
		
		int tmp = data[low];
		while( low < high) {
			while(low < high && data[high]>=tmp) 
				high--;
			data[low] = data[high];
			while(low < high && data[low]<=tmp)
				low++;
			data[high] = data[low];
		}
		data[low] = tmp;	
		return low;
	}
	
	
	public void QuickSort(int[] data,int low,int high) {
		
		if(low<=high) {	
			int position = getPosition(data,low,high);
			QuickSort(data,low,position-1);
			QuickSort(data,position+1,high);
		}
	}
	
	
	public void HashSort(int[] data) {
		
		int len = data.length;
		for( int step = len/2; step>0; step/=2 ) {
			for(int i = step; i < len; i++) {
				for(int j = i ; j - step >= 0; j = j - step) {
					if(data[j-step] > data[j]) {
						int tmp = data[j-step];
						data[j-step] = data[j];
						data[j] = tmp;
					}
				}
			}
		}
		printListData(data);	
	}
	
	
	
	public void ChooseSort(int[] data) {
		
		int len = data.length;
		for(int step=0; step < len; step++ ) {
			int position = step;
			for (int i=step+1; i<len; i++) {
				if(data[position] > data[i])
					position = i;
			}
			if( step != position ) {
				int tmp = data[step];
				data[step] = data[position];
				data[position] = tmp;
			}
		}
		printListData(data);	
	}
	
	
	public void buildHeapTree(int[] data,int i) {
		
		for(int j=(i-1)/2;j>=0;j--) {
			int tmp_j = j;
			int left = 2*j+1;
			int right = 2*(j+1);
			int sign = -1;
			while(right <=i  && left<=i) {
				if(right<i && data[right]>data[left]) 
					sign = right;
				else
					sign = left;
				if(data[sign] > data[tmp_j]) {
					int tmp = data[sign];
					data[sign] = data[tmp_j];
					data[tmp_j] = tmp;

					tmp_j = sign;					
					left = 2*tmp_j+1;
					right = 2*(tmp_j+1);
				}
				else 
					break;
			}
		}
	}
	
	public void getMinDataByTree(int[] data,int i) {
		
		int min = data[0];
		data[0] = data[i];
		data[i] = min;
	}
	
	
	public void HeapSort(int[] data) {
		
		int len = data.length;
		buildHeapTree(data,len);
		for(int i=len;i>0;i--) {	
			getMinDataByTree(data,i-1);	
			buildHeapTree(data,i-1);
		}
		printListData(data);	
	}
	
	public void Merge(int[] data,int low,int mid,int high) {
		
		int len = high - low + 1;
		int[] tmp_data = new int[len];
		int m = low, n=mid+1, j=0;
		while(m<=mid&&n<=high) {
			if(data[m]<data[n])  
				tmp_data[j++] = data[m++];
			else 
				tmp_data[j++] = data[n++];
		}
		while(m<=mid)
			tmp_data[j++] = data[m++];
		while(n<=high)
			tmp_data[j++] = data[n++];
		for(int i=low,k=0;i<=high;i++,k++) 
			data[i] = tmp_data[k];	
	}
	
	public void TwoMergeSort(int[] data,int low,int high) {
		
		if(low<high){
			int mid = (low+high)/2;
			TwoMergeSort(data,low,mid);
			TwoMergeSort(data,mid+1,high);
			Merge(data,low,mid,high);
		}
	}
	
	public static void main(String[] args) {
		
		Main m = new Main();
		int[] data = m.getRandomList_two(10);
		System.out.println("【Original Data】");
		m.printListData(data);
		
/*		System.out.println("【BubbleSort】");
		m.BubbleSort_two(data);
		
		System.out.println("【InsertSort】");
		m.InsertSort(data);
		
		int[] d = {0,4,73,24,29,-87,65,75,74,-52};
		m.printListData_other(d);
		System.out.println("【InsertSort_S】");
		m.InsertSort_other(d);
		
		System.out.println("【BinInsertSort】");
		m.BinInsertSort(data);
		
		System.out.println("【QuickSort】");
		m.QuickSort(data, 0, data.length-1);
		m.printListData(data);
		
		System.out.println("【HashSort】");
		m.HashSort(data);
		
		System.out.println("【ChooseSort】");
		m.HashSort(data);
		
		System.out.println("【HeapSort】");
		m.HeapSort(data);*/
		
		System.out.println("【TwoMergeSort】");
		m.TwoMergeSort(data,0,data.length-1);
		m.printListData(data);
	}
}





TaoTaoFu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各类排序代码实现
啊奥的博客
07-23 5351
以下各种排序算法是我自己跟着算法描述写的（有参考其他人的），直接贴到VS里就能用，如果要看懂的话还是需要了解一下各种排序算法的实现原理 先随手总结一下各种排序的时间复杂度以及稳定性 排序算法 时间复杂度 辅助空间 稳定性 冒泡排序(交换排序类) O(n^2) ...
总结各类排序方法
05-05
总结各类排序方法。排序问题一直是计算机技术研究的重要问题，排序算法的好坏直接影响程序的执行速度和辅助存储空间的占有量。此代码将详细分析常见的各种排序算法，并从时间复杂度、空间复杂度、适用情况等多个方面...
[code] 各种排序算法代码
Blanchedingding的博客
08-22 765
1. 选择排序 2. 插入排序 3. 冒泡排序 4. 箱排序 5. 桶排序 6. 基数排序 7. 计数排序 8. 归并排序 9. 快速排序 10. 堆排序： 1. 选择排序 public class SelectionSort { //最好和最坏都是O(n^2),unstable public static void sort(int[] a) { ...
几种常用的排序代码
janbar的博客
10-18 241
目录简单的代码使用go自带的排序对[]int类型排序对[]float64类型排序对[]string类型排序自定义类型排序便携的用法sort.Slice便携的用法sort.SliceStable总结简单的代码     在我的笔记里面找到几种常用的排序代码，包括“冒泡排序、选择排序、二分排序、快速排序”。关于这些排序的原理，我之前是有专门研究的，网上也有很多教程。 package main imp...
常见排序代码一览
左灯右行的爱情
03-07 2588
加油冲！
Java中信号量 Semaphore
0≡(-∞,+∞)
05-02 672
Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。自从5.0开始，jdk在java.util.concurrent包里提供了Semaphore 的官方实现，因此大家不需要自己去实现Semaphore。 下面的类使用信号量控制对内容池的访问： Java代码   import java.util.concurrent.Semaphore;  
各种排序算法代码
FlyingJack
04-23 2894
插入排序 #include <iostream> #include <algorithm> #include <cstdio> using namespace std; int const N = 10 + 5; int main(){ int n = 10; int test[N] = {12,9,2,31,10,1,15,7,8,11...
排序算法总结-C语言
jiejiezuishuai的博客
08-21 723
排序算法总结-C语言
排序算法总结
qq_40691562的博客
03-03 2140
排序算法总结 概述： 转眼大三了，总结下排序算法，对以后推免，找工作都十分有益。 先来个排序算法总结，再详细讨论。 一、冒泡排序（Bubble Sort） 第一个就总结学生平时最常用的冒泡排序吧。 1. 基本思想 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越...
各类排序算法源代码
11-16
各类排序算法的总结 // 排序.cpp : 定义控制台应用程序的入口点。 // #include "stdio.h" #include "math.h" #include "tchar.h" #define MAX_OF_ARRAY 10 int iTemp = 0; int iTimes = 0; ////////...
各类排序算法java的实现
10-20
代码实现如下： ```java public class InsertSort implements SortUtil.Sort{ public void sort(int[] data) { for(int i = 1; i ; i++) { for(int j = i; (j > 0) && (data[j] [j - 1]); j--) { SortUtil.swap...
模块拖拽排序
01-25
其中，拖拽排序作为一种直观且高效的交互方式，被广泛应用于各类Web应用中，特别是对于需要对列表或模块进行重新排序的场景。本文将基于提供的代码片段，深入探讨如何利用JavaScript插件实现页面模块的拖拽排序功能...
yolo-fastest.zip
07-28
yolo-fastest
mysql安装配置教程.pdf
最新发布
07-28
MySQL的安装配置教程可以细分为以下几个步骤，这里以Windows系统为例进行说明： 一、下载MySQL 1.访问MySQL官网： 1.前往MySQL的官方网站（https://www.mysql.com/）下载MySQL Community Server。 2.选择下载版本： 1.在官网的Downloads页面，选择“MySQL Community (GPL) Downloads”下的“MySQL Installer for Windows”。 2.跳过注册步骤，直接下载MySQL安装包。 二、安装MySQL 1.运行安装包： 1.找到下载好的MySQL安装包文件，双击运行。 2.选择安装类型： 1.在安装向导中，选择安装类型（通常建议选择“Custom”进行自定义安装）。 2.选择操作系统的位数（如64位），并勾选“Enable the Select Features...”等选项（如果提示缺少运行库，需要先安装相应的VC_redist）。 3.设置安装路径： 1.选择MySQL的安装路径和数据存储路径，建议将MySQL安装在非系统盘（如D盘）以避免潜在的问题。 4.设置密码：
基于transformers+pytorch实现非结构化商业文本信息中隐私信息识别python源码（比赛获奖项目）.zip
07-28
基于transformers+pytorch实现非结构化商业文本信息中隐私信息识别python源码（比赛获奖项目）.zip CCF大数据与计算智能大赛-非结构化商业文本信息中隐私信息识别方案 bert base + flat + crf + fgm + swa + pu learning策略 + clue数据集 = test1单模0.906 词向量：https://github.com/Embedding/Chinese-Word-Vectors SGNS(Mixed-large 综合) loss mask相关代码为pu learning策略的实现 主要模块版本 python 3.6.9 torch 1.1.0 transformers 3.0.2 pytorchcrf 1.2.0 torchcontrib 0.0.2 主要功能点 使用BERT base作为基础模型 采用flat结构进行命名实体识别 使用CRF层进行序列标注 采用对抗训练(FGM)和平滑权重平均(SWA)策略提高模型泛化能力 使用PU learning策略处理标注不全的数据 利用clue数据集进行训练
（verilog）基于MIPS指令集的单周期CPU设计
07-28
相关代码及Vivado项目工程文件
基于优化随机森林的对地攻击无人机自主作战效能评估_邵明军 - 副本.pdf
07-28
基于优化随机森林的对地攻击无人机自主作战效能评估_邵明军 - 副本
餐饮咖啡西餐厅饮品创业计划书运营策划书.doc
07-28
商业计划书，创业计划书，项目计划书，计划书模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
1_软错误失效对CANFD Transceiver芯片的影响分析.docx
07-28
1_软错误失效对CANFD Transceiver芯片的影响分析.docx
详解各类排序算法：性能第一，全面解析与优化
总结起来，这篇资源提供了丰富的排序算法详解，包括算法原理、实现方法、时间复杂度分析以及优化策略，对于学习和理解排序算法有很高的参考价值，适合对编程尤其是C/C++语言中的排序算法有一定基础的学习者深入研究...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值