【数据结构与算法】第三章：简单排序
3.1、Comparable接口介绍
Java提供了一个接口Comparable，就是用来定义排序规则的
案例：
- 定义一个学生类Student，有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则
- 定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)
完成测试
public class ComparableTest {
public static void main(String[] args) {
Student student1 = new Student();
student1.setUserName("张三");
student1.setAge(18);
Student student2 = new Student();
student2.setUserName("李四");
student2.setAge(20);
System.out.println(compare(student1, student2));
}
private static Comparable compare(Comparable c1,Comparable c2){
int i = c1.compareTo(c2);
if(i>=0){
return c1;
}else {
return c2;
}
}
}
class Student implements Comparable<Student> {
public String userName;
public int age;
public String getUserName() {
return userName;
}
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();
}
}
Student{userName='李四', age=20}
3.2、冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法
案例：
-
需求： 排序前：{4,5,6,3,2,1} 排序后：
-
排序原理
- 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置
- 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值
- API设计
- 代码实现
public class BubbleSort {
public static void main(String[] args) {
Integer[] c = {4, 5, 6, 3, 2, 1};
System.out.println("排序前：" + Arrays.toString(c));
sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
/**
* 排序
*
* @param c
*/
public static void sort(Comparable[] c) {
// 冒泡次数
for (int i = c.length - 1; i > 0; i--) {
// 每次冒泡中比较次数
for (int j = 0; j < i; j++) {
// 比较当前j与j+1的值
if (greater(c[j], c[j + 1])) {
exch(c, j, j + 1);
}
}
}
}
/**
* 比较 c1 是否大于 c2
*
* @param c1
* @param c2
* @return
*/
private static boolean greater(Comparable c1, Comparable c2) {
return c1.compareTo(c2) > 0;
}
/**
* 交换数组 c 中 i 和 j 位置的元素
*
* @param c
* @param i
* @param j
*/
private static void exch(Comparable[] c, int i, int j) {
Comparable temp = c[i];
c[i] = c[j];
c[j] = temp;
}
}
排序前：[4, 5, 6, 3, 2, 1]
排序后：[1, 2, 3, 4, 5, 6]
-
时间复杂度分析
-
冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。
-
在最坏情况下，也就是假如要排序的元素为{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) (平方阶)
-
3.3、选择排序
选择排序是一种更加简单直观的排序方法
案例：
-
需求： 排序前：{4,6,8,7,9,2,10,1} 排序后：
-
排序原理
-
每一次遍历的过程中，都假定第一个索引处的元素是最 小值，和其他索引处的值依次进行比较，如果当前索引处 的值大于其他某个索引处的值，则假定其他某个索引出 的值为最小值，最后可以找到最小值所在的索引
-
交换第一个索引处和最小值所在的索引处的值
-
- API设计
- 代码实现
public class SelectionSort {
public static void main(String[] args) {
Integer[] c = {4,6,8,7,9,2,10,1};
System.out.println("排序前：" + Arrays.toString(c));
sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
/**
* 排序
* @param c
*/
public static void sort(Comparable[] c) {
// 选择趟数
for (int i = 0; i < c.length - 1; i++) {
// 定义一个变量，记录最小元素所在的素引；默认为参与排序的第一个元素的所在索引
int minindex = i;
// 每一趟中的比较次数，找出这一趟中参与排序的最小元素j
for (int j = i + 1; j < c.length; j++) {
// 比较minindex与j位置的值
if (greater(c[minindex], c[j])) {
minindex = j;
}
}
// 交换索引位置为i、minindex的值
exch(c, i, minindex);
}
}
/**
* 比较 c1 是否大于 c2
*
* @param c1
* @param c2
* @return
*/
private static boolean greater(Comparable c1, Comparable c2) {
return c1.compareTo(c2) > 0;
}
/**
* 交换数组 c 中 i 和 j 位置的元素
*
* @param c
* @param i
* @param j
*/
private static void exch(Comparable[] c, int i, int j) {
Comparable temp = c[i];
c[i] = c[j];
c[j] = temp;
}
}
排序前：[4, 6, 8, 7, 9, 2, 10, 1]
排序后：[1, 2, 4, 6, 7, 8, 9, 10]
-
时间复杂度分析
-
选择排序使用了 双层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.4、插入排序
插入排序（Insertion sort）是一种简单直观且 稳定的 排序算法
插入排序的工作方式非常像人们排序一手扑克牌一样。
开始时，我们的左手为空并且桌子上的牌面朝下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较，如下图所示：
案例：
-
需求：排序前：{4,3,2,10,12,1,5,6} 排序后：
-
排序原理：
-
把所有的元素分为两组，已经排序的和未排序的
-
找到未排序的组中的第一个元素，向已经排序的组中进行插入
-
倒序遍历已经排序的元素，依次和待插入的元素进行比较， 直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位
-
- API设计
- 代码实现
public class InsertionSort {
public static void main(String[] args) {
Integer[] c = {4,3,2,10,12,1,5,6};
System.out.println("排序前：" + Arrays.toString(c));
sort(c);
System.out.println("排序后：" + Arrays.toString(c));
}
/**
* 排序
*
* @param c
*/
public static void sort(Comparable[] c) {
// 未排序元素
for(int i=1;i<c.length;i++){
// 取出未排序元素中的第一个，依次与已排序元素比较(倒序)，找出合适的位置插入
for(int j=i;j>0;j--){
if(greater(c[j-1],c[j])){
// 前面大于后面，交换位置
exch(c,j-1,j);
}else{
// 前面不大于后面，退出内循环
break;
}
}
}
}
/**
* 比较 c1 是否大于 c2
*
* @param c1
* @param c2
* @return
*/
private static boolean greater(Comparable c1, Comparable c2) {
return c1.compareTo(c2) > 0;
}
/**
* 交换数组 c 中 i 和 j 位置的元素
*
* @param c
* @param i
* @param j
*/
private static void exch(Comparable[] c, int i, int j) {
Comparable temp = c[i];
c[i] = c[j];
c[j] = temp;
}
}
排序前：[4, 3, 2, 10, 12, 1, 5, 6]
排序后：[1, 2, 3, 4, 5, 6, 10, 12]
- 时间复杂度分析
- 插入排序使用了双层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) （平方阶）
本文来自博客园，作者：土味儿，转载请注明原文链接：https://www.cnblogs.com/tuwer/articles/15270568.html
浙公网安备 33010602011771号