数据结构与算法----# 一、排序
一、排序
1、比较器Comparable
Java中的比较器（排序） - 情陌人灬已不在 - 博客园 (cnblogs.com)
Comparable和Comparator接口都是为了对类进行比较，众所周知，诸如Integer，double等基本数据类型，java可以对他们进行比较，而对于类的比较，需要人工定义比较用到的字段比较逻辑。可以把Comparable理解为内部比较器，而Comparator是外部比较器。
实体类student：
public class Student implements Comparable<Student> {
private String name;
private int age;
//有参、无参、get、set、tostring
@Override
public int compareTo(Student o) {
return this.age-o.age;
}
}
测试类：
public class TestCompare {
public static void main(String[] args) {
Student s1 = new Student("马云", 40);
Student s2 = new Student("马化腾", 41);
Comparable max = getMax(s1, s2);
System.out.println(max);
}
public static Comparable getMax(Comparable c1, Comparable c2){
int res=c1.compareTo(c2);
if (res>=0){
return c1;
}else {
return c2;
}
}
}
2、冒泡排序
冒泡排序优缺点
- 优点：比较简单，空间复杂度较低，是稳定的
- 缺点：时间复杂度太高，效率较低
java代码：
/*
冒泡排序算法：由小到大 分为三个方法较之前更加 封装解耦
最坏时间复杂度：逆序情况下O(n^2)
适用场景：元素较少的情况下可选择适用
优点：安全稳定排序，比较两个相同的数据时顺序不变
* */
public class BubbleSort {
/*
* 对数组a中的元素排序 Integer 类型 implements Comparable<Integer>,因此可以采用比较器
* */
public static void bubbleSort(Integer[] a){
for (int i=0;i<a.length-1;i++){ //依次循环，每次比较出最大的一个数
for (int j=0;j<a.length-1-i;j++){ //比较剩下的数
if (greater(a[j],a[j+1]))
exch(a,j,j+1);
}
//System.out.println("第"+(i+1)+"趟："+ Arrays.toString(a)); //测试每趟下来的结果
}
}
/*
数组元素i和j交换位置方法
* */
public static void exch(Comparable[] a,int i,int j){
Comparable temp;
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
/*
* 比较a,b两个元素的大小方法
* */
public static boolean greater(Comparable a,Comparable b){
return a.compareTo(b)>0;
}
}
测试类：
public class BubbleSortTest {
public static void main(String[] args) {
Integer[] arr= new Integer[]{3, 5, 1, 4, 2};
bubbleSort(arr); //给数组排序
System.out.println(Arrays.toString(arr));
}
}
3、选择排序
java代码：
/*
* 选择排序算法：升序 分为三个方法较之前更加 封装解耦
时间复杂度：O(n^2)
适用场景：元素较少的情况下可选择适用
优点：不稳定排序，比较两个相同的数据时顺序可能发生改变
* */
public class SelectSort {
public static void Sort(Integer[] arr){
//最小元素下标
int minIndex;
for (int i=0;i<arr.length-1;i++){ //进行N次交换
minIndex=i; //默认最小元素下标为i
for (int j=i+1;j< arr.length;j++){ //从i+1比较到最后一个元素
if (greater(arr[minIndex],arr[j])){
minIndex=j; //被较小元素下标替换
}
}
exch(arr,i,minIndex); //交换i与最小元素
}
}
/*
数组元素i和j交换位置方法
* */
public static void exch(Comparable[] a,int i,int j){
Comparable temp;
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
/*
* 比较a,b两个元素的大小方法
* */
public static boolean greater(Comparable a,Comparable b){
return a.compareTo(b)>0;
}
}
测试类：
public class SelectTest {
public static void main(String[] args) {
Integer[] arr=new Integer[]{4,3,5,6,1,2};
Sort(arr);
System.out.println(Arrays.toString(arr));
}
}
选择与冒泡比较：
图片失效！
4、直接插入和希尔排序
/*
直接插入排序 最坏时间复杂度：O(n^2) 最好：O(n)
* */
public static class Insertion {
//升序
public static void insertionSort(Integer[] wait){
for (int i=1;i<wait.length;i++){ //插入次数为待排序数组wait[].length-1 从索引1开始，0不用比较
for (int j=i;j>0;j--){ //j>0 防止 j-1 导致 ArrayIndexOutOfBoundsException
if (greater(wait[j-1],wait[j])){ // 前 > 后时交换
exch(wait,j-1,j);
}else {
break;
}
}
}
}
}
/*希尔排序的排序思路是：
把较大的数据集合分割成若干个小组（逻辑上分组），
然后对每一个小组分别进行插入排序，
此时，插入排序所作用的数据量比较小（每一个小组），插入的效率比较高
*/
public static class ShellSort{
public static void shellSort(Integer[] a){
int N=a.length; int h=1;
//1、确定h初始值
while (h<N/2){
h=2*h+1;
}
//2、排序
while (h>0){
//2.1、找到待插入的元素
for (int i=h;i<N;i++){
//2.3、把待插入元素放入有序序列中
for (int j=i;j>h;j-=h){
//2.2、待插入元素为a[j] 比较a[j]与a[j-h]
if (greater(j-h,j)){
//2.3、若j-h较大则交换
exch(a,j-h,j);
}else {
break;
}
}
}
h=h/2;
}
}
}
