2021-09-01千峰学习day08 排序

冒泡排序（Bubble Sort）

• 图片演示：

• 描述：

• 比较相邻两个数字的大小，如果前者比后者大，将两者进行交换

• 从头至尾对每一对相邻元素进行同样的操作，从开头第一对到结尾的最后一对，这样操作就能把最大数放在最右边

• 代码实现：

package com.zcs.lession08.paixu;
/**
 * 冒泡排序
 * */
public class MaoPaoDemo {
	public static void main(String[] args) {
		int[] a = { 65, 99, 86, 32, 75 };
		
		//冒泡排序口诀
		//外层循环n-1
		for (int i = 0; i < a.length-1; i++) {
			//内层循环n-1-i
			for (int j = 0; j < a.length-1-i; j++) {
				//当前值和后一个值进行比较
				if(a[j+1]<a[j]) {
					//当前值比后一个值大,二个值进行交换
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1]=temp;
				}
			}
		}
		//循环遍历输出
		for (int i : a) {
			System.out.print(i+"\t");
		}
	}
}

• 核心代码分析：

通过图片演示可知：

一共进行了四轮比较：

• 第一轮 4次
• 第二轮 3次
• 第三轮 2次
• 第四轮 1次

// 外层循环控制比较的轮次i
for (int i = 0; i < a.length-1; i++) {
			//内层循环控制每一轮比较的次数每一轮都会比较出一个较大值		
			for (int j = 0; j < a.length-1-i; j++) {
                // 后面的数小于前面的数就进行交换
				if(a[j+1]<a[j]) {
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1]=temp;
				}
			}
		}

外层循环 a.length-1：控制外层比较的轮次 可以为length就会多比一轮 效率更低

内层循环 a.length-1-i：控制内层比较的次数

选择排序（Selection Sort）

图片演示:

描述

首先从未排序的数组中找到最小的元素存放在排序数组的起始位置，任何再从未排完序的元素寻找次小元素放在已排序的数组的末尾，依次类推

代码实现

package com.zcs.lession08.paixu;
/**
 * 选择排序
 * */
public class XuanZeDemo {
	public static void main(String[] args) {
		int[] a = { 65, 99, 86, 32, 75 };
		// 选择排序
		// 外层循环-1
		for (int i = 0; i < a.length - 1; i++) {
			// 每次使用i的下标作为比较的基准值,和他后一个值开始比较
			// 所以j就从i+1开始循环,为了不超出数组下标,内层循环不需要-1
			int min = i;//定义一个找到最小数的小标
			for (int j = i + 1; j < a.length; j++) {
				// 判断找到最小的数		内层循环找到最小数
				if (a[j] < a[min]) {
					min = j;
				}
			}
			//如果最小数的下标不为定义的下标则交换
			if (min != i) {
				exchange(a, min, i);
			}
		}
		for (int i : a) {
			System.out.print(i + "\t");
		}

	}
	//交换方法
	public static void exchange(int[] num, int a, int b) {
		int temp = num[a];
		num[a] = num[b];
		num[b] = temp;
	}
}

核心代码分析

通过图片演示可知：

一共进行了四轮比较：

• 第一轮 4次
• 第二轮 3次
• 第三轮 2次
• 第四轮 1次

	for (int i = 0; i < a.length - 1; i++) {
			// 每次使用i的下标作为比较的基准值,和他后一个值开始比较
			// 所以j就从i+1开始循环,为了不超出数组下标,内层循环不需要-1
			int min = i;//定义一个找到最小数的小标
			for (int j = i + 1; j < a.length; j++) {
				// 判断找到最小的数		内层循环找到最小数
				if (a[j] < a[min]) {
					min = j;
				}
			}
			//如果最小数的下标不为定义的下标则交换
			if (min != i) {
				exchange(a, min, i);
			}
		}
		for (int i : a) {
			System.out.print(i + "\t");
		}

	}
public static void exchange(int[] num, int a, int b) {
		int temp = num[a];
		num[a] = num[b];
		num[b] = temp;
	}
}

exchange()静态方法在循环中调用每一次外层循环寻找到的最小值通过静态方法放到已排序的数组

外层循环 a.length-1 因为轮次是按i的下标作为基准 四轮

内层循环 a.length 因为j从i+1开始循环，为了不超出下标所以不需要-1操作

在外层循环内定义了一个最小数的下标

内层循环遍历所以数 将最小数的小标取 在外层循环进行比较

如果内层循环与外层循环定义的最小数不一致就进行值的交换