快速排序 选择排序 冒泡排序 插入排序 数据结构 java代码实现

package demoFour;

/*
*@author:张文波
*@time2020年4月9日下午5:01:28
*/
//一些排序算法
public class AllSort
{

    public static void main(String[] args)
    {
        int nums[] =
        { 1, 6, 5, 8, 4, 7 };
        // BubbleSort(nums); 冒泡排序
        // selectSort(nums); 选择排序
        //insertSort(nums);  插入排序
        fastSort(nums, 0, nums.length-1);//快速排序
        PrintTT(nums); 
    }

//快速排序：分而治之，每次选择一个数组中的第一个位置为其确定最终位置，使他左边的都小于他，右边的都大于他
    public static void fastSort(int nums[], int low, int high)
    {
        // 首先因为是递归，所以方法入口必须判断是否满足推出递归的条件
        if (low > high)
        {
            return;// 会出现这种情况，当当递归的数组元素只有一个了，也就是high=low，然后因为是递归，所以仍要调用递归函数
                    // fastSort（int nums[],int low,int high）,此时high就会小于low，
        }
        int l = low, r = high, temp = nums[low];
        while (l < r)
        {
            // 值得注意的是必须先从右边开始，找到一个比temp = nums[low];因为每次我们都选择nums[low]作为待排序
            while (l < r && nums[r] >= temp)
            {
                r--;
            }
            while (l < r && nums[l] <= temp)
            {
                // 必须带上=号，因为必须找到大于的值
                // 从左到右找到一个大于它的位置
                l++;
            }
            if (l < r)
            {
                int t = nums[l];
                nums[l] = nums[r];
                nums[r] = t;
            }

        }
        
        //while循环结束后那么就是l==r此时就是l或者r就是low所在的位置，因为比他小的都在它左边，比他大的都在他右边
        //交换下标为low和l（或者r因为l==r都一样）的数，
        nums[low]=nums[l];
        nums[l]=temp;
        //递归调用
        fastSort(nums, low, l-1);
        fastSort(nums, l+1, high);
    }

//插入排序 思路：每次从未排序的数组中选择一个数，然后再已经排好序的数组中从后往前进行比较，找到位置，并且插入
    public static void insertSort(int nums[])
    {
        for (int i = 1; i < nums.length; i++)
        {
            for (int j = i; j > 0; j--)
            {
                if (nums[j] < nums[j - 1])
                {
                    int temp = nums[j];
                    nums[j] = nums[j - 1];
                    nums[j - 1] = temp;
                }
            }
        }
    }

//选择排序 思路：两层循环，第一次每层都要确定一个最大值的数组下标，然后和最后leng-i-1下标交换
    public static void selectSort(int nums[])
    {

        for (int i = 0; i < nums.length; i++)
        {
            int max = 0; // 放到第一层循环中每次循环都清零
            for (int j = 1; j < nums.length - i; j++)
            {
                max = (nums[j] > nums[j - 1]) ? j : max;
            }
            int temp = nums[nums.length - i - 1];
            nums[nums.length - i - 1] = nums[max];
            nums[max] = temp;
        }
    }

//冒泡排序  思路；两层循环 每次比较相邻两个下标的值，如果左边大于右边那么交换位置，那么第一层循环
    // 每次都可以那一个最大的值放到leng-i位置上。
    public static void BubbleSort(int nums[])
    {
        for (int i = 0; i < nums.length; i++)
        {
            for (int j = 1; j < nums.length - i; j++)
            {// 为什么从1开始，因为如果从0那么你每次都需要比较j，和j+1
                // 那么到最后你会发现最后会超出数组边界
                if (nums[j] < nums[j - 1])
                {
                    int temp = nums[j];
                    nums[j] = nums[j - 1];
                    nums[j - 1] = temp;
                }
            }
        }
    }

// 输出数组内容
    public static void PrintTT(int nums[])
    {
        for (int i : nums)
        {
            System.out.print(i + " ");
        }
    }
}