算法

2.1 线性查找算法(顺序查找算法)
(1)算法流程
   a.使用目标元素与样本数列中的第一个元素起依次进行比较；
   b.若找到与目标元素相等的元素，则表示查找成功；

  c.若目标元素与样本数列中的所有元素都比较完毕也没找到相等的元素，则表示查找失败；

public class TestFind {

	//实现线性查找算法
	//自定义成员方法在参数指定的数组中查找参数指定的元素，并返回对应的下标
	//表示在arr数组中查找参数指定的元素data
	public static int find(int[] arr, int data){
		for(int i = 0; i < arr.length; i++){
			if(data == arr[i]){
				return i; //执行到这里，表示查找成功
			}
		}
		//执行到这里了，证明元素查找失败
		return -1;
	}
	
	
	
	public static void main(String[] args) {
		
		int[] arr = {10, 20, 30, 40, 50};
		int res = TestFind.find(arr, 20);
		
		System.out.println("查找到的元素下标是：" + res); 

}

2.2 二分查找算法(折半查找算法)(1)算法流程 

a.假定样本数列中的元素都是从小到大排列的；  

b.使用目标元素与样本数列中的中间元素比较大小，若相等则表示查找成功；  

c.若目标元素小于中间元素，则去中间元素的左边进行查找，重复步骤b；  

d.若目标元素大于中间元素，则去中间元素的右边进行查找，重复步骤b；

e.若目标元素与所有该比较元素比较完毕后也没有相等的元素，则表示查找失败；

public class TestFind {
	
	//实现二分查找算法
	//arr表示去哪里查找  left代表左边元素下标  right代表右边元素下标 data代表目标元素
	//left = 0  right = 4;
	//left = 0  right = 1;
	//left = 1  right = 1;
	//left = 2  right = 1;
	public static int findBinary(int[] arr, int left, int right, int data){
		//该数组中至少有1个元素的时候才需要查找  
		if(left <= right){
			//1.计算中间元素的下标
			int mid = (left+right) / 2;   //2  0  1
			//2.使用目标元素与中间元素进行比较，若相等则直接返回下标
			if(data == arr[mid]){ //25 == 30 25 == 10 25 == 20
				return mid;
			}
			//3.若目标元素小于中间元素则去左边进行查找，重复上面的过程因此使用递归
			else if(data < arr[mid]){ //25 < 30 25 < 10 25 < 20
				return findBinary(arr, left, mid-1, data);
			}
			//4.若目标元素大于中间元素则去右边进行查找，重复上面的过程因此使用递归
			else{
				return findBinary(arr, mid+1, right, data);
			}
		}
		else{
			return -1;
		}
	}
	
	public static void main(String[] args) {
		
		int[] arr = {10, 20, 30, 40, 50};
		int res = TestFind.findBinary(arr, 0, arr.length-1, 25);
		System.out.println("查找到的元素下标是：" + res); 
	}

}
3.常用的排序算法
3.1 冒泡排序算法
(1)算法流程  
   a.比较相邻位置的两个元素，若第一个元素比较大则交换两个元素的位置；
   b.从开始的第一对一直到结尾最后一对，经过这一步最后的元素将是这组元素中的最大值；
   c.重复步骤b持续对越来越少的元素进行两两比较，直到处理完毕所有元素为止；
     (直到任意两个相邻位置的元素都无需发生交换为止) 

public class TestSort {

	//实现冒泡排序算法
	public static void bubble(int[] arr){
		//1.使用外层循环控制比较的轮数
		for(int i = 1; i < arr.length; i++){
			//声明一个变量作为本轮比较过程中是否发生交换的标志
			boolean flag = true;
			//2.使用内层循环控制针对当前轮比较的次数，也就是下标范围
			for(int j = 0; j < arr.length-i; j++){
				//3.若第一个元素比第二个元素大，则交换两个元素的位置
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
					
					//只要发生过两个元素的交换，则修改标志位
					flag = false;
					
				}
			}
			//判断本轮比较的过程中是否发生过交换，若没有则证明排序已经完成
			if(flag){
				break; //剩余的轮数则无需进行
			}
		}
	}
	
	
	public static void main(String[] args) {
		
		int[] arr = {20, 10, 18, 5, 15, 20, 12, 25, 8};
		//调用上述冒泡排序算法的方法进行排序
		TestSort.bubble(arr);
		//打印排序后的结果
		System.out.print("排序后的结果是：");
		for(int i = 0; i < arr.length; i++){
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		
	}

}