数据结构-排序算法（一）

冒泡排序

• 冒泡排序法:每次比较相连的两个数据，查看是否满足大小关系，如果不满足，则选择互换，重复n次，排序完成
• 图解实例：
  
• 代码实例：

public class BubbleSort {
    public int [] sort(){
        int[] a={5,1,3,2,4};
        int lastExchangeIndex=0;
        int sortBorder=a.length-1;
        for (int i=0;i<a.length;i++){
            boolean isBreakFlag=true;
            for(int j=0;j<sortBorder;j++){
                if(a[j]>a[j+1]){
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    isBreakFlag=false;
                    lastExchangeIndex=j;//最后的交换位置
                }
            }
            sortBorder=lastExchangeIndex;
            if(isBreakFlag){
                //表示后续都是已经排序好的
                break;
            }

        }
        return a;
    }
    public static void main(String [] args){
        BubbleSort sort=new BubbleSort();
        int [] a=sort.sort();
        for(int i:a){
            System.out.print(i+" ");
        }
    }
}

• 优化点：1.加了变量lastExchangeIndex ，用于表示已经排序好的边界，2. 添加isBreakFlag变量，当没有交换发生时，则表示已经排序好了，不需要再循环操作
• 时间复杂度：
  最快情况: 数组无序情况下，一开始需要进行n-1比较，互换，第二轮进行 n-2比较互换。。。。(n-1)+(n-2)+…=n(n-1)/2 去掉常数 粗略的时间复杂度o(n^2)
  若原数组本身就是有序的（这是最好情况），仅需n-1次比较就可完成, 时间复杂度为o(n)

插入排序

• 插入排序：将数组分为两个区间，分为已经排序和未排序区间，从未排序区间选择一个元素，在合适的位置插入该元素，不断重复该操作，直到全部元素排序完成
• 图解实例：
  
• 代码：

/**
 * TODO
 *  插入排序
 *  最好 (o（n）)
 *  最坏（o（n^2）)
 * @author zhangp
 * @date 2019-04-23 10:06
 */
public class InsertSort {

    public int[] sort(){
        int[] a={5,1,2,4,6,8,3};
        int i=1;
        //
        for (;i<a.length;i++){
            int value=a[i];
            int j=i-1;
            //内循环是有序的
            for (;j>=0;j--){
                if(a[j]>value){
                    //移动数据
                    a[j+1]=a[j];
                }else {
                    break;
                }
                //插入数据
                a[j]=value;
            }
        }
    return a;
    }

    public static void main(String[] args){
        InsertSort insertSort=new InsertSort();

        int [] a=insertSort.sort();
        for(int i:a){
            System.out.print(i);
        }
    }
}

• 时间复杂度：
  • 时间复杂度分析：
    最坏情况下： 数组为逆序状态，插入比较，整个时间为1+2+…+n-1= N^2 / 2 舍去最高项系数，其时间复杂度为 O(N^2)
    最好情况下：数组为有序状态，每次插入有序数组最后所以时间复杂度为n

选择排序

• 选择排序：选择排序分为已排序区间和未排序区间，每次从未排序区间选择最小元素，放到已排序区间末尾
• 图解实例：
  
  • 代码实例：

/**
 * TODO
 * 最好 (o（n^2）)
 * 最坏(o（n^2）)
 * 选择排序
 * @author zhangp
 * @date 2019-04-23 14:10
 */
public class SelectionSort {

    public int[] sort(){
        int[] a={5,1,2,4,6,8,3,2,1,2,3,3,2,5,67,58,8};
        for(int i=0;i<a.length;i++){
            int j=i;
            int minIndex=j;
            for(;j<a.length-1;j++){
                //找出最小值
                if(a[minIndex]>a[j+1]){
                    minIndex=j+1;
                }
            }
            //交换
            if(i!=j){
                int tmp=a[i];
                a[i]=a[minIndex];
                a[minIndex]=tmp;
            }
        }
        return a;
    }

    public static void main(String[] args){
        SelectionSort sort=new SelectionSort();

        int [] a=sort.sort();
        for(int i:a){
            System.out.print(i+"  ");
        }
    }
}

• 时间复杂度分析：
  最坏情况下： 数组为逆序状态，寻找最小值需n-1次，整个时间为n-1+n-2+…+1= N^2 / 2 舍去最高项系数，其时间复杂度为 O(N^2)
  最好情况下：数组为有序状态，但是寻找最小值，还是要遍历数组n-1+n-2+…+1次，所以时间复杂度和最坏情况下是一样