java-归并排序与快排的效率比较

java-归并排序与快排的效率比较

用java完整地实现了归并排序和快速排序，然后测试两个算法在数组长度由100增加到一亿过程中的时间复杂度，比较两个算法效率。

归并排序

public class MergeSort {

	public int[] A;

	public MergeSort(int[] array) {
		this.A = array.clone();
		sort(0, array.length - 1);
	}

	public void sort(int low, int high) {

		if (low < high) {
			int mid = (low + high) / 2;
			sort(low, mid);
			sort(mid + 1, high);
			merge(low, mid, high);
		}
	}

	public void merge(int low, int mid, int high) {

		// 声明新的数组，临时储存归并结果
		int[] B = new int[high - low + 1];
		int h = low;
		int i = 0;
		int j = mid + 1;

		while (h <= mid && j <= high) {
			if (A[h] <= A[j]) {
				B[i] = A[h];
				h++;
			} else {
				B[i] = A[j];
				j++;
			}
			i++;
		}

		// 等号很重要
		if (h <= mid) {
			for (int k = h; k <= mid; k++) {
				B[i] = A[k];
				i++;
			}
		} else {
			for (int k = j; k <= high; k++) {
				B[i] = A[k];
				i++;
			}
		}

		for (int k = low; k < high; k++) {
			A[k] = B[k - low];
		}

	}
}

快速排序

public class QuickSort {

	public int[] A;

	public QuickSort(int[] array) {
		this.A = array.clone();
		sort(0, array.length - 2);
	}

	public void sort(int p, int q) {
		if (p < q) {
			int j = partition(p, q);
			sort(p, j - 1);
			sort(j + 1, q);
		}
	}

	public int partition(int p, int q) {
		int j = q;
		int axis = A[p];
		int i = p;

		while (true) {

			//从左往右找到第一个比axis大的数字
			while (A[i] <= axis) {
				i++;
			};

			//从右往左找到第一个小于等于axis的数字
			while (A[j] > axis) {
				j--;
			};

			if (i < j) {
				swap(i, j);
			} else {
				break;
			}
		}

		A[p] = A[j];
		A[j] = axis;

		return j;
	}

	public void swap(int i, int j) {
		int tmp = A[i];
		A[i] = A[j];
		A[j] = tmp;
	}

}

效率比较

新建TimeCounter类，用来实例化两个算法类，并测试两个算法。size指定测试数组的长度，maximum 指定生成的数组中元素的最大值，注意：由于快排的数组最后一个数字要求最大，因此实际的数组长度是是size+1

import java.util.Arrays;
import java.util.Random;

public class TimeCounter {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int size = 101;
		int maximum = 100000;
		int[] array = new int[size];

		for (int i = 0; i < array.length - 1; i++) {
			array[i] = new Random().nextInt(maximum);
		}

		//快排数组中的最后一个数字最大
		array[size - 1] = maximum + 1;
 
		long QuickStart = System.currentTimeMillis();
		new QuickSort(array);
		long QuickEnd = System.currentTimeMillis();

		long MergeStart = System.currentTimeMillis();
		MergeSort mergesort=new MergeSort(array);
		long MergeEnd = System.currentTimeMillis();

//		 System.out.println(Arrays.toString(array));
//		 System.out.println(Arrays.toString(mergesort.A));

		System.out.println("quick sort: " + (QuickEnd - QuickStart));
		System.out.println("merge sort: " + (MergeEnd - MergeStart));

	}
}

python

public class Solution {

    void sort(int[] a, int low, int high)
    {
        if(low < high)
        {
            int mid = partition(a, low, high);
            sort(a, low, mid -1);
            sort(a, mid + 1, high);
        }
    }
 
    int partition(int[] a, int low, int high)
    {
        int pivot = a[low];
        int i = low;
        int j = high;

        while(true)
        {
            while(i <= high && a[i] <= pivot)
            {
                i++;
            }
            while(j >= low && a[j] > pivot)
            {
                j--;
            }
            if(i < j)
            {
                int tmp = a[i];
                a[i] = a[j];
                a[j] = tmp;
            }
            else
            {
                break;
            }
        }
        a[low] = a[j];
        a[j] = pivot;
        return j;
    }

    public void sortIntegers(int[] a) {
        sort(a, 0, a.length -1);
    }
}

在同一台计算机上，修改size的值，运行TimeCounter.java，得到两个算法在不同数组长度下的执行时间：

数组长度	快速排序（运行时间/毫秒）	归并排序（运行时间/毫秒）
100	0	0
1000	1	1
10000	1	3
100000	14	14
1000000	79	120
10000000	982	1186
100000000	55733	12328

结果

我们知道快排和归并的理论上的时间复杂性如下表：

算法	最坏时间复杂性	平均时间复杂性
快速排序	n^2	n*log(n)
归并排序	n*log(n)	n*log(n)

1. 在数组长度小于一千万的时候，如下图，快速排序的速度要略微快于归并排序，可能是因为归并需要额外的数组开销（比如声明临时local数组用来储存排序结果），这些操作让归并算法在小规模数据的并不占优势。

2. 但是，当数据量达到亿级时，归并的速度开始超过快速排序了，如下图，因为归并排序比快排要稳定，所以在数据量大的时候，快排容易达到O(n^2)的时间复杂度，当然这里是指未改进的快排算法。

个人博客：https://pengzhaoqing.github.io/posts/