算法初探——排序和查找-CSDN博客

本文链接：https://blog.csdn.net/m0_53283585/article/details/118824179

排序算法

冒泡排序——大数上浮法

冒泡排序大数上浮法，比如我们要从小到大排序，我们就从前两个元素的比较开始，如果前一个元素比后一个元素大我们就交换他们的位置，然后再让这个最大的数和第三个数比较，以此类推。
因为每次都是两两比较的，所以n个数比出一个最大值需要循环一次比较n-1次，全部排好则需要n-1次循环，所以我们再一个循环里再套用一个循环就可以了。
下面看代码吧：

public class Test01 {

	public static void main(String[] args) {
		int[] arr = {95,88,93,77,64,54,99,73,85,60};
		
 		bubbleSort01(arr);
		
		for (int i : arr) {
			System.out.print(i+",");
		}
	}
	// 冒泡排序，大数上浮法
	public static void bubbleSort01(int[] arr) {
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j]>arr[j+1]) {
					swap(arr , j, j+1);
				}
			}
		}
}

冒泡排序——小数下沉法

与大数上浮法相反小数下沉法则是每一次循环比较出一个最小的值，原理都差不多，我们来看代码吧。

public class Test01 {

	public static void main(String[] args) {
		int[] arr = {95,88,93,77,64,54,99,73,85,60};
		
    	bubbleSort02(arr);
		
		for (int i : arr) {
			System.out.print(i+",");
		}
	}
	//冒泡排序小数下沉法
	public static void bubbleSort02(int[] arr) {
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = arr.length-1; j>0; j--) {
				if (arr[j]<arr[j-1]) {
					swap(arr , j, j-1);
				}
			}
		}
	}
	private static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
	}
}

选择排序

选择排序就是拟定第一个元素就是最小的元素，然后用这个元素和后面的所有的比较，找到最小的一个元素如果这个元素比第一个元素小，就交换他们两个的位置，也是每循环一次确定一个元素的正确位置。
下面看代码吧：

public class Test01 {

	public static void main(String[] args) {
		int[] arr = {95,88,93,77,64,54,99,73,85,60};
		
    	selectSort(arr);
		
		for (int i : arr) {
			System.out.print(i+",");
		}
	}
// 选择排序
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			int min = i;
			for (int j = i; j < arr.length; j++) {
				if (arr[min] > arr[j]) {
					min = j;
				}
			}
			if (min != i) {
				swap(arr, i, min);
			}
		}
	}
	private static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
	}
}

还有一个写法更简单的，就是将min删去直接使用i。

public class Test01 {

	public static void main(String[] args) {
		int[] arr = {95,88,93,77,64,54,99,73,85,60};
		
    	selectSort(arr);
		
		for (int i : arr) {
			System.out.print(i+",");
		}
	}
// 选择排序
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if (arr[i]>arr[j]) {
					swap(arr, i, j);
				}
			}
		}
	}
	private static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
	}
}

插入排序

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。
我们也可以想象我们打扑克牌，我们将第一张牌不动，后面的比第一张小的就放在前面，大的放后面，一次循环确定一张牌的位置。
示例：

public class Test01 {

	public static void main(String[] args) {
		int[] arr = {95,88,93,77,64,54,99,73,85,60};
		
    	insertSort(arr);
		
		for (int i : arr) {
			System.out.print(i+",");
		}
	}
//插入排序
	public static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			for (int j = i;j>0 && arr[j]<arr[j-1]; j--) {
				swap(arr, j, j-1);
			}
		}
	}
	private static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
	}
}

查找算法

线性查找

我们要查找一个元素在有序数组中的位置，最简单的便是线性查找，也就是从第一个位置开始，依次往后查找，这样的方式是可行的我们来看代码。

public class TestSearch {

	public static void main(String[] args) {
		int[] arr = {1,2,5,8,11,16,18,20,23,60,99};		
		int index = linearSearch(arr, 18);
		
		System.out.println(index);
	}

	// 线性查找，可以查询，但是随着数据越来越多效率越低，
	public static int linearSearch(int[] arr, int key) {
		for (int i = 0; i < arr.length; i++) {
			if (key == arr[i]) {
				return i;
			}
		}
		return -1;
	}
}

二分查找

当数据越来越多的时候，我们如果使用线性查找法进行查找效率会非常低，所以我要讲这个二分查找。
二分查找，就是将一个有序的数组从中间值分开，如果目标值大于中间值我们就把大于中间值这部分当作一个新数组在进行同样的方式进行查找。
我们看看代码吧。

public class TestSearch {

	public static void main(String[] args) {
		int[] arr = {1,2,5,8,11,16,18,20,23,60,99};		
		int index = binarySearch(arr, 18);
		
		System.out.println(index);
	}
	public static int binarySearch(int[] arr, int key) {
		int start = 0;
		int end = arr.length - 1;
			while (start <= end) {
			// 注意，需要将中间值的下标重新计算
			int middle = (start + end) / 2;
			if (arr[middle] > key) {
				end = middle - 1;
			} else if (arr[middle] < key) {
				start = middle + 1;
			} else {
				return middle;
			}
		}
		return -1;
	}
}

当然我们还有最简单的一个方法，就是引用Java.util.Arrays;包中的通过 binarySearch 方法对排序好的数组进行二分查找法操作。

import java.util.Arrays;

public class TestSort2 {

	public static void main(String[] args) {
		int[] arr = {1,2,5,8,11,16,18,20,23,60,99};		
		int index = Arrays.binarySearch(arr, 18);
		
		System.out.println(index);
	}

}