Java基础之排序算法

冒泡排序是一种稳定的排序方法

package Stringlei;
/*
*@author Shishuai E-mail：1198319583@qq.com
*@version Create time ： 2019年4月1日下午4:09:04
*类说明：冒泡排序算法
冒泡排序算法的运作如下：（从后往前）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

*/
public class Paixu {
	public static void main(String[] args) {
		int[] nums = {34, 4, 56, 17, 90, 65};
		//外循环控制轮数
		//比较轮数等于数列的长度
		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]) {
					nums[j] = nums[j] + nums[j + 1];
					nums[j + 1] = nums[j] - nums[j + 1];
					nums[j] = nums[j] - nums[j + 1];
				}
			}
		}
		for(int n : nums) {
			System.out.println(n);
		}
	}
}
/*34 4 56 17 90 65
 *                         //比较次数
 *4 34 17 56 65 90  //第一轮 5次
 *4 17 34 56 65     //第二轮 4次
 *4 17 34 56        //第三轮 3次
 *4 17 34           //第四轮 2次
 *4 17              //第五轮 1次
 *
 * */
 

选择排序算法 是不稳定的排序方法。

package Stringlei;
/*
*@author Shishuai E-mail：1198319583@qq.com
*@version Create time ： 2019年4月1日下午4:09:04
*类说明：选择排序算法
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
 选择排序是不稳定的排序方法。


*/
public class Paixu {
	public static void main(String[] args) {
		int[] nums = {34, 4, 56, 17, 90, 65};
		int minIndex = 0;//用于记录每次比较的最小值下标
		//控制轮数
		for(int i = 0; i < nums.length - 1; i++) {
			minIndex = i;//每轮假设一个最小值下标
			for(int j = i + 1; j < nums.length; j++) {
				if(nums[minIndex] > nums[j]) {//如果最小下标大于这个值 
					minIndex = j;//就交换下标
				}
			}
			//判断需要交换的数下标是否为自己
			if(minIndex != i) {
				nums[minIndex] = nums[minIndex] + nums[i];
				nums[i] = nums[minIndex] - nums[i];
				nums[minIndex] = nums[minIndex] - nums[i];
			}
		}
		//输出结果
		for(int n : nums) {
			System.out.println(n);
		}
	}
}
/*34 4 56 17 90 65
 *
 *4 34 56 17 90 65 第一轮 比较5次
 *4 17 56 34 90 65 第二轮 比较4次
 *4 17 34 56 90 65 第三轮 比较3次
 *4 17 34 56 90 65 第四轮 比较2次
 *4 17 34 56 65 90 第五轮 比较1次
 * 
 *
 * */
 

直接插入排序算法

（从后向前找到合适位置后插入）

基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的子序列的合适位置（从后向前找到
合适位置后），直到全部插入排序完为止。

package Stringlei;
/*
*@author Shishuai E-mail：1198319583@qq.com
*@version Create time ： 2019年4月1日下午4:09:04
*类说明：直接插入排序算法
（从后向前找到合适位置后插入）
基本思想：每步将一个待排序的记录，
按其顺序码大小插入到前面已经排序的子序列的合适位置(前边的肯定是排好的)
（从后向前找到合适位置后），直到全部插入排序完为止。


*/
public class Paixu {
	public static void main(String[] args) {
		int[] nums = {34, 4, 56, 17, 90, 65};
		//控制比较的轮数
		for(int i = 1; i < nums.length; i++) {
			int temp = nums[i]; //记录操作数
			int j = 0;
			for(j = i - 1; j >= 0; j--) {
				if(nums[j] > temp) {
					nums[j + 1] = nums[j];
				}else {
					break;
				}
			}
			if(nums[j + 1] != temp) {
				nums[j + 1] = temp;
			}
		}
		//输出结果
		for(int n : nums) {
			System.out.println(n);
		}
	}
}
/*34 4 56 17 90 65
 *
 *
 * */
 

二分法查找（折半查找）：
*前提是在已经排好序的数组中，
*通过将待查找的元素与中间索引值对应的元素进行比较，
*若大于中间索引值对应的元素，
*去右半部分查找，否则，去左半部分查找。
*依此类推。直到找到为止；找不到返回一个负数。

package Stringlei;
/*
*@author Shishuai E-mail：1198319583@qq.com
*@version Create time ： 2019年4月1日下午4:09:04
*类说明：二分法查找（折半查找）：
*前提是在已经排好序的数组中，
*通过将待查找的元素与中间索引值对应的元素进行比较，
*若大于中间索引值对应的元素，
*去右半部分查找，否则，去左半部分查找。
*依此类推。直到找到为止；找不到返回一个负数。



*/
public class Paixu {//折半查找
	public static void main(String[] args) {
		
		//必须保证数列是有序的
		int[] num = {10, 20, 50, 65, 88, 90};
		
		int index = binarySearch(num, 88);
		System.out.println(index);
		
	}
	//二分查找算法
	public static int binarySearch(int[] num, int key) {
		int start = 0;//开始下标
		int end = num.length - 1;//结束下标
		
		while(start <= end) {
			int middle = (start + end)/2; //除2 或者无符号右移1位 >>> 1
			if(num[middle] > key) {
				end = middle - 1;
			}else if(num[middle] < key){
				start = middle + 1;
			}else {
				return middle;
			}
		}
		return -1;
	}
	
}