算法笔记---更新中

排序算法

1. 冒泡排序

概述：
依次比较相邻的两个数，将小数放在前面，大数放在后面。
即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。
然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。

public static int[] bubbleSort(int[] arr, int a, int b);
解析：
	int[] ：返回类型 
	arr	：传入数组
	a	：起始位置
	b	：结束位置

//冒泡排序
public static int[] bubbleSort(int[] arr, int a, int b){
	for(int i=a; i<b; i++){
		for(int j=a; j<b-1-i; j++){
			if(arr[j] > arr[j+1]){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
	return arr;
}

2. 选择排序

概述：
每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

public static int[] selectSort(int[] arr, int a, int b);
解析：
	int[]：返回类型
	arr	：传入数组
	a	：起始位置
	b	：结束位置

//选择排序
public static int[] selectSort(int[] arr, int a, int b){
	for(int i=a; i<b; i++){
		for(int j=i+1; j<b; j++){
			if(arr[i] > arr[j]){
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
	return arr;
}

3. 插入排序

概述：
每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

public static int[] insertionSort(int[] arr)
解析：
	int[]：返回类型
	arr	：传入数组

//插入排序
public static int[] insertionSort(int[] arr){
	for(int i=1; i<arr.length; i++){
		int j = i;
		while(j > 0 && arr[j] < arr[j-1]){
			int temp = arr[j];
			arr[j] = arr[j-1];
			arr[j-1] = temp;
			j--;
		}
	}
	return arr;
}

4. 快速排序

概述：
快速排序(Quicksort)是对冒泡排序的一种改进，由C. A. R. Hoare在1962年提出。它的基本思想是：
（1）先从数列中选择一个数作为基准数
（2）将序列分成两个区间，小于基准数的放在左区间，大于基准数的放在右区间。
（3）对分出的左右区间重复第二步，直到各区间只有一个数。（递归）

快速排序：无返回值（递归思想）
public static void quickSort(int[] arr, int left, int right);
解析：
	int[] arr：传入数组
	int left：数组要排序的最左边索引
	int right：数组要排序的最右边索引

public class Test {
	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22 };
		System.out.print("排序前：");
		for (int i : arr) {
			System.out.print(i+" ");
		}
		System.out.println();

		quickSort(arr, 0, arr.length - 1);
		System.out.print("排序后: ");
		for (int i : arr) {
			System.out.print(i+" ");
		}
		System.out.println();
	}
	
	//快速排序：无返回值
	public static void quickSort(int[] arr, int left, int right){
		if (left < right){
			int i = left, j = right, x = arr[left];
			while (i < j){
				while(i < j && arr[j] >= x) //从右向左找第一个小于x的数
					j--;
				if(i < j) {
					arr[i] = arr[j];		//将查询出来的值赋给arr[left]
					i++;					//left后移一位
				}
			
				while(i < j && arr[i] < x)	//从左向右找第一个大于等于x的数
					i++;  
				if(i < j) {
					arr[j] = arr[i];		//将查询出来的值赋给arr[right]
					j--;					//right前移一位
				}
			}
			arr[i] = x;						//确定中间值
			quickSort(arr, left, i - 1);	//递归调用 
			quickSort(arr, i + 1, right);
		}
	}
}

查找算法

1. 顺序查找

概述
通过遍历无序数组，一个一个对比数组中的值与目标值是否相同，若相同，则返回索引，否则继续遍历，直到遍历结束，未发现该目标值，则返回 -1

public static int getIndex(int[] arr, int value);
解析：
	int：返回索引值
	arr	：传入数组
	value	：要查询的值

// 普通查找: arr是无序的
public static int getIndex(int[] arr, int value) {
	 int index = -1;
	 for (int x = 0; x < arr.length; x++) {
		 if (arr[x] == value) {
			index = x;
			break;
		 }
	 }
	 return index;
 }

2. 二分查找

概述
二分查找，又称折半查找，基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2]，则找到x，算法中止；如果x<a[n/2]，则只要在数组a的左半部分继续搜索x，如果x>a[n/2]，则只要在数组a的右半部搜索x.

public static int BinSearch(int[] arr, int a);
	解析：
	int：返回索引值
	arr	：传入数组
	a	：要查询的数字

//二分查找: arr是已经排序好的
public static int BinSearch(int[] arr, int a){
	int low = 0;
	int hight = arr.length;
	int mid = 0;
	
	while(low <= hight){
		mid = (low+hight)/2;
		if(a < arr[mid]){
			hight = mid-1;
		}else if(a > arr[mid]){
			low = mid+1;
		}else{
			return mid;
		}
	}
	return 0;
}