排序算法

排序算法

自己码的代码，亲测可以直接运行

冒泡排序

• 原理：

比较相邻的元素。如果第一个比第二个大，就交换它们两个。

• 算法分析

最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

/**
	 * 冒泡排序
	 */
	public void bobSort() {
		for (int i = 0; i < length - 1; i++) {// 排序轮数
			for (int j = 0; j < length - 1; j++) {// 比较次数
				if (array[j] > array[j + 1]) {
					int temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
		}
	}

快速排序

• 原理：

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

• 算法分析

最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(nlogn)

   /**
    	 * 快速排序
    	 */
    	public static void quickSort(int array[], int low, int high) {		
    		// 1,找到递归算法的出口
    		if (low > high) {
    			return;
    		}
    		// 2, 存
    		int i = low;
    		int j = high;
    		// 3,key
    		int key = array[low];
    		// 4，完成一趟排序
    		while (i < j) {
    			// 4.1 ，从右往左找到第一个小于key的数
    			while (i < j && array[j] > key) {
    				j--;
    			}
    			// 4.2 从左往右找到第一个大于key的数
    			while (i < j && array[i] <= key) {
    				i++;
    			}
    			// 4.3 交换
    			if (i < j) {
    				int p = array[i];
    				array[i] = array[j];
    				array[j] = p;
    			}
    		}
    		// 4.4，调整key的位置
    		int p = array[i];
    		array[i] = array[low];
    		array[low] = p;
    		// 5, 对key左边的数快排
    		quickSort(array, low, i - 1);
    		// 6, 对key右边的数快排
    		quickSort(array, i + 1, high);
    	}

选择排序

• 原理：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

• 算法分析

最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

/**
	 * 选择排序
	 */
	public static void bubbleSort(int array[]){
		int len=array.length;
	    for (int i=0 ; i<len-1 ; i++){
	        for(int j=0 ; j<len-1-i ; j++){
	            if(array[j]>array[j+1]){
	                int temp = array[j];
	                array[j] = array[j+1];
	                array[j+1] = temp;
	            }
	        }
	    }
	    
	}

源码

package com.demo.test;

public class SortTest {

	private int[] array;
	private int length;

	/**
	 * 构造函数
	 * 
	 * @param array
	 */
	public SortTest(int[] array) {
		this.array = array;
		this.length = array.length;
	}

	/**
	 * 打印数组中数据
	 */
	public void display(int[] array) {
		for (int i : array) {
			System.out.print(i + " ");
		}
		System.out.println();
	}

	/**
	 * 冒泡排序
	 */
	public void bobSort() {
		for (int i = 0; i < length - 1; i++) {// 排序轮数
			for (int j = 0; j < length - 1; j++) {// 比较次数
				if (array[j] > array[j + 1]) {
					int temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
		}
	}

	/**
	 * 快速排序
	 */
	public static void quickSort(int array[], int low, int high) {		
		// 1,找到递归算法的出口
		if (low > high) {
			return;
		}
		// 2, 存
		int i = low;
		int j = high;
		// 3,key
		int key = array[low];
		// 4，完成一趟排序
		while (i < j) {
			// 4.1 ，从右往左找到第一个小于key的数
			while (i < j && array[j] > key) {
				j--;
			}
			// 4.2 从左往右找到第一个大于key的数
			while (i < j && array[i] <= key) {
				i++;
			}
			// 4.3 交换
			if (i < j) {
				int p = array[i];
				array[i] = array[j];
				array[j] = p;
			}
		}
		// 4.4，调整key的位置
		int p = array[i];
		array[i] = array[low];
		array[low] = p;
		// 5, 对key左边的数快排
		quickSort(array, low, i - 1);
		// 6, 对key右边的数快排
		quickSort(array, i + 1, high);
	}

	public static void main(String[] args) {
		int[] array = { 77, 29, 28, 36, 33, 25, 10 };
		SortTest bobSort = new SortTest(array);
		System.out.println("冒泡排序前的数据为：");
		bobSort.display(array);
		
		bobSort.bobSort();		
		
		System.out.println("冒泡排序后的数据为：");
		bobSort.display(array);
		
		int[] array1 = { 77, 29, 28, 36, 33, 25, 10 };
		SortTest bobSort1 = new SortTest(array1);
		System.out.println("快速排序前的数据为：");
		bobSort1.display(array1);
		quickSort(array1,0,array1.length-1);
		System.out.println("快速排序后的数据为：");
		bobSort.display(array1);
		
        int[] array2 = { 78, 28, 26, 36, 33, 25, 11 };
		SortTest bobSort2 = new SortTest(array2);
		System.out.println("选择排序前的数据为：");
		bobSort2.display(array2);
	
	    bubbleSort(array2);		
	
		System.out.println("选择排序后的数据为：");
		bobSort2.display(array2);
}
	}

}