JAVA基础篇：基础排序算法

冒泡排序法：

---

原理简介：

从前向后(或从后向前)依次比较相邻的元素，若发现逆顺序，则交换。小的向前换，大的向后换，像水底的气泡逐渐向上冒，顾名思义冒泡排序法。

通俗一点就是把大的往上挪！！！像冒泡一样。
是交换式排序法的一种。（冒泡排序法效率较低）

冒泡排序法思路：

1：外层循环：控制它要走多少次。
假设你有5个数，那就要走4次，最后一次不用走，最后那个数已经在它位置了所以就要length-1次。
2：内层循环：控制逐一比较，如果发现前一个数比后一个数大，则交换。
注意！因为越比较长度就越小了，所以长度要length-1-i。

代码示例：

package Homework;
//冒泡排序法
public class Testone01 {

	public static void main(String[] args) {
		int[] arr = {45,53,62,98,87,76,48,85,92,59};
		selectNum(arr);
		for (int i : arr) {
			System.out.print(i + ",");
		}
	}

	public static void selectNum(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 static void swap(int[] arr, int j, int i) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
		
	}

}

选择排序法：

---

原理简介：

选择排序原理即是，遍历元素找到一个最小（或最大）的元素，把它放在第一个位置，然后再在剩余元素中找到最小（或最大）的元素，把它放在第二个位置，依次下去，完成排序。

选择排序思路：

一：外层循环：控制它要走多少次，同样是length-1次。
1：设置一个最小值，假设第一个就是最小值（默认为i）。
2：设置一个最小值下标（也就是最小值索引）。
二：内层循环：用你当前的最小值去逐一比较。当有比当前最小值小的数时，记录最小值，记录下标。退出内层循环后就交换位置。

代码示例：

package Homework;
//选择排序法
public class Testone02 {
	public static void main(String[] args) {
		int[] arr = {45,53,62,98,87,76,48,85,92,59};
		selectNum(arr);
		for (int i : arr) {
			System.out.print(i + ",");
		}
	}

	public static void selectNum(int[] arr) {
		for (int i = 0; i < arr.length-1; i++) {
			int minIndex = i;//记录最小值索引，默认为i
			for (int j = i; j < arr.length; j++) {
				if(arr[j] < arr[minIndex]) {
					minIndex = j;
				}
			}
			if (i != minIndex) {
				swap(arr,i,minIndex);
			}
		}
		
	}

	public static void swap(int[] arr, int i, int minIndex) {
		arr[i] = arr[i] + arr[minIndex];
		arr[minIndex] = arr[i] - arr[minIndex];
		arr[i] = arr[i] - arr[minIndex];
		
	}

}

插入排序法：

---

原理简介：

把i个待排序的元素看成一个有序表和无序表。一开始有序表只包含一个元素，无序表中包含i-1个元素。排序过程中每次从无序表中取出第一个元素，把它依次与有序表中的元素进行比较。然后把它插入到有序表的适当位置，形成新的有序表。

通俗来讲：假设第一个元素是有序的，后面的元素往前插入，依次进行比较，小的往前挪，大的往后挪，找到合适的位置插入。打个形象的比方就是打扑克牌时的摆牌。

选择排序思路：

一：外层循环：控制它要走多少次，因为第一个是有序的，所以不用参与插入，所以从1开始，所以是length次。

二：内层循环：如果插入的数比被插入的数小，就要把被插入的数向后移，插入的数向前移，j-就退出了循环，当不满足循环条件后就找到了合适的位置插入。

原理图：

 代码示例：

package Homework;
//插入排序法
public class Testone03 {
	public static void main(String[] args) {
		int[] arr = {45,53,62,98,87,76,48,85,92,59};
		selectNum(arr);
		for (int i : arr) {
			System.out.print(i + ",");
		}
	}

	public static void selectNum(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			for (int j = i; j >0; j--) {
				if(arr[j] < arr[j-1]) {
					 int temp = arr[j];
	                    arr[j] = arr[j - 1];
	                    arr[j - 1] = temp;
				}
			}
		}
		
	}

}

查询算法（二分查找（折半查找））：

---

原理简介：

二分查找又称为折半查找，它是一种效率较高的查找方法，但是，折半查找要求线程表必须采用顺序存储结构，且表中的元素是有序的。如果查询数据是无序的，那就找线性（遍历）查找。

适用范围：

适用于经常查找的、但是不变的（增删）的有序列表。

原理图：

 代码示例：

package Excise;

//二分查找
public class Test {

	public static void main(String[] args) {
		int[] arr = {1, 2, 9, -100, -55, 23, -99, 0, 3, 4, 8};
		bubbleSort(arr);
		int index = binarySearch(arr, -55);
		System.out.println(index);
	}

	public static void bubbleSort(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);
					}
				}
			}
		}

	private static void swap(int[] arr, int j, int i) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
		}

	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;
	}
	
}