自己实现的几种排序算法，含源代码java

冒泡排序，时间复杂度O(n^2)：

	public static void bubbleSort(int[] array) {
		int temp;
		for (int i = 0; i < array.length; i++) {
			for (int j = i + 1; j < array.length; j++) {
				if (array[i] > array[j]) {
					temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
	}

插入排序，时间复杂度O(n^2)：

	public static void insertSort(int[] array) {
		int temp;
		int j;
		for (int i = 1; i < array.length; i++) {
			temp = array[i];
			j = i - 1;
			while ( j >= 0 && temp > array[j]) {
				array[j + 1] = array[j];
				j--;
			}
			array[j + 1] = temp;
		}
	}

快速排序，时间复杂度O（nlogn）:

	public static void quickSort(int[] array, int left, int right) {
		if (left < right) {
			int position = partition(array, left, right);
			quickSort(array, left, position - 1);
			quickSort(array, position + 1, right);
		}
	}
	
	private static int partition(int[] array, int left, int right) {
		int pivot = array[left];
		while (left < right) {
			while (left < right && array[right] < pivot) {
				right--;
			}
			array[left] = array[right];
			while (left < right && array[left] >= pivot) {
				left++;
			}
			array[right] = array[left];
		}
		
		array[left] = pivot;
		return left;
	}

合并两个已排序数组：

	public static int[] mergeArray(int[] array1, int[] array2) {
		int length = array1.length + array2.length;
		int[] arrayMerged = new int[length];
		int i = 0;
		int j = 0;
		int k = 0;
		
		int length1 = array1.length;
		int length2 = array2.length;
		while (i< length1 && j < length2) {
			if (array1[i] < array2[j]) {			//拷贝值较小的元素，填充合并数组
				arrayMerged[k++] = array1[i++];
			} else if (array1[i] > array2[j]) {
				arrayMerged[k++] = array2[j++];
			} else {
				arrayMerged[k++] = array1[i++];
				arrayMerged[k++] = array1[j++];
			}
		}
		
		if (i >= length1) {
			while (j < length2) {
				arrayMerged[k++] = array2[j++];
			}
		} else {
			while (i < length1) {
				arrayMerged[k++] = array1[i++];
			}
		}
		
		return arrayMerged;
	}

不用中间变量，交换两个数：

	public static void swap(int[] array, int n, int m, int method) {
		switch (method) {
		case 0:
			array[n] = array[n] + array[m];
			array[m] = array[n] - array[m];
			array[n] = array[n] - array[m];
			break;
		case 1:
			array[n] = array[n] * array[m];
			array[m] = array[n] / array[m];
			array[n] = array[n] / array[m];
		default:
			break;
		}
	}