零:实现Comparable接口比较大小
Java提供了Comparable接口用来定义排序规则,只要求实现一个compareTo方法
此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序 ,类的 compareTo 方法被称为它的自然比较方法 。实现此接口的对象列表(和数组)可以通过 Collections.sort (和 Arrays.sort )进行自动排序。实现此接口的对象可以用作有序映射表中的键或有序集合中的元素,无需指定比较器。 强烈推荐(虽然不是必需的)使自然排序与 equals 一致。所谓与equals一致是指对于类 C 的每一个 e1 和 e2 来说,当且仅当 (e1.compareTo((Object)e2) == 0) 与e1.equals((Object)e2) 具有相同的布尔值时,类 C 的自然排序才叫做与 equals 一致 。
比较大小实现类:
package algorithm.sort;
public class Student implements Comparable<Student>{
private String username;
private int age;
public void setUsername(String username) {
this.username = username;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"username='" + username + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
return this.getAge() - o.getAge();
}
}
测试类:
package algorithm.test.sort;
import algorithm.sort.Student;
public class TestComparable {
public static void main(String[] args) {
Student s1 = new Student();
s1.setUsername("张三");
s1.setAge(18);
Student s2 = new Student();
s1.setUsername("李四");
s1.setAge(28);
Comparable max = getMax(s1, s2);
System.out.println(max);
}
public static Comparable getMax(Comparable c1, Comparable c2) {
int result = c1.compareTo(c2);
if(result >= 0) {
return c1;
} else {
return c2;
}
}
}
一:冒泡排序
基本思想:对待排序数组,从第一个数开始,依次比较相邻元素的值,若逆序则交换,每一轮比较都能让一个元素移动到正确位置,故总共需要进行数组长度 - 1轮排序,每轮的两两比较次数较于上一轮减少一次
时间复杂度:冒泡排序使用了双层for循环,其中内层循环的循环体是真正完成排序的代码,所以,我们分析冒泡排序的时间复杂度,主要分析一下内层循环体的执行次数即可。
在最坏情况下,也就是假如要排序的元素为{6,5,4,3,2,1,7}逆序,
那么:
元素比较的次数为:
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
元素交换的次数为:
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
总执行次数为:
(N^2/2-N/2)+(N^2/2-N/2)=N^2-N;
按照大O推导法则,保留函数中的最高阶项那么最终冒泡排序
的时间复杂度为O(N^2)。
最好情况时(原数组已经有序)则为达到O(n)
稳定性:在相邻元素进行比较时,若相等则不发生交换,故冒泡排序是稳定的
适用场景:冒泡排序思路简单,代码也简单,特别适合小数据的排序。但是,由于算法复杂度较高,在数据量大的时候不适合使用。
代码实现:
package algorithm.sort;
public class Bubble {
// 排序
public static <E> E[] sort(Comparable<E>[] a) {
for (int i = 0; i < a.length - 1; i++) {
int flag = 0; // 是否交换的标记,如果为零,则说明数组已有序,无需继续循环
for (int j = 0; j < a.length - i - 1; j++) {
if (greater(a[j], a[j + 1])) {
swap(a, j, j + 1);
flag = 1;
}
}
if (flag == 0) break;
}
return (E[]) a;
}
// 比较大小
private static <T> boolean greater(Comparable<T> v, Comparable<T> w) {
return v.compareTo((T) w) > 0; // compareTo源码规定参数为T类型
}
// 交换位置
private static <E> void swap(Comparable<E>[] a, int i, int j) {
Comparable<E> t;
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
测试代码:
package algorithm.test.sort;
import algorithm.sort.Bubble;
import org.junit.Test;
import java.util.Arrays;
public class TestBubble {
@Test
public void test() {
Integer[] result = Bubble.sort(new Integer[]{4, 5, 6, 3, 9, 1, 7}); // Integer实现了Comparable接口
System.out.println(Arrays.toString(result));
}
}
二:选择排序
基本思想:第一轮从待排序数组中选出最小的元素,与数组第一个元素交换,第二轮从待排序数组剩下的后n - 1个元素中,选出最小的元素与数组第二个元素交换,以此类推,共进行数组长度 - 1轮,即可得到一个有序数组
时间复杂度:选择排序使用了双层for循环,其中外层循环完成了数据交换,内层循环完成了数据比较,所以我们分别统计数据交换次数和数据比较次数:
数据比较次数:(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
数据交换次数:N-1
时间复杂度:N^2/2-N/2+(N-1)=N^2/2+N/2-1;
根据大O推导法则,保留最高阶项,去除常数因子,时间复杂度为O(N^2);
稳定性:在元素两两交换时,可能会导致相同元素的相对位置发生变化,如数组3 3 5 2 1,第一轮交换中,3与1交换,数组变为1 3 5 2 3,显然两个3的相对位置发生变化,故选择排序是不稳定的
适用场景:选择排序实现也比较简单,并且由于在各种情况下复杂度波动小,因此一般是优于冒泡排序的。在所有的完全交换排序中,选择排序也是比较不错的一种算法。但是,由于固有的O(n2)复杂度,选择排序在海量数据面前显得力不从心。因此,它适用于简单数据排序。
代码实现:
package algorithm.sort;
import java.util.Arrays;
public class Select {
public static <E> E[] sort(Comparable<E>[] a) {
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int j = 1; j < a.length - i; j++) {
if (greater(a[min], a[i + j])) {
min = i + j;
}
}
if (i != min) swap(a, i, min);
}
return (E[]) a;
}
private static <T> boolean greater(Comparable<T> v, Comparable<T> w) {
return v.compareTo((T) w) > 0;
}
private static <E> void swap(Comparable<E>[] a, int i, int j) {
Comparable<E> t = a[i];
a[i] = a[j];
a[j] = t;
}
}
测试代码:
package algorithm.test.sort;
import algorithm.sort.Select;
import org.junit.Test;
import java.util.Arrays;
public class TestSelect {
@Test
public void test() {
Integer[] result = Select.sort(new Integer[]{4, 5, 6, 3, 9, 1, 7});
System.out.println(Arrays.toString(result));
}
}
三:插入排序
基本思想:将待排序数组看作一个有序表和一个无序表,最开始有序表中只包含一个元素,也就是数组第一个元素,剩下的元素组成无序表,每一轮将无序表的第一个元素插入到有序表的正确位置,使得有序表仍然有序,总共需要进行数组长度 - 1轮排序。
时间复杂度:插入排序使用了双层for循环,其中内层循环的循环体是真正完成排序的代码,所以,我们分析插入排序的时间复杂度,主要分析一下内层循环体的执行次数即可。最坏情况,也就是待排序的数组元素为{12,10,6,5,4,3,2,1},那么:
比较的次数为:
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
交换的次数为:
(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
总执行次数为:
(N^2/2-N/2)+(N^2/2-N/2)=N^2-N;
按照大O推导法则,保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2).
稳定性:由于每轮交换前进行的两两比较,是从后向前进行的,也就是说相同元素中位置靠后的,在插入后仍然位置靠后,相对位置不变,故插入排序是稳定的
适用场景:插入排序由于O( n2 )的复杂度,在数组较大的时候不适用。但是,在数据比较少的时候,是一个不错的选择,一般做为快速排序的扩充。例如,在STL的sort算法和stdlib的qsort算法中,都将插入排序作为快速排序的补充,用于少量元素的排序。又如,在JDK 7 java.util.Arrays所用的sort方法的实现中,当待排数组长度小于47时,会使用插入排序。
代码实现:
package algorithm.sort;
public class Insert {
public static <E> E[] sort(Comparable<E>[] a) {
for (int i = 1; i < a.length; i++) {
// 在比较中交换,在正确位置停止交换
for (int j = i; j >= 1 && greater(a[j - 1], a[j]); j--) swap(a, j, j - 1);
}
return (E[]) a;
}
private static <T> boolean greater(Comparable<T> v, Comparable<T> w) {
return v.compareTo((T) w) > 0;
}
private static <E> void swap(Comparable<E>[] a, int i, int j) {
Comparable<E> t = a[i];
a[i] = a[j];
a[j] = t;
}
}
测试代码:
package algorithm.test.sort;
import algorithm.sort.Select;
import org.junit.Test;
import java.util.Arrays;
public class TestInsert {
@Test
public void test() {
Integer[] result = Select.sort(new Integer[]{4, 5, 6, 3, 9, 1, 7});
System.out.println(Arrays.toString(result));
}
}
四:希尔排序
在希尔排序出现之前,计算机界普遍存在“排序算法不可能突破O(n2)”的观点。希尔排序是第一个突破O(n2)的排序算法,它是简单插入排序的改进版。希尔排序的提出,主要基于以下两点:
- 插入排序算法在数组基本有序的情况下,可以近似达到O(n)复杂度,效率极高。
- 但插入排序每次只能将数据移动一位,在数组较大且基本无序的情况下性能会迅速恶化。
基本思想:对待排序数组按照步长进行分组,对每组进行插入排序。步长逐渐缩短,直到所有元素都在同一组,此时进行最后一次插入排序,实现数组有序。步长较长时,每组元素较少,排序效率较高,步长较短时,每组元素已经很接近有序,排序仍然有较高的效率
时间复杂度:希尔排序的时间复杂度与步长选取有关,大小为O(n^s),1 < s < 2
希尔排序的增量数列可以任取,需要的唯一条件是最后一个一定为1(因为要保证按1有序)。但是,不同的数列选取会对算法的性能造成极大的影响。切记:增量序列中每两个元素最好不要出现1以外的公因子!(很显然,按4有序的数列再去按2排序意义并不大)。
下面是一些常见的增量序列。
- 第一种增量是最初Donald Shell提出的增量,即折半降低直到1。据研究,使用希尔增量,其时间复杂度还是O(n2)。
- 第二种增量Hibbard:{1, 3, …, 2k-1}。该增量序列的时间复杂度大约是O(n1.5)。
- 第三种增量Sedgewick增量:(1, 5, 19, 41, 109,…),其生成序列或者是94i - 92i + 1或者是4i - 3*2i + 1。
稳定性:我们都知道插入排序是稳定算法。但是,Shell排序是一个多次插入的过程。在一次插入中我们能确保不移动相同元素的顺序,但在多次的插入中,相同元素完全有可能在不同的插入轮次被移动,最后稳定性被破坏,因此,Shell排序不是一个稳定的算法。
适用场景:Shell排序虽然快,但是毕竟是插入排序,其数量级并没有后起之秀–快速排序O(n㏒n)快。在大量数据面前,Shell排序不是一个好的算法。但是,中小型规模的数据完全可以使用它。
代码实现:
package algorithm.sort;
public class Shell {
public static <E> E[] sort(Comparable<E>[] a) {
// 确定增长量h的初始值
int h = 5;
// 排序
while(h >= 1) {
for (int i = 0; i + h < a.length; i++) {
for (int j = 0; i + j + h < a.length; j += h)
if (greater(a[i + j], a[i + j + h])) swap(a, i + j, i + j + h);
}
h /= 2;
}
return (E[]) a;
}
private static <T> boolean greater(Comparable<T> v, Comparable<T> w) {
return v.compareTo((T) w) > 0;
}
private static <E> void swap(Comparable<E>[] a, int i, int j) {
Comparable<E> t = a[i];
a[i] = a[j];
a[j] = t;
}
}
测试代码:
package algorithm.test.sort;
import algorithm.sort.Shell;
import org.junit.Test;
import java.util.Arrays;
public class TestShell {
@Test
public void test() {
Integer[] result = Shell.sort(new Integer[]{9, 1, 2, 5, 7, 4, 8, 6, 3, 5});
System.out.println(Arrays.toString(result));
}
}
五:归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。
基本思想:对待排序数组进行折半拆分,直到数组不可再分,对拆分得到的子数组两两有序合并,直到全部子数组合成一个完整数组,每两个有序子数组进行合并时,方法类似于两个有序表合成一个有序表,即分别使用两个指针指向两个数组的第一个元素,分别向后遍历,并将较小的元素存入临时数组中
时间复杂度:O(nlogn)
稳定性:因为我们在遇到相等的数据的时候必然是按顺序“抄写”到辅助数组上的,所以,归并排序同样是稳定算法。
适用场景:归并排序在数据量比较大的时候也有较为出色的表现(效率上),但是,其空间复杂度O(n)使得在数据量特别大的时候(例如,1千万数据)几乎不可接受。而且,考虑到有的机器内存本身就比较小,因此,采用归并排序一定要注意。
代码实现:
package algorithm;
import java.util.Arrays;
public class Merge {
private static Comparable[] assist;
public static void sort(Comparable[] a) {
assist = new Comparable[a.length];
int low = 0;
int high = a.length - 1;
sort(a, low, high);
}
private static void sort(Comparable[] a, int low, int high) {
if (high <= low) return;
int mid = low + (high - low) / 2;
sort(a, low, mid);
sort(a, mid + 1, high);
merge(a, low, mid, high);
}
private static void merge(Comparable[] a, int low, int mid, int high) {
int i = low;
int p1 = low;
int p2 = mid + 1;
while (p1 <= mid && p2 <= high) {
if (less(a[p1], a[p2])) assist[i++] = a[p1++];
else assist[i++] = a[p2++];
}
while(p1 <= mid) assist[i++] = a[p1++];
while(p2 <= high) assist[i++] = a[p2++];
for (int index = low; index <= high; index++) a[index] = assist[index];
}
private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
}
class Test {
public static void main(String[] args) throws Exception {
Integer[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
Merge.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
六:快速排序
基本思想:快速排序是对冒泡排序的一种改进。它是通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
排序原理:
- 首先设定一个分界值,通过该分界值将数组分成左右两部分
- 将大于或等于分界值的数据放到到数组右边,小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值,而右边部分中各元素都大于或等于分界值;
- 然后,左边和右边的数据可以独立排序。对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两部分,同样在左边放置较小值,右边放置较大值。右侧的数组数据也可以做类似处理。
- 重复上述过程,可以看出,这是一个递归定义。通过递归将左侧部分排好序后,再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后,整个数组的排序也就完成了。
时间复杂度:O(n)
稳定性:快速排序并不是稳定的。这是因为我们无法保证相等的数据按顺序被扫描到和按顺序存放。
适用场景:快速排序在大多数情况下都是适用的,尤其在数据量大的时候性能优越性更加明显。但是在必要的时候,需要考虑下优化以提高其在最坏情况下的性能。
代码实现:
package algorithm;
import java.util.Arrays;
public class Quick {
public static void sort(Comparable[] a) {
int low = 0;
int high = a.length - 1;
sort(a, low, high);
}
private static void sort(Comparable[] a, int low, int high) {
if (high <= low) return;
int partition = partition(a, low, high);
sort(a, low,partition - 1);
sort(a,partition + 1, high);
}
public static int partition(Comparable[] a, int low, int high) {
Comparable key = a[low];
int left = low;
int right = high + 1;
while(true){
while(less(key, a[--right])){
if (right == low) break;
}
while(less(a[++left], key)){
if (left == high) break;
}
if (left >= right) break;
else swap(a, left, right);
}
swap(a, low, right);
return right;
}
private static void swap(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
}
class Test2 {
public static void main(String[] args) throws Exception {
Integer[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 8};
Quick.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
如果有兴趣了解更多相关内容,欢迎来我的个人网站看看:瞳孔的个人空间