Java数组快速排序，冒泡排序，选择排序，插入排序代码实现

Java数组快速排序，插入排序，冒泡排序，选择排序代码实现

快速排序：递归拆分
插入排序：从左往右一个一个插入左边已排好的数组中
冒泡排序：选定一个节点循环相邻的比较，每次循环排出一个最大的值
冒泡排序优化：看完血赚https://www.cnblogs.com/kilig/p/10423845.html
选择排序：只要发现小的就交换到前面
二分查找：前后端点和中间点循环比较

package test;

import java.util.Arrays;

public class ArraySort {
	public static void main(String args[]) {

		int[] a = { 2, 4, 64, 3, 63, 6 };
		// quickSort(a, 0, a.length - 1);
		// insertSort(a);
		// bubleSort(a);
		selsctSort(a);
		for (int i : a) {
			System.out.print(i + ",");
		}
		binarySearch(a, 6);
		System.out.println();
		System.out.print("二分查找:" + binarySearch(a, 63));
	}

	// 快速排序
	//https://mp.weixin.qq.com/s?__biz=MzIxMjE5MTE1Nw==&mid=2653195042&idx=1&sn=2b0915cd2298be9f2163cc90a3d464da&chksm=8c99f9f8bbee70eef627d0f5e5b80a604221abb3a1b5617b397fa178582dcb063c9fb6f904b3&scene=21#wechat_redirect
	public static int[] quickSort(int[] A, int begin, int end) {
	 int i = begin;
        int j = end;
        if (i >= j) {
            return A;
        }
        int temp = A[i];
        while (i < j) {
            while (i < j && A[j] >= temp) {
                j--;
            }
            while (i < j && A[i] <= temp) {
                i++;
            }
            if (i < j) {
                int k = A[i];
                A[i] = A[j];
                A[j] = k;
            }
        }
        A[begin] = A[i];
        A[i] = temp;
        // 递归调用左半数组
        quickSort(A, begin, i - 1);
        // 递归调用右半数组
        quickSort(A, i + 1, end);

        return A;
	}

	// 插入排序
	public static int[] insertSort(int[] A) {
		for (int i = 1; i < A.length; i++) {
			int temp = A[i];
			int j;
			for (j = i - 1; j >= 0; j--) {
				if (temp < A[j]) {
					A[j + 1] = A[j];

				} else {
					break;
				}
			}
			A[j + 1] = temp;
		}

		return A;
	}

	// 冒泡排序
	public static int[] bubleSort(int[] nums) {
		// 1.从前往后
		for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
			for (int j = 0; j < nums.length - i - 1; j++) {// 内层循环控制每一趟排序多少次
				if (nums[j] > nums[j + 1]) {
					int temp = nums[j];
					nums[j] = nums[j + 1];
					nums[j + 1] = temp;
				}
			}
		}

		// 2.从后往前
		/*for (int i = nums.length - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				if (nums[j + 1] < nums[j]) {
					int temp = nums[j];
					nums[j] = nums[j + 1];
					nums[j + 1] = temp;
				}
			}
		
		}
		*/
		return nums;
	}

	// 选择排序
	public static int[] selsctSort(int[] nums) {
		// 普通选择排序
		/*	for (int i = 0; i < nums.length; i++) {
				for (int j = i + 1; j < nums.length; j++) {
					if (nums[i] > nums[j]) {
						int temp = nums[i];
						nums[i] = nums[j];
						nums[j] = temp;
					}
				}
			}*/
		// 提高效率排序
		int k = 0;
		for (int i = 0; i < nums.length - 1; i++) {
			k = i;
			for (int j = i + 1; j < nums.length; j++) {
				if (nums[j] < nums[k]) {
					k = j;
				}
			}
			if (k != i) {
				nums[k] = nums[k] ^ nums[i];
				nums[i] = nums[k] ^ nums[i];
				nums[k] = nums[k] ^ nums[i];
			}
		}

		return nums;
	}

	// 二分查找
	public static int binarySearch(int[] nums, int num) {
		int begin = 0;
		int end = nums.length - 1;
		int mid;
		while (begin < end) {
			mid = begin + (end - begin)  /  2;
			//(begin +end)  /  2有溢出风险
			if (nums[mid] == num) {
				return mid;
			} else if (nums[mid] < num) {
				begin = mid;
			} else if (nums[mid] > num) {
				end = mid;
			} else {
				return 0;
			}
		}
		return 0;
	}
// 递归二分查找
	public static int binarySearch(int[] nums, int bg, int end, int num) {
		 if(bg<=end){
			int mid = begin + (begin - end)  /  2;
			if (nums[mid] == num) {
				return mid;
			} else if (nums[mid] < num) {
				//bg = mid + 1;
				return binarySearch(nums, mid+1, end, num);
			} else {
				//end = mid - 1;
				return binarySearch(nums, bg, mid-1, num);
			}

		 }
		return -1;
	}
}