java实现冒泡排序、选择排序、二分法查找

🧁 本文介绍了利用Java实现两种排序和一种查询
🍔 分别介绍了冒泡排序、选择排序、二分法查找
🌭 文中还包括方便理解的相关例子

---

---

📙冒泡排序

🧀 冒泡排序通过两层循环控制：内循环是两两比较交换，外循环是执行的趟数
🥟 平均时间复杂度为O(n^2)、最佳时间复杂度为O(n)
🍠 排序算法是稳定的

class Test
{
	public static void main(String[] args){
		int[] array = {4,16,3,22,1,8};
		int temp;
		//冒泡排序
		for(int i = 0; i < array.length; i++){
			for(int j = 0; j < array.length - i - 1; j++){
				if(array[j] > array[j + 1]){
					temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
		}
		for(int i = 0; i < array.length; i++){
			System.out.println(array[i]);
		}
	}
}

📙选择排序

🥨 选择排序的思想：每趟遍历未排序所有元素，找到最大值，将其与数组最后一个元素交换
🥩 平均时间复杂度O(n^2) 最佳时间复杂度和平均时间复杂度相同
🥚 排序算法是不稳定的

class Test
{
	public static void main(String[] args){
		int[] array = {4,16,3,22,1,8};
		int max;
		int point;
		//选择排序
		for(int i = 0; i < array.length; i++){
			point = 0;
			max = array[0];
			for(int j = 0; j < array.length - i; j++){
				if(array[j] > max){
					max = array[j];
					point = j;
				}
			}
			array[point] = array[array.length - i - 1];
			array[array.length - i - 1] = max;     
		}
		for(int i = 0; i < array.length; i++){
			System.out.println(array[i]);
		}
	}
}

max是为了记录每趟遍历的最大值
point是为了记录最大值所处的数组下标

📙二分法查找

🍿 二分法查找适用于有序的数组、可以先利用排序算法将无序数组排好序
🍤二分法查找的思想：找到数组中间元素，将其与目标对比，如果小于则在中间元素的前部分查找，否则在中间元素的后部分查找
🥗本例子采用的是递归算法实现
🧀查找的时间复杂度：O(log2^n)

class Test
{
	static final int goal = 79;

	public static void main(String[] args){
		int[] array = {4,6,10,47,80};
		int result = Part(array,0,array.length-1);
		if(result != -1){
			System.out.println(result);
		}
		else{
			System.out.println("no found");
		}
	}

	public static int Part(int[] array,int a, int b){
		//计算中间节点
		int middle = (a + b) / 2;
		if(a > b){
			return -1;
		}else{
			if(array[middle] > goal){
				middle = Part(array, a , middle - 1);
			}
			else if(array[middle] < goal){
				middle = Part(array, middle + 1, b);	
			}
		}
		return middle;
	}
}

🥘 递归算法的出口：当查找序列的首指针大于尾指针时返回错误(未找到)，否则返回值
🍱 算法过程：Part函数作为查找函数，接受的参数为(查找数组、查找序列首指针、查找序列尾指针)，首先计算中间节点，如果中间节点大于查找目标，则利用分治法处理前面部分子序列，否则处理面部分子序列。