零：实现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));
}
}
如果有兴趣了解更多相关内容，欢迎来我的个人网站看看：瞳孔的个人空间
419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
