Java小白入门200例67之选择排序

Posted 2021-10-14 编程界明世隐

作者简介

作者名：编程界明世隐
简介：CSDN博客专家，从事软件开发多年，精通Java、javascript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！

引言

很多Java初学者问我，新手明明很用心、很努力学习的Java知识，转头又忘记了，很让人犯愁，小白如何能够快速成长、成为大牛呢？
其实要成为大神的技巧只有一个：“多学多练”，于是明哥就整理了比较典型的练习实例，通过练习能够快速提升编码技巧和熟练度，让你在成为大佬的路上一去不复返（切记要亲手练习哦）！

导航

✪ Java小白入门200例系列目录索引
◄上一篇  66.快速排序
►下一篇  68.创建一个学生类（Student）

什么是选择排序

它与冒泡排序不同。选择排序是指每一趟从待排序的数据元素中选出最大（或最小）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
冒泡：每次冒泡都可能存在多次交换。
选择：每次只需交换最多一次。

需求

排序前数组：{3,11,100,99,37,85}
排序后数组：{3,11,37,85,99,100}

排序第一次

将数组中的最大值100，移动到最后。

package demo.demo67;

public class SelectSort1 {

	public static void main(String[] args) {
		int[] arr = {3,11,100,99,37,85}; 
		 // 对arr数组进行循环遍历
		System.out.println("排序前的数组内容如下：");
	    for (int i = 0; i < arr.length; i++) {
	        System.out.print(arr[i] + "\\t");
	    }
	    System.out.println("\\n第一次排序后的数组内容如下：");
	    // 对数组进行排序
	    selectSort1(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	}
	
	private static void selectSort1(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//循环数组，从1开始
		for (int i = 1; i < arrays.length; i++) {
			//取到最大值，根据下标
			max = arrays[maxIndex];
			//max开始取到的是第一个元素，因为maxIndex默认0
			if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
				maxIndex=i;
			}
		}
		
		//把max放到最后
		max = arrays[maxIndex];
		arrays[maxIndex] = arrays[arrays.length-1];
		arrays[arrays.length-1] = max;
		
	}
}

运行结果：

排序前的数组内容如下：
3 11 100 99 37 85
第一次排序后的数组内容如下：
3 11 85 99 37 100

第二次排序

将99排到100的前面

package demo.demo67;

public class SelectSort2 {

	public static void main(String[] args) {
		int[] arr = {3,11,100,99,37,85}; 
		 // 对arr数组进行循环遍历
		System.out.println("排序前的数组内容如下：");
	    for (int i = 0; i < arr.length; i++) {
	        System.out.print(arr[i] + "\\t");
	    }
	    System.out.println("\\n第一次排序后的数组内容如下：");
	    // 对数组进行排序
	    selectSort1(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	    
	    System.out.println("\\n第二次排序后的数组内容如下：");
	    selectSort2(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	}
	
	private static void selectSort1(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//循环数组，从1开始
		for (int i = 1; i < arrays.length; i++) {
			//取到最大值，根据下标
			max = arrays[maxIndex];
			//max开始取到的是第一个元素，因为maxIndex默认0
			if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
				maxIndex=i;
			}
		}
		
		//把max放到最后
		arrays[maxIndex] = arrays[arrays.length-1];
		arrays[arrays.length-1] = max;
	}
	
	private static void selectSort2(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//循环数组，从1开始
		for (int i = 1; i < arrays.length-1; i++) {
			//取到最大值，根据下标
			max = arrays[maxIndex];
			//max开始取到的是第一个元素，因为maxIndex默认0
			if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
				maxIndex=i;
			}
		}
		
		//把max放到最后
		max = arrays[maxIndex];
		arrays[maxIndex] = arrays[arrays.length-2];
		arrays[arrays.length-2] = max;
	}
}

运行结果:

排序前的数组内容如下：
3 11 100 99 37 85
第一次排序后的数组内容如下：
3 11 85 99 37 100
第二次排序后的数组内容如下：
3 11 85 37 99 100

第n次排序

因代码类似，就一次加上去

package demo.demo67;

public class SelectSort3 {

	public static void main(String[] args) {
		int[] arr = {3,11,100,99,37,85}; 
		 // 对arr数组进行循环遍历
		System.out.println("排序前的数组内容如下：");
	    for (int i = 0; i < arr.length; i++) {
	        System.out.print(arr[i] + "\\t");
	    }
	    System.out.println("\\n第一次排序后的数组内容如下：");
	    // 对数组进行排序
	    selectSort1(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	    
	    System.out.println("\\n第二次排序后的数组内容如下：");
	    selectSort2(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	    
	    System.out.println("\\n第三次排序后的数组内容如下：");
	    selectSort3(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	    
	    
	    System.out.println("\\n第四次排序后的数组内容如下：");
	    selectSort4(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	    
	    System.out.println("\\n第五次排序后的数组内容如下：");
	    selectSort5(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	}
	
	private static void selectSort1(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//循环数组，从1开始
		for (int i = 1; i < arrays.length; i++) {
			//取到最大值，根据下标
			max = arrays[maxIndex];
			//max开始取到的是第一个元素，因为maxIndex默认0
			if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
				maxIndex=i;
			}
		}
		
		//把max放到最后
		max = arrays[maxIndex];
		arrays[maxIndex] = arrays[arrays.length-1];
		arrays[arrays.length-1] = max;
	}
	
	private static void selectSort2(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//循环数组，从1开始
		for (int i = 1; i < arrays.length-1; i++) {
			//取到最大值，根据下标
			max = arrays[maxIndex];
			//max开始取到的是第一个元素，因为maxIndex默认0
			if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
				maxIndex=i;
			}
		}
		
		//把max放到最后
		max = arrays[maxIndex];
		arrays[maxIndex] = arrays[arrays.length-2];
		arrays[arrays.length-2] = max;
	}
	
	private static void selectSort3(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//循环数组，从1开始
		for (int i = 1; i < arrays.length-2; i++) {
			//取到最大值，根据下标
			max = arrays[maxIndex];
			//max开始取到的是第一个元素，因为maxIndex默认0
			if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
				maxIndex=i;
			}
		}
		
		//把max放到最后
		max = arrays[maxIndex];
		arrays[maxIndex] = arrays[arrays.length-3];
		arrays[arrays.length-3] = max;
	}
	
	private static void selectSort4(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//循环数组，从1开始
		for (int i = 1; i < arrays.length-3; i++) {
			//取到最大值，根据下标
			max = arrays[maxIndex];
			//max开始取到的是第一个元素，因为maxIndex默认0
			if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
				maxIndex=i;
			}
		}
		
		//把max放到最后
		max = arrays[maxIndex];
		arrays[maxIndex] = arrays[arrays.length-4];
		arrays[arrays.length-4] = max;
	}
	
	private static void selectSort5(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//循环数组，从1开始
		for (int i = 1; i < arrays.length-4; i++) {
			//取到最大值，根据下标
			max = arrays[maxIndex];
			//max开始取到的是第一个元素，因为maxIndex默认0
			if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
				maxIndex=i;
			}
		}
		
		//把max放到最后
		max = arrays[maxIndex];
		arrays[maxIndex] = arrays[arrays.length-5];
		arrays[arrays.length-5] = max;
	}
}

运行结果：

排序前的数组内容如下：
3 11 100 99 37 85
第一次排序后的数组内容如下：
3 11 85 99 37 100
第二次排序后的数组内容如下：
3 11 85 37 99 100
第三次排序后的数组内容如下：
3 11 37 85 99 100
第四次排序后的数组内容如下：
3 11 37 85 99 100
第五次排序后的数组内容如下：
3 11 37 85 99 100

分析

虽然代码已经实现了排序，但显然这不是我们想要的代码，需要优化。
1.上例中，排序多次，显然可以用循环的方式。
2.每次排序的代码都是差不多的，就是里面的下标有所区别。

最终代码

package demo.demo67;

public class SelectSort {

	public static void main(String[] args) {
		int[] arr = {3,11,100,99,37,85}; 
		 // 对arr数组进行循环遍历
		System.out.println("排序前的数组内容如下：");
	    for (int i = 0; i < arr.length; i++) {
	        System.out.print(arr[i] + "\\t");
	    }
	    System.out.println("\\n排序后的数组内容如下：");
	    // 对数组进行排序
	    selectSort(arr);
	    // 遍历排序后的数组
	    for (int j = 0; j < arr.length; j++) {
	        System.out.print(arr[j] + "\\t");
	    }
	}
	
	private static void selectSort(int[] arrays){
		//数组中最大元素的下标，默认0
		int maxIndex=0;
		int max=0;
		//这里需要循环比数组总长度少一次
		for (int j = 0; j < arrays.length-2; j++) {
			//循环数组，从1开始，i < arrays.length-j 注意这里
			for (int i = 1; i < arrays.length-j; i++) {
				//取到最大值，根据下标
				max = arrays[maxIndex];
				//max开始取到的是第一个元素，因为maxIndex默认0
				if(max<arrays[i]){//如果元素比max大，则给maxIndex设置新下标
					maxIndex=i;
				}
			}
			
			//把max放到最后
			max = arrays[maxIndex];
			//arrays.length-j-1 注意这个
			arrays[maxIndex] = arrays[arrays.length-j-1];
			arrays[arrays.length-j-1] = max;
		}
	}
}

运行结果：

排序前的数组内容如下：
3 11 100 99 37 85
排序后的数组内容如下：
3 11 37 85 99 100

需要注意的几个地方：

	都在selectSort方法中：

1. for (int j = 0; j < arrays.length-2; j++) {
   第一个循环这里需要循环比数组总长度少一次。
2. for (int i = 1; i < arrays.length-j; i++) {
   第二个循环这里的长度每次循环会减少，因为每次循环后最大的已经交换的后面了。
3. arrays[maxIndex] = arrays[arrays.length-j-1];
   arrays[arrays.length-j-1] = max;

交换的时候要注意下标值的更换

小结

这节总结了“选择排序”，希望能对大家有所帮助，请各位小伙伴帮忙 【点赞】+【收藏】+ 【评论区打卡】， 如果有兴趣跟小明哥一起学习Java的，【关注一波】不迷路哦。

评论区打卡一波让我知道你，明哥会持续关注你的学习进度哦！

导航

✪ Java小白入门200例系列目录索引
◄上一篇  66.快速排序
►下一篇  68.创建一个学生类（Student）

热门专栏推荐

1.Java小游戏系列（俄罗斯方块、飞机大战、植物大战僵尸等）
2.JavaWeb项目实战（图书管理、在线考试、宿舍管理系统等）
3.JavaScript精彩实例（飞机大战、扫雷、贪吃蛇、验证码等）
4.Java小白入门200例
Java小白入门200例66之快速排序

Java小白入门200例65之Java sort()数组排序

Java小白入门200例111之Collections类操作集合详解

Java小白入门200例115之Java模拟斗地主发牌

Java小白入门200例98之Java异常

Java小白入门200例95之Java匿名类