简单排序之java实现

3种顺序排序方法。简单排序是指时间复杂度为O(n^2)的排序方法。

1）选择排序

将某个特定值有序的放置在最终位置上---外层循环控制最终位置的序号，内层循环从外层循环序号处向后遍历，找到最小值。

2）插入排序

插入排序将某个特定值插入到值列的某个子集中，并重复该过程---外层循环控制要插入的数据（从第二个数到最后一个），内层循环控制前面已排好序的的值后移。

3）冒泡排序

重复比较相邻的两个元素，并在必要的时候交换双方位置。---外层循环控制每次冒泡到达的最终位置，内层循环交换元素

4）其他：这里写的是一个通用的排序算法，不光是对数值排序，可以对对象排序。对象实现Comparable接口，对象就可以参与比较进行排序。

在对对象进行排序的方法中，就可以调用对象的public int compareTo(Object other)方法来比较对象的先后顺序。

一个可以比较先后顺寻的Student类（按照score大小顺序）：

class Student implements Comparable{
    
    private String name;
    private double score;
    
    public Student(String name,double score)
    {
        this.name = name;
        this.score = score;
    }
    
    
    public int compareTo(Object other) {
        int result;
        if(score > ((Student) other).score)
            return 1;
        else if(score < ((Student) other).score)
            return -1;    
        return 0;
    }
    
    
    public String toString(){
        String result = "";
        result = name + "  " + score;
        return result;
    }
    
}

三种排序方法：

package Sort;

 public class SimpleSort {

    
    public static void main(String[] args) {
        
        Student[] student = new Student[7];
        
        student[0] = new Student("aa",90.32);
        student[1] = new Student("bb",70.32);
        student[2] = new Student("cc",85.32);
        student[3] = new Student("dd",64.32);
        student[4] = new Student("ee",91.32);
        student[5] = new Student("ff",74.32);
        student[6] = new Student("gg",79.32);
        
        //selectionSort(student);
         insertSort(student);
        //bubbleSort(student);
         
        for(int i = 0;i < student.length;i++)
            System.out.println(student[i]);
    }
    

    //选择排序
     public static void selectionSort(Comparable[] data){
        
        int min;//用min标识最小元素的下标
         Comparable temp;
        for(int index = 0;index < data.length-1;index ++){//外层循环控制每个位置得到一个最终的值
             min = index;
            for(int scan = index + 1;scan < data.length;scan ++)//内层循环从外层循环位置处向后扫描
                if(data[scan].compareTo(data[min]) < 0)
                    min = scan;//只记录位置！！！！
            //内层for循环完表明一个位置的元素已经选好，交换
            temp = data[min];
            data[min] = data[index];
            data[index] = temp;        
        }                
    }
    
    
    //插入排序
    public static void insertSort(Comparable[] data){
        
        for(int index = 1;index <= data.length-1;index ++)//外层循环控制每个待插入元素
        {
            Comparable key = data[index];//待插入元素
            int position = index;//用position记录插入后的应该占领位置（如果不发生改变，初试值是它自己的位置）
            
            //只记录应该插入的位置，最后一步赋值。！！！
            //while(data[position-1].compareTo(key) > 0 && position > 0)
            while(position > 0 && data[position-1].compareTo(key) > 0)
            {
                data[position] = data[position-1];
                position--;
            }
            data[position] = key;
        }
    }
    
    
    //冒泡排序
    public static void bubbleSort(Comparable[] data){
        
        int position,scan;
        Comparable temp;
        for(position = data.length - 1;position >= 0;position--)//外层循环控制每趟冒泡到的最终位置
        {
            for(scan = 0;scan <= position -1;scan ++)//内层循环不断交换相邻两个元素
            {
                if(data[scan].compareTo(data[scan+1]) > 0)
                {
                    temp = data[scan];
                    data[scan] = data[scan+1];
                    data[scan+1] = temp;
                }
            }
        }
    }
    
}

注意插入排序的内层循环开始写成了这样while(data[position-1].compareTo(key) > 0 && position > 0)，运行起来会导致数组越界的异常。且表达式的判断要把最先决条件放在前面，这一点容易忽略。

运行结果，将数组重新排列了---

dd  64.32

bb  70.32

ff  74.32

gg  79.32

cc  85.32

aa  90.32

ee  91.32