冒泡排序、选择排序、直接插入排序、二分法查找

1.冒泡排序

原理

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。 

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

每次比较相邻两数，小的交换到前面，每轮结束后最大的数交换到最后

如这样的一个数组[11,5,80,25,62],可以发现第一轮，比较了4次，第二轮，比较了3次，第三轮，比较了2次，第四轮：比较了1次

这样就可以想到之前使用双重循环结构输出图形，外层循环控制行，内层循环控制列。在这里面是外层循环控制比较轮数，内层循环控制比较次数。

for (int i = 0; i < num.length; i++) {
 for (int j = 1; j < num.length-i; j++) {
    if(num[j]>num[j-1]){
    int temp=num[j];
    num[j]=num[j-1];
    num[j-1]=temp;
    }
 }
}

2.选择排序

原理：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

在这里比完第一轮，找出最小的数之后，就把这个数跟下标为0的数（即数组的第一个数）交换位置，而第二轮开始的时候这个数是不参与比较的，所以可以整一个循环。又因为这个循环是要去跟剩余的所有的数比较的，所以应该用一个双重循环。接下来看比较的次数了

如一个数组 31 25 8 97 26 53 20

第一轮 初始数:31 比较6次 得到数组:8 31 25 97 26 53 20 最小数:8  假设的最小值下标+1

第二轮 初始数:31 比较5次 得到数组:8 20 31 25 97 26 53 最小数:20 假设的最小值下标+1

第三轮 初始数:31 比较4次 得到数组:8 20 25 31 97 26 53 最小数:25 假设的最小值下标+1

第四轮 初始数:31 比较3次 得到数组:8 20 25 26 31 97 53 最小数:26 假设的最小值下标+1

第五轮 初始数:31 比较2次 得到数组:8 20 25 2631 97 53 最小数:31 假设的最小值下标+1

第六轮 初始数:97 比较1次 得到数组:8 20 25 2631 53 97 最小数:53 最后两个数全部确认结束循环

所以代码是：

        int[] nums={31,25,8,97,26,53,20};//待排序的数列
		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.print(n+" ");
		}

选择排序是不稳定的排序方法,如果两个相同的数，前面的数可能会因为一次比较而被换到后面去，这样相同的数字相对的前后顺序就改变了

3.直接插入排序

原理：从后向前找到合适位置后插入

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

同样的，直接插入也是利用一个双重循环

首先要记录一个操作数，这个操作数是和它前面的数相比，如果比它大就把这两个数交换，直到换到前面的数小于这个数的时候结束并开始下一次循环，下标为0的时候前面是没有数据的所以这个循环从下标唯一的时候开始

如：数组 34,4,56,17,90,65 

第一轮: i=1 temp=4  顺序:34 34 56 17 90 65

                                         4 34 56 17 90 65

第二轮   i=2   temp=56  顺序: 4  34 56 17 90 65

第三轮   i=3   temp=17  顺序: 4  34 56 56 90 65
                                               4  34 34 56 90 65
                                               4  17 34 56 90 65

第四轮  i=4   temp=90  顺序   4 17 34 56 90 65

第五轮  i=5   temp =65  顺序  4 17 34 56 90 90
                                               4 17 34 56 65 90

        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.print(n+" ");
		}

4.二分法查找

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

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;
			if(num[middle]>key){
				end = middle-1;//中间的数大于寻找的数，即这个数在寻找的数的右边，所以终止位置-1，继续循环
			}else if(num[middle]<key){
				start=middle+1;//最中间的数小于寻找的数，即这个数在寻找的数的左边，所以把起始位置-1，继续循环
			}else{//如果都不符合就说明找到了，直接输出middle即下标
				return middle;
			}
		}
		return -1;
	}