java常用算法

1.排序算法

1. 冒泡排序
   相邻的两个元素比较，顺序不对就更换位置，时间复杂度O(n^2)。
   示例如下：

    	 int temp = 0;
    	 int[] arr = {10,30,20,50,6,3,80};
    	 for (int i = 0; i < arr.length; i++) {
    		 for (int j = i; j < arr.length; j++) {
    			 if (arr[j] < arr[i]) {
    				 temp = arr[j];
    				 arr[j] = arr[i];
    				 arr[i] = temp;
    			 }
    		 }
    	 }
    	 
    	 for (int i = 0; i < arr.length; i++) {
    		 System.out.println(arr[i]);
    	 }

2. 选择排序
   每次选择未排序序列中最小元素，将其放到已排序序列末尾，时间复杂度O(n^2)
   示例如下：

    	 int temp = 0;
    	 int minIndex = 0;
    	 int[] arr = {10,30,20,50,6,3,80};
    	 for (int i = 0; i < arr.length - 1; i++) {
    		 minIndex = i;
    		 for (int j = i + 1; j < arr.length; j++) {
    			 if (arr[j] < arr[minIndex]) {
    				 minIndex = j;
    			 }
    		 }
    		 
    		 temp = arr[minIndex];
    		 arr[minIndex] = arr[i];
    		 arr[i] = temp;
    	 }
    	 
    	 for (int i = 0; i < arr.length; i++) {
    		 System.out.println(arr[i]);
    	 }

3. 插入排序
   将未排序的序列中的每个元素插入到已排序序列的合适位置，时间复杂度O(n^2)
   示例如下：

    	 int temp = 0;
    	 int[] arr = {10,30,20,50,6,3,80};
    	 for (int i = 1; i < arr.length; i++) {
    		 for (int j = 0; j < i; j++) {
    		     // 内层循环是已排序数组
    			 if (arr[j] > arr[i]) {
    				 temp = arr[j];
    				 arr[j] = arr[i];
    				 arr[i] = temp;
    			 }
    		 }
    		 
    	 }
    	 
    	 for (int i = 0; i < arr.length; i++) {
    		 System.out.println(arr[i]);
    	 }

4. 希尔排序
   插入排序算法的改进，又称增量缩小排序，通过比较相距一定间隔的元素进行，各趟比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。希尔排序时间复杂度是 O(n^(1.3-2))，是一种不稳定的排序算法。

5. 快速排序
   选择一个基准元素，将序列分成2部分，一部分比基准元素小，一部分比基准元素大，然后对这两个序列分别进行排序。该算法的时间复杂度为O(nlogn)。
   示例如下：

public static void quickSort(int[] arr, int leftIndex, int rightIndex) {
		if (leftIndex >= rightIndex) {
			return;
		}
		
		int left = leftIndex;
		int right = rightIndex;
		int key = arr[left];	// 基准值
		// 左右两边交替扫描，直到left=right
		while (left < right) {
			// 从右向左排序,找到一个比基准值小的元素
			while (right > left && arr[right] >= key) {
				right--;
			}
			
			arr[left] = arr[right];
			
			// 从左向右排序,找到一个比基准值大的元素
			while(left < right && arr[left] <= key) {
				left++;
			}
			
			arr[right] = arr[left];
		}
		
		// 基准值归位
		arr[left] = key;
		
		// 对基准值左边的元素进行递归排序
		quickSort(arr, leftIndex, left - 1);
		
		// 对基准值右边的元素进行递归排序
		quickSort(arr, right + 1, rightIndex);
	}

6. 归并排序
   将待排序的数组不断拆分，直到待拆分的数组只剩一个元素，然后合并两个有序数组，一层一层向上合并。时间复杂度可以记为O(N)。因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在O(N*logN)的几种排序方法（快速排序，归并排序，希尔排序，堆排序）也是效率比较高的。

算法流程：
1、将一个数组拆分为两个，从中间点拆开，通过递归操作来实现一层一层拆分。
2、从左右数组中选择小的元素放入到临时空间，并移动下标到下一位置。
3、重复步骤2直到某一下标达到尾部。
4、将另一序列剩下的所有元素依次放入临时空间。
5、将临时空间的数据依次放入原数据数组。

7. 堆排序
   堆排序是一种基于二叉堆数据结构的排序算法。它将待排序的序列构建成一个二叉堆，然后依次将堆顶元素（即最大元素）和堆尾元素交换，然后再对剩余的元素进行堆调整，使得剩余元素中的最大值上浮到堆顶，再次交换堆顶元素和堆尾元素，直到所有元素都被排序完成。堆排序的时间复杂度为O(nlogn)，不需要额外的空间,空间复杂度O(1)，是一种原地排序算法。

算法流程：
1 将待排序的数组构造一个大顶堆，堆顶为最大元素
2 然后堆顶元素和最后一个元素交换，调整大顶堆，不断减少数组的范围。
3 以此类推，最后会生成一个升序的数组。

2.查找算法

1. 二分查找
   又称折半查找，前提是集合是有序的。他的思想是将集合分成2半，如果目标元素比空间元素小，就从前半部分查找，反之从后半部分查找。找到目标元素或数据集合为空。
   示例如下：

	public static int search(int[] arr, int key) {
		int left = 0;
		int right = arr.length - 1;
		while(left <= right) {
		    // 找到中间元素
			int mid = left + (right- left) / 2;
			if (arr[mid] == key) {
				return mid;
			} else if (arr[mid] > key) {
			    // 如果中间元素比查找元素大，说明在左侧查找
				right = mid - 1;
			} else {
			    // 如果中间元素比查找元素小，说明在右侧查找
				left = mid + 1;
			}
		}
		
		return -1;
	}

2. 线性查找
   最简单的查找方法，从集合的第一个元素开始比较，直到找到目标元素，可能遍历整个集合。