一、冒泡排序。
1、介绍。
冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。
冒泡排序是稳定排序,不需要额外内存,空间复杂度O(1)。时间复杂度,最佳情况:O(n) 最差情况:O(n^2) 平均情况:O(n^2)。
2、步骤。
(1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。
(2)对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
(3)针对所有的元素重复以上的步骤,除了最后一个。
(4)持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
3、代码。
public static void main(String[] args) {
System.out.println("------开始------");
//生成生成两份一模一样的随机数组,其中一组用系统自带的方法进行排序,到时候进行验证。
final int number = 100000;
int[] sortArray = new int[number];
int[] sortArrayCopy = new int[number];
for (int i = 0; i < sortArray.length; i++) {
sortArray[i] = (int) (Math.random() * number);
}
System.arraycopy(sortArray, 0, sortArrayCopy, 0, number);//数组复制
Arrays.sort(sortArrayCopy);
//开始排序
long startTime = System.currentTimeMillis();
bubbleSort(sortArray);//冒泡排序
System.out.println("花费时间:" + (System.currentTimeMillis() - startTime));
//跟系统排序之后数组进行比较,查看是否排序成功。
if (Arrays.equals(sortArray, sortArrayCopy)) {
System.out.println("排序成功");
} else {
System.out.println("排序失败");
}
System.out.println("------结束------");
}
//冒泡排序 最佳情况:T(n) = O(n) 最差情况:T(n) = O(n2) 平均情况:T(n) = O(n2)
private static void bubbleSort(int[] array) {
for (int i = 1; i < array.length; i++) {//n-1轮 最后一个无序排序
boolean finish = true;
for (int k = 0; k < array.length - i; k++) {//每轮次数都会减少
if (array[k] > array[k + 1]) {
finish = false;
//交换位置
int flag = array[k];
array[k] = array[k + 1];
array[k + 1] = flag;
}
}
if (finish) {//本轮没有产生交换,说明后面的不需要排序了
break;
}
}
}
4、结果。
二、快速排序
1、介绍。
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
快速排序是不稳定排序,不需要额外内存,空间复杂度O(logn)。时间复杂度,最佳情况:O(nlogn) 最差情况:O(n^2) 平均情况:O(nlogn)。
2、步骤。
(1)首先设定一个分界值,通过该分界值将数组分成左右两部分。
(2)将大于或等于分界值的数据集中到数组右边,小于分界值的数据集中到数组的左边。此时,左边部分中各元素都小于或等于分界值,而右边部分中各元素都大于或等于分界值。
(3)然后,左边和右边的数据可以独立排序。对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两部分,同样在左边放置较小值,右边放置较大值。右侧的数组数据也可以做类似处理。
(4)重复上述过程,可以看出,这是一个递归定义。通过递归将左侧部分排好序后,再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后,整个数组的排序也就完成了。
3、代码。
public static void main(String[] args) {
System.out.println("------开始------");
//生成生成两份一模一样的随机数组,其中一组用系统自带的方法进行排序,到时候进行验证。
final int number = 100000;
int[] sortArray = new int[number];
int[] sortArrayCopy = new int[number];
for (int i = 0; i < sortArray.length; i++) {
sortArray[i] = (int) (Math.random() * number);
}
System.arraycopy(sortArray, 0, sortArrayCopy, 0, number);//数组复制
Arrays.sort(sortArrayCopy);
//开始排序
long startTime = System.currentTimeMillis();
quickSort(sortArray, 0, sortArray.length - 1);
System.out.println("花费时间:" + (System.currentTimeMillis() - startTime));
//跟系统排序之后数组进行比较,查看是否排序成功。
if (Arrays.equals(sortArray, sortArrayCopy)) {
System.out.println("排序成功");
} else {
System.out.println("排序失败");
}
System.out.println("------结束------");
}
//快速排序 最佳情况:T(n) = O(nlogn) 最差情况:T(n) = O(n2) 平均情况:T(n) = O(nlogn)
private static void quickSort(int[] array, int start, int end) {
if (start < end) {
int i = start;
int k = end + 1;
int compareValue = array[start];
//跳出循环的条件是i >= k
//如果i==k的话,就说明array[i]==array[k]==compareValue
//如果i==k+1的话,就说明array[i]>=compare>=array[k]
//所以最后array[k]要和compare再互换一下
while (true) {
while (array[++i] < compareValue && i < end) ;
while (array[--k] > compareValue) ;
if (i >= k) {
break;
} else {
int flag=array[i];
array[i]=array[k];
array[k]=flag;
}
}
int flag=array[start];
array[start]=array[k];
array[k]=flag;
//
quickSort(array, start, k - 1);
quickSort(array, k + 1, end);
}
}
4、结果。