java七种排序

冒泡排序：

	// 时间复杂度O(n^2)
	public static void bubbleSort(int[] arr) {
		int temp = 0;
		boolean flag = false;// 标识变量，表示是否经历过交换
		for (int j = 1; j < arr.length; j++) {
			for (int i = 0; i < arr.length - j; i++) {
				if (arr[i] > arr[i + 1]) {
					flag = true;
					temp = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = temp;
				}
			}
			if (!flag) {// 在一次排序中，一次交换都没有发生过
				break;
			} else {// 重置flag,进行下次判断
				flag = false;
			}
		}
	}

插入排序：

// 插入排序
	public static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			int temp = arr[i];
			int index = i - 1;
			while (index >= 0 && temp < arr[index]) {// 保证找插入位置时不越界
				arr[index + 1] = arr[index];//向右移
				index--;
			}
			//退出while说明找到插入位置
			arr[index + 1] = temp;
		}
	}

归并排序：

//分+合方法
public static void mergeSort(int[] arr, int left, int right, int[] temp) {
	if(left < right) {
		int mid = (left + right) / 2;
		mergeSort(arr, left, mid, temp);
		mergeSort(arr, mid + 1, right, temp);
		//合并
		merge(arr, left, mid, right, temp);
	}
}
//合并的方法
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
	int i = left;// 左边有序序列的初始索引
	int j = mid + 1;// 右边有序序列的初始索引
	int t = 0;// temp数组的当前索引
	while (i <= mid && j <= right) {
		if (arr[i] <= arr[j]) {
			temp[t] = arr[i];
			t++;
			i++;
		} else {
			temp[t] = arr[j];
			t++;
			j++;
		}
	}
	while (i <= mid) {
		temp[t] = arr[i];
		t++;
		i++;
	}
	while (j <= right) {
		temp[t] = arr[j];
		t++;
		j++;
	}
	//将temp数组的元素拷贝到arr
	t = 0;
	int tempLeft = left;
	while(tempLeft <= right) {
		arr[tempLeft] = temp[t];
		t++;
		tempLeft++;
	}
}

快排：

	public static void quickSort(int[] arr, int left, int right) {
		int l = left;
		int r = right;
		int pivot = arr[(l + r) / 2];
		int temp = 0;
		// 比中值小的放到左边，大的放到右边
		while (l < r) {
			while (arr[l] < pivot) {
				l += 1;
			}
			while (arr[r] > pivot) {
				r -= 1;
			}
			if (l >= r) {
				break;
			}
			temp = arr[l];
			arr[l] = arr[r];
			arr[r] = temp;
			if(arr[l] == pivot) {
				r -= 1;
			}
			if(arr[r] == pivot) {
				l += 1;
			}
		}
	}

基数排序：

	public static void radixSort(int[] arr) {
		/*
		 * 基数排序用空间换时间 定义一个二维数组表示10个桶，每个桶就是一个一维数组
		 */
		int[][] bucket = new int[10][arr.length];
		// 定义一维数组来记录各个桶每次放入的数据个数
		int[] count = new int[10];
		int temp = arr[0];
		//找出最大数
		for (int i : arr) {
			if (temp < i) {
				temp = i;
			}
		}
		//控制取哪一位数
		int tempNum = 1;
		while (temp != 0) {//判断循环次数
			for (int i : arr) {
				int num = (i / tempNum) % 10;
				bucket[num][count[num]] = i;
				count[num]++;//取数放入数组
			}
			int index = 0;
			for (int k = 0; k < count.length; k++) {
				if (count[k] != 0) {
					for (int l = 0; l < count[k]; l++) {
						arr[index++] = bucket[k][l];
					}
				}//返回给arr,将count清0
				count[k] = 0;
			}
			temp /= 10;
			tempNum *= 10;
		}
	}

选择排序：

	// 选择排序,时间复杂度O(n^2)
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			int temp = arr[i];
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (temp > arr[j]) {
					temp = arr[j];
					minIndex = j;
				}				
			}
			if (minIndex != i) {
				arr[minIndex] = arr[i];
				arr[i] = temp;
			}
		}
	}

希尔排序：

	// 交换法排序
	public static void shellSort(int[] arr) {
		int temp = 0;
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				for (int j = i - gap; j >= 0; j -= gap) {
					if (arr[j] > arr[j + gap]) {
						temp = arr[j];
						arr[j] = arr[j + gap];
						arr[j + gap] = temp;
					}
				}
			}
		}
	}

	// 移位法排序
	public static void shellSort2(int[] arr) {
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				int j = i;
				int temp = arr[j];
				if (arr[j] < arr[j - gap]) {
					while (j - gap >= 0 && temp < arr[j - gap]) {
						arr[j] = arr[j - gap];
						j -= gap;
					}
					// 退出while时找到插入位置
					arr[j] = temp;
				}
			}
		}
	}