各种排序算法

选择排序：

第一轮确定nums[0]的值，后面发现比nums[0]小的值，就将这个数和nums[0]进行交换

第一轮确定nums[1]的值，后面发现比nums[1]小的值，就将这个数和nums[1]进行交换

.......

一共需要数组长度-1轮

public class test
{
    //从小到大排序：小的在前面，大的在后面
    public static int[] SelectSort(int[] nums)
    {
        for(int i=0;i<nums.length-1;i++)
        {
            for(int j=i+1;j<nums.length;j++)
            {
                if(nums[j]<nums[i])
                {
                    int temp=nums[i];
                    nums[i]=nums[j];
                    nums[j]=temp;
                }
            }
        }
        return nums;
    }

    public static void main(String[] args)
    {
        int[] nums={1,5,2,4,9,36,5,7,8,3};
        int[] result=SelectSort(nums);
        for(int num:result)
        {
            System.out.println(num);
            //1,2,3,4,5,5,7,8,9,36
        }
    }
}

冒泡排序：

public class test
{
    //从小到大排序：小的在前面，大的在后面
    public static int[] BubbleSort(int[] nums)
    {
        for(int i=0;i<nums.length-1;i++)
        {
            for(int j=0;j<nums.length-1-i;j++)
            {
                //应该小的在前面，大的在后面
                //如果发现前面的大于后面的那就将大的换到后面去
                if(nums[j]>nums[j+1])
                {
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        return nums;
    }

    public static void main(String[] args)
    {
        int[] nums={1,5,2,4,9,36,5,7,8,3};
        int[] result=BubbleSort(nums);
        for(int num:result)
        {
            System.out.println(num);
            //1,2,3,4,5,5,7,8,9,36
        }
    }
}

快速排序：

public void quick_sort(int[] nums,int low,int high)
{
   if(low<high)
   {
       //找到分界点p,也就是划分子数组的位置
       int p=partition(nums,low,high);

       //然后对nums[p]左边的数和右边的数进行排序，递归调用quick_sort函数（本身）
       quick_sort(nums,low,p-1);//左子数组递归调用
       quick_sort(nums,p+1,high);//右子数组递归调用
   }
}
public static int partition(int[] array, int low, int high)
{
        // 取最后一个元素作为中心元素
        int pivot = array[high];

        // 定义指向比中心元素大的指针，首先指向第一个元素
        int pointer = low;
        // 遍历数组中的所有元素，将比中心元素大的放在右边，比中心元素小的放在左边
        for (int i = low; i < high; i++) 
        {
            if (array[i] <= pivot) 
               {
                // 将比中心元素小的元素和指针指向的元素交换位置
                // 如果第一个元素比中心元素小，这里就是自己和自己交换位置，指针和索引都向下一位移动
                // 如果元素比中心元素大，索引向下移动，指针指向这个较大的元素，直到找到比中心元素小的元素，并交换位置，指针向下移动
                int temp = array[i];
                array[i] = array[pointer];
                array[pointer] = temp;
                pointer++;
            }
            System.out.println(Arrays.toString(array));
        }
        // 将中心元素和指针指向的元素交换位置
        int temp = array[pointer ];
        array[pointer] = array[high];
        array[high] = temp;
        return pointer;
    }
}

 很像二叉树的先序遍历

核心其实是那个partition函数

 归并排序

void merge_sort(int[] nums,int low,int high)
{
    int mid=(low+high)/2;
    
    if(low<right)
    {

        //若要对nums[low~high]进行排序，先对nums[low,mid]进行排序，再对nums[mid+1，high]进行排序
        merge_sort(nums,low,mid);
        merge_sort(nums,mid+1,high);

        //合并上面两个有序数组
        merge(nums,low,mid,high);
     }
}
public static void merge(int[] a, int low, int mid, int high)
{
        int[] temp = new int[high - low + 1];
        int i = low;// 左指针
        int j = mid + 1;// 右指针
        int k = 0;
        // 把较小的数先移到新数组中
        while (i <= mid && j <= high)
        {
            if (a[i] < a[j])
            {
                temp[k++] = a[i++];
            }
            else 
            {
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组
        while (i <= mid) 
        {
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while (j <= high)
        {
            temp[k++] = a[j++];
        }
        // 把新数组中的数覆盖nums数组
        for (int k2 = 0; k2 < temp.length; k2++)
        {
            a[k2 + low] = temp[k2];
        }
 }

很像二叉树的后序遍历，其实也是分治算法