常见排序算法的分析与实现

本文仅实现了冒泡排序、选择排序，插入排序和快速排序，仅供参考学习。

性能体验：冒泡—>选择—>插入—>快排。

冒泡排序：

	/**
	 * 冒泡排序—最简单的排序 
	 * 稳定性：稳定 
	 * 时间复杂度：O(n^2)
	 */
	public void BubbleSort(int a[]) {
		// 用于交换两个数的值
		int temp;

		for (int i = 0; i < a.length - 1; i++) {
			for (int j = 0; j < a.length - 1 - i; j++) {
				// 前后两个数比较，大的数后移（向后冒泡）
				if (a[j] > a[j + 1]) {
					temp = a[j + 1];
					a[j + 1] = a[j];
					a[j] = temp;
				}
			}
			// 大的数向后移动
		}
		// 结束
	}

选择排序：

        /**
	 * 升序 
	 * 选择排序—找出最小数，然后交换当前最小数 
	 * 稳定性：不稳定 
	 * 时间复杂度：O(n^2)
	 */
	public void SelectSort(int[] a) {
		int temp = 0;
		int min;
		int index;

		for (int i = 0; i < a.length - 1; i++) {
			min = a[i];
			index = i;
			for (int j = i + 1; j < a.length; j++) {
				if (a[j] < min) {
					// 记录最小元素的位置
					index = j;
					// 更新最小值
					min = a[j];
				}
			}
			if (i != index) {
				// 找到最小值,交换位置
				temp = a[index];
				a[index] = a[i];
				a[i] = temp;
			}
		}
	}

 

插入排序

/**
	 * 升序 
	 * 直接插入排序 
	 * 稳定性:稳定 
	 * 时间复杂度：O(n^2)
	 */

	public void InsertSort(int[] a) {
		int insertVal;
		int index;

		for (int i = 1; i < a.length; i++) {

			insertVal = a[i];
			index = i - 1;
			while (index >= 0 && insertVal < a[index]) {
				a[index + 1] = a[index];
				index--;
			}
			a[index + 1] = insertVal;
		}
	}

 

        /**
	 * 快速排序 
	 * 稳定性:不稳定,多个相同的值的相对位置(前后位置)也许会在算法结束时产生变动 
	 * 时间复杂度：O(nlogn)
	 * 空间复杂度：O(nlogn)
	 */	
	public void quicksort(int[] a, int left, int right) {
        int dp;
        if (left < right) {
            dp = partition(a, left, right);
            quicksort(a, left, dp - 1);
            quicksort(a, dp + 1, right);
        }
    }
	
	/**
	 * @return  返回中轴位置
	 */
    public int partition(int[] a, int left, int right) {
        int pivot = a[left];
        while (left < right) {
            while (left < right && a[right] >= pivot)
                right--;
            if (left < right)
                a[left++] = a[right];
            while (left < right && a[left] <= pivot)
                left++;
            if (left < right)
                a[right--] = a[left];
        }
        a[left] = pivot;
        return left;
    }

 

测试程序入口

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SortMain s = new SortMain();
		int size = 40000000;
		// 数组必须马上分配空间，否则编译器报错
		int[] a = new int[size];
		for (int i = 0; i < a.length; i++) {
			// 取0~100随机数
			int r = (int) (Math.random() * 10000);
			a[i] = r;
//			System.out.print(r + "  ");
		}
		System.out.println();
		
		//开始时间
		Calendar car = Calendar.getInstance();
		System.out.println(car.getTime());

		// 冒泡
//		 s.BubbleSort(a);

		// 选择
//		 s.SelectSort(a);

//		// 插入
//		s.InsertSort(a);
		
		//快排
		s.quicksort(a,0, size-1);
		
		//排序结束时间
		car = Calendar.getInstance();
		System.out.println(car.getTime());

		//数组长度较小时打印数组，较大时注释掉避免死机
//		for (int i = 0; i < a.length; i++) {
//			System.out.print(a[i] + "  ");
//		}

	}

 

各排序算法小结