数据结构和算法-（比较排序）冒泡排序和快速排序

数据结构和算法-排序算法（比较排序）

比较排序的第一种算法是冒泡排序，比较常见，时间复杂度是n的平方

package suanfa;

public class MySort {
    private void swap(int[] data,int m,int n){
        int temp=data[m];
        data[m]=data[n];
        data[n]=temp;
    }
    public void maopaoSort(int[] data){
        for(int i=0;i<data.length-1;i++){
            for(int k=0;k<data.length-i-1;k++){
                if(data[k]>data[k+1]){
                    swap(data,k,k+1);
                }
            }
        }
    }

    public static void main(String[] args){
        int[] data=new int[]{9,8,7,65,4,3,32,223,1};
        MySort mySort=new MySort();
        mySort.maopaoSort(data);
        for(int value:data){
            System.out.println(value);
        }
    }
}

比较排序的另一种常见算法是快速排序算法，该算法也是计算机中一个知名度比较高的算法了，它的特点就是稳定且快速。

package suanfa;

public class MySort {
    private void swap(int[] data,int m,int n){
        int temp=data[m];
        data[m]=data[n];
        data[n]=temp;
    }
    public void quickSort(int[] data,int start,int end){
        //结束条件
        if(start>=end){
            return;
        }
        int temp_start=start+1;
        int temp_end=end;
        int base=data[start];
        while(temp_start<=temp_end){
            while(temp_start<=temp_end&&data[temp_start]<=base){
                temp_start++;
            }
            while(temp_start<=temp_end&&data[temp_end]>base){
                temp_end--;
            }
            if(temp_start<=temp_end){
                swap(data,temp_end,temp_start);
            }
        }

        swap(data,start,temp_end);


        quickSort(data,start,temp_end-1);
        quickSort(data,temp_start,end);
    }
    public static void main(String[] args){
        int[] data=new int[]{9,8,7,65,4,3,32,223,1};
        MySort mySort=new MySort();
        mySort.quickSort(data,0,data.length-1);
        for(int value:data){
            System.out.println(value);
        }
    }
}

快速排序实现原理：

其实就是每次递归的时候，都将数组进行一次调整，具体表现为将开头元素作为标兵，将数组分为左边为比标兵小的元素集合，右边是比标兵大的元素集合，这样我们就确定了标兵在排完序的有序数组中下标，然后同理，对左右集合再次递归进行排序。