JAVA 实现五种基本排序方法的实现以及时间的统计

最新推荐文章于 2022-12-13 16:39:16 发布
最新推荐文章于 2022-12-13 16:39:16 发布
阅读量467 收藏 5
点赞数
文章标签： JAVA 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41539778/article/details/84678454
版权 
package test;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class sort {
	/**
	 *Author:April
	 *Date:2018.12.1
	 *Version:0.1
	 *Description:1、选择排序、冒泡排序、归并排序、快速排序、插入排序的算法原理。
	 *            2.不同排序算法时间效率的经验分析方法，验证理论分析与经验分析的一致性。
	 *
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		func();		
	}
	private static void func() {
		// TODO Auto-generated method stub
		System.out.println("1.选择排序 2.冒泡排序 3.合并排序 4.快速排序  5.插入排序");
		@SuppressWarnings("resource")
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入要选择的字母：");
		
		int num = sc.nextInt();
		//int num  = sc.nextInt();
		switch(num){
		case 1:
			//System.out.println("1");
		    select();
			break;
		case 2:
			bubble();
			break;
		case 3:
			merge();
			break;
		case 4:
			fast();
			break;
		case 5:
			insert();
			break;
		default:
			System.out.println("请输入正确的字母");
				
		}
		
	}
//插入排序
	private static void insert() {
		// TODO Auto-generated method stub
		//数据规模为10时
		double begin = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
		int[] nums = new int[10];  //定义一个一维数组
		  int count=0;
		  while(count<10) {
		   nums[count]=(int)(Math.random()*100);//产生100以内的随机数给nums
		   count++;
		  }
		  //插入排序
		  int insertNote;
		  for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
	            insertNote = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
	            int j = i - 1;
	            while ( j >= 0 && insertNote < nums[j]) {
	            	nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
	                j--;
	            }
	            nums[j + 1] = insertNote;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
	        }
		  System.out.println("数据规模为"+nums.length+"时");//数组长度
		  System.out.println("排序后序列为：");
		  for (int i = 0; i < nums.length; i++) {   //循环并打印出每个数组的数字
		   System.out.print(nums[i]+"\t") ;
		   }
		  double end = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
		  double time = end - begin;// 程序的运行时间		
		  System.out.println("\n排序所花平均时间(ms)："+time / 60*1000 );
		  
//数据规模为100时	  
		  double begin1 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
			int[] nums1 = new int[100];  //定义一个一维数组
			  int count1=0;
			  while(count1<100) {
			   nums1[count1]=(int)(Math.random()*100);//产生100以内的随机数给nums
			   count1++;
			  }
			  //插入排序
			  int insertNote1;
			  for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
		            insertNote1 = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
		            int j = i - 1;
		            while ( j >= 0 && insertNote1 < nums[j]) {
		            	nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
		                j--;
		            }
		            nums[j + 1] = insertNote1;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
		        }
			  System.out.println("数据规模为"+nums1.length+"时");//数组长度
			  System.out.println("排序后序列为：");
			  for (int i = 0; i < nums1.length; i++) {   //循环并打印出每个数组的数字
			   System.out.print(nums1[i]+"\t") ;
			   }
			  double end1 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
			  double time1 = end1 - begin1;// 程序的运行时间		
			  System.out.println("\n排序所花平均时间(ms)："+time1 / 60*1000 );
			  
//数据规模为1000时
			  double begin2 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
				int[] nums2 = new int[1000];  //定义一个一维数组
				  int count2=0;
				  while(count2<1000) {
					  nums2[count2]=(int)(Math.random()*100);//产生100以内的随机数给nums
					  count2++;
				  }
				  //插入排序
				  int insertNote2;
				  for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
			            insertNote2 = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
			            int j = i - 1;
			            while ( j >= 0 && insertNote2 < nums[j]) {
			            	nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
			                j--;
			            }
			            nums[j + 1] = insertNote2;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
			        }
				  System.out.println("数据规模为"+nums2.length+"时");//数组长度
				  System.out.println("排序后序列为：");
				  for (int i = 0; i < nums2.length; i++) {   //循环并打印出每个数组的数字
				   System.out.print(nums2[i]+"\t") ;
				   }
				  double end2 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
				  double time2 = end2 - begin2;// 程序的运行时间		
				  System.out.println("\n排序所花平均时间(ms)："+time2 / 60*1000 );
//数据规模为10000时
				  double begin3 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
					int[] nums3 = new int[10000];  //定义一个一维数组
					  int count3=0;
					  while(count3<10000) {
						  nums3[count3]=(int)(Math.random()*100);//产生100以内的随机数给nums
						  count3++;
					  }
					  //插入排序
					  int insertNote3;
					  for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
				            insertNote3 = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
				            int j = i - 1;
				            while ( j >= 0 && insertNote3 < nums[j]) {
				            	nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
				                j--;
				            }
				            nums[j + 1] = insertNote3;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
				        }
					  System.out.println("数据规模为"+nums3.length+"时");//数组长度
					  System.out.println("排序后序列为：");
					  for (int i = 0; i < nums3.length; i++) {   //循环并打印出每个数组的数字
					   System.out.print(nums3[i]+"\t") ;
					   }
					  double end3 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
					  double time3 = end3 - begin3;// 程序的运行时间		
					  System.out.println("\n排序所花平均时间(ms)："+time3 / 60*1000 );
//数据规模为100000时
					  double begin4 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
						int[] nums4 = new int[100000];  //定义一个一维数组
						  int count4=0;
						  while(count4<100000) {
							  nums4[count4]=(int)(Math.random()*100);//产生100以内的随机数给nums
							  count4++;
						  }
						  //插入排序
						  int insertNote4;
						  for (int i = 1; i < nums.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
					            insertNote4 = nums[i];// 设置数组中的第2个元素为第一次循环要插入的数据
					            int j = i - 1;
					            while ( j >= 0 && insertNote4 < nums[j]) {
					            	nums[j + 1] = nums[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
					                j--;
					            }
					            nums[j + 1] = insertNote4;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
					        }
						  System.out.println("数据规模为"+nums4.length+"时");//数组长度
//						  System.out.println("排序后序列为：");
//						  for (int i = 0; i < nums4.length; i++) {   //循环并打印出每个数组的数字
//						   System.out.print(nums4[i]+"\t") ;
//						   }
						  double end4 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
						  double time4 = end4 - begin4;// 程序的运行时间		
						  System.out.println("\n排序所花平均时间(ms)："+time4 / 60*1000 );
		
		
		
	}
//快速排序
	private static void fast() {
		// TODO Auto-generated method stub
		
	}
//合并排序
	private static void merge() {
		// TODO Auto-generated method stub
		
	}
//冒泡排序
	private static void bubble() {
		// TODO Auto-generated method stub
		//数据规模为10时
		double begin = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
		int[] nums = new int[10];  //定义一个一维数组
		  int count=0;
		  while(count<10) {
		   nums[count]=(int)(Math.random()*100);//产生100以内的随机数给nums
		   count++;
		  }
		  //冒泡排序
		for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
			for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
				if (nums[j] > nums[j + 1]) {
					int temp = nums[j];
					nums[j] = nums[j + 1];
					nums[j + 1] = temp;
				}
			}
		}
		  System.out.println("数据规模为"+nums.length+"时");//数组长度
		  System.out.println("排序后序列为：");
		  for (int i = 0; i < nums.length; i++) {   //循环并打印出每个数组的数字
		   System.out.print(nums[i]+"\t") ;
		   }
		  double end = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
		  double time = end - begin;// 程序的运行时间		
		  System.out.println("\n排序所花平均时间(ms)："+time / 60*1000 );
		  
//数据规模为100时	  
		  double begin1 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
			int[] nums1 = new int[100];  //定义一个一维数组
			  int count1=0;
			  while(count1<100) {
			   nums1[count1]=(int)(Math.random()*100);//产生100以内的随机数给nums
			   count1++;
			  }
			  //冒泡排序
				for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
					for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
						if (nums[j] > nums[j + 1]) {
							int temp = nums[j];
							nums[j] = nums[j + 1];
							nums[j + 1] = temp;
						}
					}
				}
			  System.out.println("数据规模为"+nums1.length+"时");//数组长度
			  System.out.println("排序后序列为：");
			  for (int i = 0; i < nums1.length; i++) {   //循环并打印出每个数组的数字
			   System.out.print(nums1[i]+"\t") ;
			   }
			  double end1 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
			  double time1 = end1 - begin1;// 程序的运行时间		
			  System.out.println("\n排序所花平均时间(ms)："+time1 / 60*1000 );
			  
//数据规模为1000时
			  double begin2 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
				int[] nums2 = new int[1000];  //定义一个一维数组
				  int count2=0;
				  while(count2<1000) {
					  nums2[count2]=(int)(Math.random()*100);//产生100以内的随机数给nums
					  count2++;
				  }
				  //冒泡排序
				  //冒泡排序
					for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
						for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
							if (nums[j] > nums[j + 1]) {
								int temp = nums[j];
								nums[j] = nums[j + 1];
								nums[j + 1] = temp;
							}
						}
					}
				  System.out.println("数据规模为"+nums2.length+"时");//数组长度
				  System.out.println("排序后序列为：");
				  for (int i = 0; i < nums2.length; i++) {   //循环并打印出每个数组的数字
				   System.out.print(nums2[i]+"\t") ;
				   }
				  double end2 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
				  double time2 = end2 - begin2;// 程序的运行时间		
				  System.out.println("\n排序所花平均时间(ms)："+time2 / 60*1000 );
//数据规模为10000时
				  double begin3 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
					int[] nums3 = new int[10000];  //定义一个一维数组
					  int count3=0;
					  while(count3<10000) {
						  nums3[count3]=(int)(Math.random()*100);//产生100以内的随机数给nums
						  count3++;
					  }
					  //冒泡排序
					  //冒泡排序
						for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
							for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
								if (nums[j] > nums[j + 1]) {
									int temp = nums[j];
									nums[j] = nums[j + 1];
									nums[j + 1] = temp;
								}
							}
						}
					  System.out.println("数据规模为"+nums3.length+"时");//数组长度
					  System.out.println("排序后序列为：");
					  for (int i = 0; i < nums3.length; i++) {   //循环并打印出每个数组的数字
					   System.out.print(nums3[i]+"\t") ;
					   }
					  double end3 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
					  double time3 = end3 - begin3;// 程序的运行时间		
					  System.out.println("\n排序所花平均时间(ms)："+time3 / 60*1000 );
//数据规模为100000时
					  double begin4 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
						int[] nums4 = new int[100000];  //定义一个一维数组
						  int count4=0;
						  while(count4<100000) {
							  nums4[count4]=(int)(Math.random()*100);//产生100以内的随机数给nums
							  count4++;
						  }
						  //冒泡排序
						 
							for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
								for (int j = 0; j < nums.length - 1 - i; j++) {// 内层循环控制每一趟排序多少次
									if (nums[j] > nums[j + 1]) {
										int temp = nums[j];  //temp是用于交换时的临时变量
										nums[j] = nums[j + 1];
										nums[j + 1] = temp;
									}
								}
							}
						  System.out.println("数据规模为"+nums4.length+"时");//数组长度
//						  System.out.println("排序后序列为：");
//						  for (int i = 0; i < nums4.length; i++) {   //循环并打印出每个数组的数字
//						   System.out.print(nums4[i]+"\t") ;
//						   }
						  double end4 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
						  double time4 = end4 - begin4;// 程序的运行时间		
						  System.out.println("\n排序所花平均时间(ms)："+time4 / 60*1000 );
		
	}
	
	
//选择排序
	private static void select() {  
		// TODO Auto-generated method stub
		//数据规模为10时
		double begin = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
		int[] nums = new int[10];  //定义一个一维数组
		  int count=0;
		  while(count<10) {
		   nums[count]=(int)(Math.random()*100);//产生100以内的随机数给nums
		   count++;
		  }
		  //选择排序
		  for(int i = 0; i < nums.length-1; ++i){  //外层循环数组寻找最小的数
	            int k = i;
	            for(int j = i; j < nums.length; ++j){  //内层循环，做比较
	                if(nums[k] > nums[j]){  //若j比k小，则把j放入前面的位置
	                    k = j;
	                }
	            }
	            if(k != i){  //交换元素
	                int temp = nums[i];  //temp是用于交换时的临时变量
	                nums[i] = nums[k];
	                nums[k] = temp;
	            }
	        }
		  System.out.println("数据规模为"+nums.length+"时");//数组长度
		  System.out.println("排序后序列为：");
		  for (int i = 0; i < nums.length; i++) {   //循环并打印出每个数组的数字
		   System.out.print(nums[i]+"\t") ;
		   }
		  double end = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
		  double time = end - begin;// 程序的运行时间		
		  System.out.println("\n排序所花平均时间(ms)："+time / 60*1000 );
		  
//数据规模为100时	  
		  double begin1 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
			int[] nums1 = new int[100];  //定义一个一维数组
			  int count1=0;
			  while(count1<100) {
			   nums1[count1]=(int)(Math.random()*100);//产生100以内的随机数给nums
			   count1++;
			  }
			  //选择排序
			  for(int i = 0; i < nums1.length-1; ++i){  //外层循环数组寻找最小的数
		            int k = i;
		            for(int j = i; j < nums1.length; ++j){  //内层循环，做比较
		                if(nums1[k] > nums1[j]){  //若j比k小，则把j放入前面的位置
		                    k = j;
		                }
		            }
		            if(k != i){  //交换元素
		                int temp = nums1[i];  //temp是用于交换时的临时变量
		                nums1[i] = nums1[k];
		                nums1[k] = temp;
		            }
		        }
			  System.out.println("数据规模为"+nums1.length+"时");//数组长度
			  System.out.println("排序后序列为：");
			  for (int i = 0; i < nums1.length; i++) {   //循环并打印出每个数组的数字
			   System.out.print(nums1[i]+"\t") ;
			   }
			  double end1 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
			  double time1 = end1 - begin1;// 程序的运行时间		
			  System.out.println("\n排序所花平均时间(ms)："+time1 / 60*1000 );
			  
//数据规模为1000时
			  double begin2 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
				int[] nums2 = new int[1000];  //定义一个一维数组
				  int count2=0;
				  while(count2<1000) {
					  nums2[count2]=(int)(Math.random()*100);//产生100以内的随机数给nums
					  count2++;
				  }
				  //选择排序
				  for(int i = 0; i < nums2.length-1; ++i){  //外层循环数组寻找最小的数
			            int k = i;
			            for(int j = i; j < nums2.length; ++j){  //内层循环，做比较
			                if(nums2[k] > nums2[j]){  //若j比k小，则把j放入前面的位置
			                    k = j;
			                }
			            }
			            if(k != i){  //交换元素
			                int temp = nums2[i];  //temp是用于交换时的临时变量
			                nums2[i] = nums2[k];
			                nums2[k] = temp;
			            }
			        }
				  System.out.println("数据规模为"+nums2.length+"时");//数组长度
				  System.out.println("排序后序列为：");
				  for (int i = 0; i < nums2.length; i++) {   //循环并打印出每个数组的数字
				   System.out.print(nums2[i]+"\t") ;
				   }
				  double end2 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
				  double time2 = end2 - begin2;// 程序的运行时间		
				  System.out.println("\n排序所花平均时间(ms)："+time2 / 60*1000 );
//数据规模为10000时
				  double begin3 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
					int[] nums3 = new int[10000];  //定义一个一维数组
					  int count3=0;
					  while(count3<10000) {
						  nums3[count3]=(int)(Math.random()*100);//产生100以内的随机数给nums
						  count3++;
					  }
					  //选择排序
					  for(int i = 0; i < nums3.length-1; ++i){  //外层循环数组寻找最小的数
				            int k = i;
				            for(int j = i; j < nums3.length; ++j){  //内层循环，做比较
				                if(nums3[k] > nums3[j]){  //若j比k小，则把j放入前面的位置
				                    k = j;
				                }
				            }
				            if(k != i){  //交换元素
				                int temp = nums3[i];  //temp是用于交换时的临时变量
				                nums3[i] = nums3[k];
				                nums3[k] = temp;
				            }
				        }
					  System.out.println("数据规模为"+nums3.length+"时");//数组长度
					  System.out.println("排序后序列为：");
					  for (int i = 0; i < nums3.length; i++) {   //循环并打印出每个数组的数字
					   System.out.print(nums3[i]+"\t") ;
					   }
					  double end3 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
					  double time3 = end3 - begin3;// 程序的运行时间		
					  System.out.println("\n排序所花平均时间(ms)："+time3 / 60*1000 );
//数据规模为100000时
					  double begin4 = System.currentTimeMillis(); // 程序开始时间，调用系统的当前时间
						int[] nums4 = new int[100000];  //定义一个一维数组
						  int count4=0;
						  while(count4<100000) {
							  nums4[count4]=(int)(Math.random()*100);//产生100以内的随机数给nums
							  count4++;
						  }
						  //选择排序
						  for(int i = 0; i < nums4.length-1; ++i){  //外层循环数组寻找最小的数
					            int k = i;
					            for(int j = i; j < nums4.length; ++j){  //内层循环，做比较
					                if(nums4[k] > nums4[j]){  //若j比k小，则把j放入前面的位置
					                    k = j;
					                }
					            }
					            if(k != i){  //交换元素
					                int temp = nums4[i];  //temp是用于交换时的临时变量
					                nums4[i] = nums4[k];
					                nums4[k] = temp;
					            }
					        }
						  System.out.println("数据规模为"+nums4.length+"时");//数组长度
//						  System.out.println("排序后序列为：");
//						  for (int i = 0; i < nums4.length; i++) {   //循环并打印出每个数组的数字
//						   System.out.print(nums4[i]+"\t") ;
//						   }
						  double end4 = System.currentTimeMillis(); // 程序结束时间，调用系统当前时间
						  double time4 = end4 - begin4;// 程序的运行时间		
						  System.out.println("\n排序所花平均时间(ms)："+time4 / 60*1000 );
 
		
	}


}

 

Wyn_
关注
分别使用插入排序、合并排序、快排对随机生成的若干整数序列进行排序，并统计各种情况下排序所耗费的时间。
xfsgdsgoy的博客
10-08 723
分别使用插入排序、合并排序、快排最随机生成的若干整数序列进行排序，并统计各种情况下排序所耗费的时间。 #include<iostream> using namespace std; #include<ctime> //time()函数 #include<cstdlib>//srand()和rand()函数在此文件中 clock_t start,stop;//...
java 实现计数排序和桶排序实例代码
08-31
以下是两种不同的计数排序实现方式： **第一种实现**： 1. 初始化最大值max和最小值min。 2. 创建大小为max-min+1的help数组。 3. 遍历原数组，更新help数组的计数值。 4. 通过help数组反向填充排序后的数组。 **...
计数排序和桶排序（Java实现）
diaoxie19780718的博客
12-14 180
目录 比较和非比较的区别 计数排序 计数排序适用数据范围 过程分析 桶排序 网络流传桶排序算法勘误 桶排序适用数据范围 过程分析 比较和非比较的区别 常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。 在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，...
Java 统计各个单词的个数并排序
热门推荐
Bad Boy
05-05 1万+
这个比较简单，我用来练练手，觉得好玩，便把代码贴出来，比如说我们统计"hello,my name is Tom,what is your name?he said:\"my name is John\"";这句英语中单词的总数和各个单词的数量并排序输出，运行结果如下： 总共单词数：15 is:3 name:3 my:2 hello:1 said:1 what:1 Tom:1
Java程序员从笨鸟到菜鸟（二）五种基本排序算法实现
u013090299的博客
02-23 320
注：数组排序以从升序排序为例 1.冒泡排序 1.1 算法原理：从左向右比较相邻的元素，如果前面的数比后面的数大，则交换它们的位置，这样每次比较完，靠后的位置的数字都是比前面的数值更大，循环比较到倒数第二位。详细解释见冒泡排序 1.2 算法分析： 时间复杂度：若数组开始为正序，则比较次数Cmin= n-1,移动次数Mmin=0，最好的时间复杂度为O(n)；若数组初始为反序的，则需要进行n-1...
统计各排序算法运行的时间
看，好自为之的博客！！！
03-08 2169
学习内容： 编写 java 程序，随机产生N个数（N>30000），分别使用插入排序、合并排序、冒泡排序对其进行排序，比较各种排序所用的时间。要求统计每个算法的运行时间，输出排序后的前20个数。 源代码： import java.util.Calendar; public class MySort_hw { static int n = 30000; public static void main(String[] args) { int[] A = new
Java实现基数排序.rar
05-27
以下是Java实现基数排序的基本步骤： 1. **确定最大数和位数**：首先，我们需要找出数组中的最大数，以确定需要处理的位数。例如，如果数组中最大数为999，那么需要处理3位。 2. **创建辅助数组**：为了实现排序，...
计数排序算法介绍以及使用Java语言实现
最新发布
07-04
### 计数排序算法介绍及Java实现 #### 一、计数排序算法基本概念 ...以上是计数排序算法的基本介绍及其Java实现。计数排序作为非比较型排序算法，在特定情况下具有很高的效率，是值得了解和掌握的一种排序方法。
Java实现排序的12种方式(3).zip_java排序（3）_八叉树
09-20
本资料主要探讨了Java中实现排序的12种方法，其中包括一些经典的排序算法以及基于集合的排序方式。以下是对这些排序算法的详细介绍： 1. **计数排序**：计数排序是一种非比较型排序算法，适用于整数排序。它通过...
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
Java-五种排序算法实现
NAME_CJF的博客
10-24 320
前言 这篇我们会介绍比较简单的五种排序算法：插入排序、冒泡排序、快速排序、选择排序、归并排序的原理及Java代码实现。 关于实现，我们先定义算法外的方法： 打印数组方法： private static void printNums(int[] nums) { for (int i = 0; i < nums.length; i++) { if ...
桶排序和计数排序的理解实现和比较(Java)
weixin_30698527的博客
04-08 237
比较和非比较的区别 常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。 计数排序、基数排序、桶排序则属于非比较排序，通过确定每个元素之前，应该有多少个元素来排序。针...
Java统计单词(字符串)出现的顺序并且排序
varyall的专栏
09-07 1791
import java.util.*; /** * Created by abin on 2018/9/7. * Java统计单词(字符串)出现的顺序并且排序 */ public class WordCountSort { public static void main(String[] args) { List&lt;String&gt; list = new...
用java实现大数据去重、词频统计、排序
Xn的博客
10-12 2702
概述 前提：数据源不会爆内存 使用HashMap做去重、统计、使用TreeMap做排序 原代码 KeyWordCount.java import util.TimeUtil; import java.io.*; import java.util.*; /** * 搜索关键词去重、统计、降序 */ public class KeyWordCount { static...
java 计数排序——初级版（内含思路，代码，注释）
黄瓜炒鸡蛋的博客
04-30 277
计数排序 排序的方法又很多种，有效率高的，有简单粗暴的，有令人头疼的。但是今天我要讲的这种排序，我觉得是及其简单的，它的思路很简单，却又比冒泡排序要省略很多的时间，他就是——计数排序。 代码思路： 我们在用数组排序的时候，自然会牵扯到数组的坐标。但是与其用各种递归、分治、回溯、多重循环反复倒腾这些坐标里的数字，何不在坐标本身上下点功夫呢？？ 是的，比如我们在排序一个数组的时候，一个数组的数字为10...
计数排序（java）
qq_41044209的博客
12-13 427
无
统计三种排序方法的运行时间差异
weixin_45331522的博客
06-09 408
利用随机函数rand()生成50000个随机整数，分别使用起泡排序、选择排序、qsort排序方法对之排序，统计三种排序方法的运行时间差异 5.2.c #include<stdlib.h> #include<stdio.h> #include<math.h> #include"sort.h" #include<sys/time.h> #include<unistd.h> int main() { struct timeval tv1, tv
java实现计数排序_java 实现计数排序和桶排序实例代码
weixin_39607473的博客
03-02 90
java 实现计数排序和桶排序实例代码发布于 2020-3-13|复制链接摘记: java 实现计数排序和桶排序实例代码目录比较和非比较的区别常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确 ..java 实现计数排序和桶排序实例代码目录比较和非比较的区别常见的快速排序、归并排序、堆排序、冒泡排序...
Java实现桶排序详解：原理与步骤
桶排序是一种非比较型整数排序算法，其基本思想是将待排序的数据分布到多个桶（bucket）中，每个桶内部再使用其他排序算法进行排序。Java语言实现桶排序的关键在于以下几个步骤： 1. **理解桶的概念**： - 当你...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Wyn_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值