数组排序学习

几种常见排序方法学习记录

1 交换两个元素

private static void swap(int[] array, int i, int j) {
		if (i != j) {
			array[i] = array[i] + array[j];
			array[j] = array[i] - array[j];
			array[i] = array[i] - array[j];
		}
	}

2.冒泡排序

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

3.选择排序

public static void selectSort(int[] array) {
		int length = array.length;
		for (int i = 0; i < length; i++) {
			int index = i;
			for (int j = i + 1; j < length; j++) {
				if (array[j] < array[index]) {
					index = j;
				}
			}
			if (i != index) {
				swap(array, i, index);
			}
		}
	}

4.插入排序

public static void insertSort(int[] array) {
		int length = array.length;
		for (int i = 1; i < length; i++) {
			int key = array[i];
			int position = i;
			for (int j = i - 1; j >= 0; j--) {
				if (array[j] > key) {
					array[j + 1] = array[j];
					position--;
				} else {
					break;
				}
			}
			array[position] = key;
		}
	}

5.快速排序

public static void quickSort(int[] array, int start, int end) {
		if (start < end) {
			int key = array[start];
			int i = start;
			for (int j = start + 1; j <= end; j++) {
				if (key > array[j]) {
					swap(array, j, ++i);
				}
			}
			array[start] = array[i];
			array[i] = key;
			quickSort(array, start, i - 1);
			quickSort(array, i + 1, end);
		}
	}

6.归并排序

public static void mergeSort(int[] array, int left, int right) {
		if (left < right) {
			int center = (left + right) >> 1;
			mergeSort(array, left, center);
			mergeSort(array, center + 1, right);
			merge(array, left, center, right);
		}
	}

	private static void merge(int[] array, int left, int center, int right) {
		int length = right - left + 1;
		int[] temp = new int[length];
		int temIndex = 0;
		int _left = left;
		int _right = center + 1;
		while (_left <= center && _right <= right) {
			if (array[_left] <= array[_right]) {
				temp[temIndex++] = array[_left++];
			} else {
				temp[temIndex++] = array[_right++];
			}
		}
		while (_right <= right) {
			temp[temIndex++] = array[_right++];
		}
		while (_left <= center) {
			temp[temIndex++] = array[_left++];
		}
		temIndex = 0;
		while (temIndex < length) {
			array[left + temIndex] = temp[temIndex++];
		}
	}

7.堆排序

public static void maxHeapFy(int[] array, int i, int heapSize) {
		int left = i * 2 + 1;
		int right = i * 2 + 2;
		int largest = i;
		if (left < heapSize && array[left] > array[largest]) {
			largest = left;
		}
		if (right < heapSize && array[right] > array[largest]) {
			largest = right;
		}
		if (largest != i) {
			swap(array, largest, i);
			maxHeapFy(array, largest, heapSize);
		}
	}

	public static void buildMaxHeap(int[] array,int heapSize){
		for(int i=(heapSize-2)>>1;i>=0;i--){
			maxHeapFy(array, i, heapSize);
		}
	}

	public static void heapSort(int[] array) {
		int length = array.length;
		buildMaxHeap(array, length);
		for (int i = 0; i < length; i++) {
			swap(array, 0, length - 1 - i);
			maxHeapFy(array, 0, length - i - 1);
		}
	}

8.二分查找

public static int binarySearch(int[] array, int key) {
		int low = 0;
		int high = array.length - 1;
		while (low <= high) {
			int middle = low + ((high - low) >> 1);
			if (key == array[middle]) {
				return middle;
			}
			if (key > array[middle]) {
				low = middle + 1;
			} else {
				high = middle - 1;
			}
		}
		return -1;
	}

未完待续…