sheng的学习笔记-选择排序

选择排序定义

1.概念

选择排序（Selection sort）是最简单直观的一种算法，基本思想为每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止

• 运行时间和输入无关

• 数据移动少

算法特点

1.时间复杂度

选择排序算法的每一轮要遍历所有元素，共遍历n-1轮，所以时间复杂度是O(N^2)

2.空间复杂度

选择排序算法排序过程中需要一个临时变量存储最小元素（最大元素），所需要的额外空间为1，因此空间复杂度为O(1)

3.稳定性

选择排序算法是一种不稳定排序算法，当出现相同元素的时候有可能会改变相同元素的顺序

算法描述：

①、在待排序的一组数据中，选出最小（最大）的一个数与第一个位置的数交换。

②、然后在剩下的数中，再找最小（最大）的数与第二个位置的数交换位置。

③、依次类推直到第 n-1 个元素与第 n 个元素交换位置，选择排序结束。

代码

注：下面的代码摘自《算法》中，做了少量修改

基础类，弄个子类集成sort函数就行

package algorithm.sort;

import java.util.Random;

// 基础类，其他子类继承这个类
public abstract class AbstractSort {
    public static void main(String[] args) {
        AbstractSort sortService = new SelectionSort();
        DataInfo[] a = new DataInfo[20];
        for (int i = 0; i < a.length; i++) {
            a[i] = new DataInfo();
            a[i].setNumber(new Random().nextInt(100));
        }
        sortService.show(a);
        sortService.sort(a);
        assert sortService.isSorted(a);
        sortService.show(a);
    }

    public abstract void sort(Comparable[] a);

    protected boolean less(Comparable a, Comparable b) {
        return a.compareTo(b) < 0;
    }

    protected void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    protected void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }

    // 看是否已经是有序的了
    public boolean isSorted(Comparable[] a) {
        for (int i = 1; i < a.length; i++) {
            if (less(a[i], a[i - 1])) {
                return false;
            }
        }
        return true;
    }
}

数据结构（自定义对象，实现compareTo用于排序）

package algorithm.sort;

public class DataInfo implements Comparable<DataInfo> {
    private long number;

    public long getNumber() {
        return number;
    }

    public void setNumber(long number) {
        this.number = number;
    }

    @Override
    public int compareTo(DataInfo o) {
        if (this.number > o.number) {
            return 1;
        }
        if (this.number < o.number) {
            return -1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "DataInfo{" +
                "number=" + number +
                '}';
    }
}

实现的算法

package algorithm.sort;

// 选择排序
public class SelectionSort extends AbstractSort {

    @Override
    public void sort(Comparable[] a) {
        int len = a.length;
        for (int i = 0; i < len; i++) {
            int minIndex = i;
            //找到最小的值对应的索引
            for (int j = i + 1; j < len; j++) {
                if (less(a[j], a[minIndex])) {
                    minIndex = j;
                }
            }
            //在a数组中，交换索引为i和minIndex的值
            exch(a, i, minIndex);
        }
    }
}