十种排序算法(java描述)

代码中类似mid=(low+high)/2的语句可能会产生溢出，可以改成mid=low+(high-low)/2

一、冒泡排序(时间复杂度:O(n^2),稳定)

public static void bubbleSort(int[] array) {
	boolean flag = true;
	for (int i = array.length - 1; flag && i > 0; i--) {
		flag = false;
		for (int j = 0; j < i; j++) {
			if (array[j] > array[j + 1]) {
				int tmp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = tmp;
				flag = true;
			}
		}
	}
}

二、选择排序(时间复杂度:O(n^2),不稳定)

public static void selectionSort(int[] array){
	for(int i = array.length-1;i>0;i--){
		int maxIndex = i;
		for(int j = 0;j
   
   
    
    array[maxIndex])
				maxIndex=j;
		}
		if(i!=maxIndex){
			int tmp =array[i];
			array[i]=array[maxIndex];
			array[maxIndex]=tmp;
		}
	}
}

   
   

三、直接插入排序(时间复杂度:O(n^2),稳定)

public static void straightInsertionSort(int[] array) {
	for (int start = 1; start < array.length; start++) {
		int key = array[start];
		int pos = start - 1;
		while (pos >= 0 && array[pos] > key) {
			array[pos + 1] = array[pos];
			pos--;
		}
		array[pos + 1] = key;
	}
}

四、折半插入排序(时间复杂度:O(n^2),稳定)

public static void binaryInsertionSort(int[] array) {
	for (int start = 1; start < array.length; start++) {
		int key = array[start];
		int low = 0;
		int high = start - 1;
		while (low <= high) {
			int mid = (low + high) / 2;
			if (array[mid] <= key)
				low = mid + 1;
			else
				high = mid - 1;
		}
		for (int i = start; i > low; i--)
			array[i] = array[i - 1];
		array[low] = key;
	}
}

五、希尔排序(时间复杂度:O(n^1.3),不稳定)

public static void shellSort(int[] array) {
	int interval = 1;
	while (interval < array.length / 3)
		interval = 3 * interval + 1;
	for (; interval >= 1; interval = (interval - 1) / 3) {
		for (int start = interval; start < array.length; start += interval) {
			int key = array[start];
			int pos = start - interval;
			while (pos >= 0 && array[pos] > key) {
				array[pos + interval] = array[pos];
				pos -= interval;
			}
			array[pos + interval] = key;
		}
	}
}

六、快速排序(时间复杂度:O(nlog2n),不稳定)

private static void quickSort(int[] array, int start, int end) {
	if (start < end) {
		int nextStart = start;
		int nextEnd = end;
		int key = array[start];
		while (start < end) {
			while (start < end && key <= array[end])
				end--;
			if (start < end)
				array[start++] = array[end];
			while (start < end && key >= array[start])
				start++;
			if (start < end)
				array[end--] = array[start];
		}
		array[start] = key;
		quickSort(array, nextStart, start - 1);
		quickSort(array, start + 1, nextEnd);
	}
}

public static void quickSort(int[] array) {
	quickSort(array, 0, array.length - 1);
}

七、堆排序(时间复杂度:O(nlog2n),不稳定)

private static void heapAdjust(int[] array, int start, int end) {
	int key = array[start];
	int nextStart;
	while ((nextStart = 2 * start + 1) <= end) {
		if (nextStart < end && array[nextStart] < array[nextStart + 1])
			nextStart++;
		if (key < array[nextStart]) {
			array[start] = array[nextStart];
			start = nextStart;
		} else
			break;
	}
	array[start] = key;
}

public static void heapSort(int[] array) {
	for (int i = array.length / 2 - 1; i >= 0; i--)
		heapAdjust(array, i, array.length - 1);
	for (int j = array.length - 1; j > 0; j--) {
		int tmp = array[0];
		array[0] = array[j];
		array[j] = tmp;
		heapAdjust(array, 0, j - 1);
	}
}

八、归并排序(时间复杂度:O(nlog2n),稳定)

private static void merge(int[] array, int[] left, int[] right) {
	int count1 = 0;
	int count2 = 0;
	int count3 = 0;
	while (count1 < left.length && count2 < right.length) {
		if (left[count1] <= right[count2])
			array[count3++] = left[count1++];
		else
			array[count3++] = right[count2++];
	}
	while (count1 < left.length)
		array[count3++] = left[count1++];
	while (count2 < right.length)
		array[count3++] = right[count2++];
}

public static void mergeSort(int[] array) {
	if (array.length > 1) {
		int[] left = Arrays.copyOfRange(array, 0, array.length / 2);
		int[] right = Arrays.copyOfRange(array, array.length / 2,
				array.length);
		mergeSort(left);
		mergeSort(right);
		merge(array, left, right);
	}
}

九、桶排序(时间复杂度:O(n),稳定)

public static void bucketSort(int[] array, int min, int max) {
	int[] bucket = new int[max - min + 1];
	for (int i = 0; i < array.length; i++)
		bucket[array[i] - min]++;
	for (int j = 1; j < bucket.length; j++)
		bucket[j] += bucket[j - 1];
	int[] tmp = Arrays.copyOfRange(array, 0, array.length);
	for (int k = array.length - 1; k >= 0; k--)
		array[--bucket[tmp[k] - min]] = tmp[k];
}

十、基数排序(时间复杂度:O((n+radix)*digitCount),稳定)

public static void radixSort(int[] array, int digitCount) {
	int divisor = 1;
	while (digitCount > 0) {
		int[] bucket = new int[10];
		for (int i = 0; i < array.length; i++)
			bucket[array[i] / divisor % 10]++;
		for (int j = 1; j < 10; j++)
			bucket[j] += bucket[j - 1];
		int[] tmp = Arrays.copyOfRange(array, 0, array.length);
		for (int k = array.length - 1; k >= 0; k--)
			array[--bucket[tmp[k] / divisor % 10]] = tmp[k];
		divisor *= 10;
		digitCount--;
	}
}