java之最简单和最复杂的排序算法

1、冒泡排序：

当前元素和next元素对比大小

逻辑单元：

• swap
• 对比次数(i)：每个元素都要对比，直到最后一个不需要(size-1)
• 一轮次数：每一轮都会降低一轮对比的次数(i-j-1)

ok 看看代码

public class BubleSort {
    public static int[] bubbleSort(int[] arr){
        int size = arr.length;
        for(int i=0;i<size-1;i++){
            for(int j=0;j<size-1-i;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
        return arr;
    }


    public static void swap(int arr [],int num1,int num2){
        int temp;
        temp=arr[num1];
        arr[num1]=arr[num2];
        arr[num2]=temp;
    }
    @Test
    public void sort(){
        int arr[]={1,2,3,8,4,5};
        System.out.println(bubbleSort(arr));
    }
}

2、快速排序

1. 找基准值
2. 比大小
3. 交换
4. 继续查找
5. 交换基准值到合适的位置
6. 重复

快排，排序中据说是最快的(不然为啥叫做快排呢?)，Arrays.sort()内部实现之一，快排是核心，同时也是分治法得一种

0.测试数据

int[]a={7,5,3,2,9,10,8,4,6,1};

1.找基准值

基准值的问题，大家就先不要纠结，众说云云，选择哪个那个是最快的，这里我就假设第一个为基准值

这里基准值就是a[0]=7;

2.比大小

这里呢，来两个指针i(数组开始index)和j(结束index)

对比基准值

如果是从小到大呢,则是期望对比结果左边则是比基准值大的，右边比基准值小

如果是从大到小则相反

为什么是左边要找基准值大的呢，因为要交换

知道了期望结果，就知道怎么做了

3.交换

指针i,j都开始进行靠拢，如果i指针指向的值比基准值小，而j指针执行的值比基准值大，则交换

4.继续查找

接着i，j继续靠拢，如果出现符合交换条件的就进行交换，同时也要符合i<j的条件

5.交换基准值到合适的位置

知道i,j指针相遇，则交换基准值

6.重复

接着用分治法的思路，把左边和右边分开，继续进行以上过程(递归),最后得到的数组就是从小到大的顺序

show 代码

    public void quickSort(int[]arr,int left,int right)
    {
        if(left>right)
            return;
        int pivot=arr[left];
        int i=left;
        int j=right;
        while(i<j){
            while(arr[i]<pivot&&i<j)
                i++;
            while(arr[j]>pivot&&i<j)
                j--;
            if(i<j){
                swap(arr,i,j);
            }
        }
        arr[left]=arr[i];
        arr[i]=pivot;
        quickSort(arr,left,i-1);
        quickSort(arr,i+1,right);
    }