常用数据结构算法：简单排序方式（冒泡，选择，插入）

　　所谓的简单排序方式就是时间复杂度相对于一些高级排序方式较高的排序方式（简单排序的时间复杂度一般都是 O(N2)），但是其实现简单，并且思路比较清晰，在本文当中，简单介绍三种简单排序方式，包括经典的冒泡排序、选择排序、还有插入排序。

　　首先介绍插入排序，其实现思路是：默认当前待排序的位置的左边是已经排序好的数组，然后将当前位置与左边排序好的数组元素逐一比较，找到当前待排序的元素所应在的位置，该位置之后的所有元素右移一位，之后向下再便利，可能单看文字描述不宜理解，那么看下图应该就可以很直观的理解该算法的思路了：

class InsertSort
{
    private int[] input;
    private int length;
    
    public InsertSort(int[] input) {
        this.input=input;
        length=input.length;
    }
    
    public void Sort()
    {
        int out,in;
        //遍历出来第一个数字的所有数字
        for(out=1;out<length;out++)
        {
            //提取要被插入的数字
            int temp=input[out];
            in=out;
            //寻找位置，并且找到位置之前，所有元素都比它大，所以都要右移一位
            //该处大小于号控制其升序降序
            while(in>0&&input[in-1]>temp)
            {
                input[in]=input[in-1];
                in--;        
            }
            //找到位置，直接赋值
            input[in]=temp;
        }
    }
}

　　之后介绍的是选择排序，选择排序的方式与插入排序有所不同，以升序规则讲解，在确认从左至右第一个位置的时候，遍历一次数组，找出数组当中最小的元素，然后放入第一个位置，之后确认第二个位置，再次遍历一次数组（除了第一个位置不需要遍历，因为第一个位置的数字一定是数组当中最小的），再找到最小的元素，放入第二个位置，循环下去，如图所示：

class SelectInsort
{
    private int[] input;
    private int length;
    
    public SelectInsort(int[] input) {
        this.input=input;
        length=input.length;
    }
    
    //内部方法，交换数组当中的两个位置内的元素值
    private void swap(int a,int b)
    {
        int temp;
        temp=input[a];
        input[a]=input[b];
        input[b]=temp;
    }
    
    //找到数组当中i之后的最大值
    private int findTheMax(int i)
    {
        int result=0;
        int temp=Integer.MIN_VALUE;
        for(;i<length;i++)
        {
            if(input[i]>temp)
            {
                result=i;
                temp=input[i];
            }
        }
        return result;
    }
    
    //找到数组当中i之后的最小值
    private int findTheMin(int i)
    {
        int result=0;
        int temp=Integer.MAX_VALUE;
        for(;i<length;i++)
        {
            if(input[i]<temp)
            {
                result=i;
                temp=input[i];
            }
        }
        return result;
    }
    
    //选择排序
    public void Sort()
    {
        for(int i=0;i<length;i++)
        {
            swap(i,findTheMin(i));
        }
    }
}

　　最后介绍的是简单排序当中的经典算法，冒泡排序，其实现思路也是最简单的，两重循环，里层循环确保每次遍历完成后，能将最小值（或最大值）遍历到数组的最后一个位置，外层循环控制遍历的位置，思路如图：

class BubbleSort
{
    private int[] input;
    private int length;
    public BubbleSort(int[] input) {
        this.input=input;
        length=input.length;
    }
    
    //交换数组当中的两个位置的值
    private void swap(int a,int b)
    {
        int temp;
        temp=input[a];
        input[a]=input[b];
        input[b]=temp;
    }
    
    //双重循环，注意下标的确定，读者要思考清楚为什么下标是这么设定的
    public void Sort()
    {
        for(int i=0;i<length;i++)
        {
            for(int j=0;j<length-i-1;j++)
            {
                //大小于号确定升序降序
                if(input[j]<input[j+1])swap(j, j+1);
            }
        }
    }
}

　　至此，三种简单的排序方式的思路和实现方式都已经介绍完毕，之后还会介绍几种高级排序方式，如快排，归并排序等排序方式。