排序算法

冒泡排序

public static void bubbleSort(int[] array) {
	boolean flag = false;// 判断是否发生交换

	for (int i = 0; i < array.length - 1; i++) {
		for (int j = 0; j < array.length - 1 - i; j++) {
			if (array[j] > array[j + 1]) {
				flag = true;
				int temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;
			}
		}
		if (!flag)
			break;// 若不发生交换，则排序完成跳出循环
		else
			flag = false;
	}
}

选择排序

public static void selectSort(int[] a) {
	for (int i = 0; i < a.length-1; i++) {
		int min = a[i];
		int minIndex = i;
		for (int j = i; j < a.length; j++) {
			if (a[j]<min) {
				min = a[j];
				minIndex = j;
			}
		}
		a[minIndex] = a[i];
		a[i] = min;
	}
}

插入排序

public static void insertSort(int[] a) {
	for (int i = 1; i < a.length; i++) {
		int insertVal = a[i];
		int insertIndex = i - 1;
		while (insertIndex >= 0 && a[insertIndex] > insertVal) {
			a[insertIndex + 1] = a[insertIndex];
			insertIndex--;
		}
		if (insertIndex + 1 != i)
			a[insertIndex + 1] = insertVal;
	}
}

希尔排序

按下标的一定增量分组，对每组使用直接插入排序算法排序。

public static void shellSort(int[] a) {
	for (int gap = a.length / 2; gap > 0; gap /= 2) {
		for (int i = gap; i < a.length; i++) {
			int insertVal = a[i];
			int insertIndex = i - gap;
			while (insertIndex >= 0 && a[insertIndex] > insertVal) {
				a[insertIndex + gap] = a[insertIndex];
				insertIndex -= gap;
			}
			if (insertIndex + gap != i)
				a[insertIndex + gap] = insertVal;
		}
	}
}

快速排序

1．先从数列中取出一个数作为基准数。代码取第一项为基准数
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

public static void quickSort(int[] a, int left, int right) {
	if (left < right) {
		int l = left;
		int r = right;
		//数组第一项为基准数
		int X = a[l];
		while (l < r) {
			while (a[r] > X && l < r)
				r--;
			if (l < r) {
				a[l] = a[r];
				l++;
			}
			while (a[l] < X && l < r)
				l++;
			if (l < r) {
				a[r] = a[l];
				r--;
			}
		}
		a[l] = X;
		//分治
		quickSort(a, left, l - 1);
		quickSort(a, l + 1, right);
	}
}

归并排序

//合并
private static void mergeArray(int a[], int first, int mid, int last, int temp[]) {
	int i = first, j = mid + 1;
	int m = mid, n = last;
	int k = 0;

	while (i <= m && j <= n) {
		if (a[i] <= a[j])
			temp[k++] = a[i++];
		else
			temp[k++] = a[j++];
	}

	while (i <= m)
		temp[k++] = a[i++];
	while (j <= n)
		temp[k++] = a[j++];
	for (i = 0; i < k; i++)
		a[first + i] = temp[i];
}
//排序
public static void mergeSort(int a[], int first, int last, int temp[]) {
	if (first < last) {
		int mid = (first + last) / 2;
		mergeSort(a, first, mid, temp); // 左边有序
		mergeSort(a, mid + 1, last, temp); // 右边有序
		mergeArray(a, first, mid, last, temp); // 再将二个有序数列合并
	}
}

基数排序

// 空间换时间
public static void radixSort(int[] arr) {
	// 得到最大数的位数
	int max = arr[0];
	for (int i = 1; i < arr.length; i++) {
		if (arr[i] > max) {
			max = arr[i];
		}
	}
	int maLength = (max + "").length();

	for (int i = 0, n = 1; i < maLength; i++, n *= 10) {
		int[][] bucket = new int[10][arr.length];
		// 记录每个桶实际放入的数据
		int[] bucketElementsCounts = new int[10];
		for (int j = 0; j < arr.length; j++) {
			int digitOfElement = arr[j] / n % 10;
			// 放入到对应桶中
			bucket[digitOfElement][bucketElementsCounts[digitOfElement]] = arr[j];
			bucketElementsCounts[digitOfElement]++;
		}
		// 依次取出数组，放入原来数组
		int index = 0;
		for (int k = 0; k < bucketElementsCounts.length; k++) {
			if (bucketElementsCounts[k] != 0) {
				for (int l = 0; l < bucketElementsCounts[k]; l++) {
					arr[index++] = bucket[k][l];
				}
			}
			bucketElementsCounts[k] = 0;
		}
	}
}