Day05 学习java（排序、查找）

排序

所谓排序，就是指让保存的元素按照一定的规则进行排序存储，比如升序降序等。

1.冒泡排序：

思想：以升序为例，从后往前(或从前往后)两两比较相邻元素的值，若为逆序(即A[i-1]>A[i]),则交换他们，直到序列比较完。称这样过程为"一趟"冒泡排序，第一趟排序使关键字值最小的一个元素"冒"到最前面(如果值相同不交换，为了保证稳定性）
空间复杂度：O（1）
最好情况下的时间复杂度（已经排好序）：O（n）
最坏情况下的时间复杂度（完全逆序）：O（n^2）
平均时间复杂度为：O（n^2）

	public static void main(String[] args) {
		int[] a = { 9,8,7,6,5,4,3,2,1 };
		sort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}

	public static void sort(int[] arr) {
		// 中间变量
		int temp;

		for (int i = 0; i < arr.length - 1; i++) {

			// n个元素比较n-1次
			for (int j = 0; j < arr.length - 1 - i; j++) {
				// 不排序已经完成排序的i个元素
				if (arr[j] > arr[j + 1]) {
					// 如果前一个元素大于后一个元素则交换，把最大的冒泡到最后
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

2.选择排序：

思想：以升序为例，每次把最小的放到左边。先拿出第一个，假设是最小的，然后依次和后面的比较，如果有比第一个小的则交换下标，比较一轮之后已经得到了最小元素的下标，然后和最前面的元素交换即可。重复执行多次直到元素后面没有其他元素
空间复杂度：O（1）
最好情况下的时间复杂度（已经排好序）：O（n^2）
最坏情况下的时间复杂度（完全逆序）：O（n^2）
平均时间复杂度为：O（n^2）

	public static void main(String[] args) {
		int[] a = { 9, 8, 7, 22, 6, 5, 4, 10, 3, 2, 1, 11 };
		sort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + "  ");
		}
	}

	public static void sort(int[] arr) {
		// 中间变量
		int temp;
		// n个元素比较n-1次
		for (int i = 0; i < arr.length - 1; i++) {
			int min = i;
			// 不比较已经排好序的i个元素
			for (int j = 1 + i; j < arr.length; j++) {
				// 如果后面的元素小于位置i的元素，则记录下标到min
				min = arr[min] > arr[j] ? j : min;
			}
			// 如果min不等于i，则说明min位置的元素比i位置的元素小，交换
			if (min != i) {
				temp = arr[i];
				arr[i] = arr[min];
				arr[min] = temp;
			}
		}
	}

查找元素

1.顺序查找：

就是用所有数据挨个和目标数据比较，目标数据靠前的话相对快一些

public static void main(String[] args) {
		int[] a = { 1, 2, 3, 7, 8, 9, 4, 5, 6 };
		int num = 8;
		int result = search(a, num);
		System.out.println("在第 " + result + " 位");
	}

	public static int search(int[] arr, int target) {
		// 遍历数组，挨个与目标值target比较
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == target)
				// 找到则返回下标
				return i;
		}
		// 没找到则返回-1
		return -1;
	}

2.二分查找：

又称为折半查找，要求数据必须有序，一般用于固定数据，因为有序，所以添加和删除比较麻烦。
每次比较中间值与目标值，一次比较会筛去1/2的元素

		public static void main(String[] args) {
		int[] a = { 1, 7, 8, 15, 19, 21, 55, 245, 1000 };
		int num = 55;
		int result = binarySearch(a, num);
		System.out.println("在第 " + result + " 位");
	}

	public static int binarySearch(int[] arr, int target) {
		int low = 0, high = arr.length - 1, mid = (low + high) / 2;
		while (low <= high) {
			if (arr[mid] == target) {
				// mid位置元素值和target相等时返回mid
				return mid;
			} else if(target>arr[mid]{
				// target比mid位置元素值大，则low指向mid右边一位
				low = mid + 1 ;
			}else {
				// target比mid位置元素值小，则high指向mid左边一位
				high = mid -1;
			}
			// 更新mid值
			mid = (low + high) / 2;
		}
		// 未找到返回-1
		return -1;
	}