Java-冒泡排序、插入排序、简单选择排序

冒泡排序

	public static void main(String[] args) {
		
	}
	/**
	 * 冒泡排序
	 * 比较相邻的元素，如果第一个比第二个大，就交换他们两个，把大的数沉下去，小数冒上来
	 * 依次比较直到完成
	 */
	public static void bullesort() {
		int[] array = {121, 8, 72, 95, 8, 71, 9, 28, 17, 42, 38, 46, 120};
		System.out.println(Arrays.toString(array));
		int temp;
		int count = 0;
		// 控制排序的轮数，排序次数是 array.length - 1
		for (int i = 0; i < array.length - 1; i++) {
			// 控制排序每轮的比较次数，每轮的比较次数是 array.length - i - 1
			for (int j = 0; j < array.length - i - 1; 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));
	}

增强版冒泡排序

	/**
	 *  增强版冒泡排序
	 *  比较相邻的元素。如果第一个比第二个大，就交换他们两个，把大的数沉下去，小数冒上来
	 *  增强条件flag，如果内层循环不发生交换（flag = ture）说明排序已将完成不用再进行排序
	 */
	public static void bullesortHigh() {
		int[] array = {121, 8, 72, 95, 8, 71, 9, 28, 17, 42, 38, 46, 120};
		System.out.println(Arrays.toString(array));
		int temp;
		int count = 0;
		// 判断数组是否排序成功，如果不进行交换就已将排序完成
		boolean flag;  
		// 控制排序的轮数，排序次数是 array.length - 1
		for (int i = 0; i < array.length - 1; i++) {
			// 默认 已将排序完成，定义在这里
			flag = true; 
			// 控制排序每轮的比较次数，每轮的比较次数是 array.length - i - 1
			for (int j = 0; j < array.length - i - 1; j++) {
				// 如果前一个数比后一个数大，就把它沉底，也就是交换给索引大的数
				if (array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
					// 如果发生了交换说明
					flag = false;
				}
			}
			if (flag) {
				break;
			}
		}
		System.out.println(Arrays.toString(array));
	}

插入排序

	/*
	插入排序
		
    （1）原理：

　　1、将指针指向某个元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止；

       2、此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大；

　　3、指针向后移动一位，重复上述过程。每操作一轮，左侧有序元素都增加一个，右侧无序元素都减少一个。

    （2）例子：
　　待比较数据：7, 6, 9, 8, 5,1

　　第一轮：指针指向第二个元素6，假设6左面的元素为有序的，将6抽离出来，形成7,_,9,8,5,1，从7开始，6和7比较，发现7>6。将7右移，形成_,7,9,8,5,1，6插入到7前面的空位，结果：6,7,9,8,5,1

　　第二轮：指针指向第三个元素9，此时其左面的元素6,7为有序的，将9抽离出来，形成6,7,_,8,5,1，从7开始，依次与9比较，发现9左侧的元素都比9小，于是无需移动，把9放到空位中，结果仍为：6,7,9,8,5,1

　　第三轮：指针指向第四个元素8，此时其左面的元素6,7,9为有序的，将8抽离出来，形成6,7,9,_,5,1，从9开始，依次与8比较，发现8<9，将9向后移，形成6,7,_,9,5,1，8插入到空位中，结果为：6,7,8,9,5,1

　　第四轮：指针指向第五个元素5，此时其左面的元素6,7,8,9为有序的，将5抽离出来，形成6,7,8,9,_,1，从9开始依次与5比较，发现5比其左侧所有元素都小，5左侧元素全部向右移动，形成_,6,7,8,9,1，将5放入空位，结果5,6,7,8,9,1。
　　
	第五轮：同上，1被移到最左面，最后结果：1,5,6,7,8,9。
	 */
	/**
	 *  插入排序实思想，从第二个数开始提取出来，和它前面的数进行比较，
	 *  如果小于前一个数就把前一个向后移一个位置，直到不小于它前面数为止，
	 *  在对应的位置插入提取值
	 */
	public static void insertSort() {
		int[] array = {121, 8, 72, 95, 8, 71, 9, 28, 17, 42, 38, 46, 120};
		System.out.println(Arrays.toString(array));
		// 存储插入值
		int insertValue;
		
		// i 表示 将要插入数据的索引
		// 从第二个数开始，依次与前一个数进行比较，如果小于前一个数，就把前一个数的值赋值给当前数（相当于后移）
		for (int i = 1; i < array.length; i++) {
			
			// 提取将要插入数据
			insertValue = array[i];
			// j 用来存储需要后移数据的下标
			int j;
			// 如果 j索引所在值 大于 标记值，就把 array[j] 后移一位
			for (j = i - 1; j >= 0 && array[j] > insertValue; j--) {
				array[j+1] = array[j];
			}
			// 循环结束后，j+1所在位置就是插入位置
			array[j+1] = insertValue;
		}
		System.out.println(Arrays.toString(array));
	}

简单选择排序

	/**
	 * 简单选择排序
	 * 从数组中找到最小的值，放在第一位，从剩下的数再找到最小值放到第二位，依次类推
	 */
	public static void easySelectSortHigh() {
		int[] array = {121, 8, 72, 95, 8, 71, 9, 28, 17, 42, 38, 46, 120};
		System.out.println(Arrays.toString(array));
		// 存储最小值的索引
		int minIndex;
		// 第一个位置开始
		for (int i = 0; i < array.length; i++) {
			// 
			minIndex = i;
			// 从第 i+1 个位置开始比较
			for (int j = i + 1; j < array.length; j++) {
				// 如果 minIndex 所在值 大于 j 所在值，说明 j 位置的值比 minIndex 小
				// 就把 j 的位置 赋值给 minIndex
				// 当遍历完 j ~~ array.length 数组就找到最小值所在下标
				if (array[minIndex] > array[j]) {
					minIndex = j;
				}
			}
			// 把最小值与第 i 个位置的值 进行交换
			int temp = array[i];
			array[i] = array[minIndex];
			array[minIndex] = temp;
		}
		System.out.println(Arrays.toString(array));
	}

插入排序参考：https://www.cnblogs.com/bjh1117/p/8335628.html