标签：gt temp nums int 希尔 冒泡 排序 left

冒泡：

public int[] bubbleSort(int[] nums){
        for (int i=0;i<nums.length-1;i++){
            for (int j=0;j<nums.length-i-1;j++){
                if (nums[j]>nums[j+1]){
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        return nums;
    }

选择:

public int[] selectSort(int[] nums){
        //选择排序的思想是每次选择一个最小的元素插入到最前面
        for (int i=0;i<nums.length-1;i++){
            int minIndex=i;
            for (int j=i+1;j<nums.length;j++){
                if (nums[j]<nums[minIndex]){
                    minIndex=j;
                }
            }//循环了一次数组，找到了最小的元素
            int temp=nums[i];
            nums[i]=nums[minIndex];
            nums[minIndex]=temp;//把最小的元素和前边的元素进行交换
        }
        return nums;
    }

插入：

for (int i=1;i<nums.length;i++){
            int j=i;
            int temp=nums[i];
            while (j>0&&nums[j-1]>temp){
                nums[j]=nums[j-1];
                j--;
            }
            nums[j]=temp;
        }
        return nums;

快速：

public int[] quickSort(int[] nums,int left,int right){
        if (right-left<=7){
            insertSort(nums,left,right);
            return nums;
        }
        int pIndex=partition(nums,left,right);
        quickSort(nums,left,pIndex-1);
        quickSort(nums,pIndex+1,right);
        return nums;

    }

    private int partition(int[] nums, int left, int right) {
        Random random=new Random();
        int randomIndex=left+random.nextInt(right-left+1);
        swap(nums,left,randomIndex);
        int pivot=nums[left];
        int lt=left+1;
        int gt=right;
        while (true){
            while (lt<=right&&nums[lt]<pivot){
                lt++;
            }
            while (gt>left&&nums[gt]>pivot){
                gt--;
            }
            if (lt>=gt){
                break;
            }
            swap(nums,lt,gt);
            lt++;
            gt--;
        }
        swap(nums,gt,left);
        return gt;

    }

    private void swap(int[] nums, int left, int randomIndex) {
        int temp=nums[left];
        nums[left]=nums[randomIndex];
        nums[randomIndex]=temp;
    }

    private void insertSort(int[] nums, int left, int right) {
        for (int i=left+1;i<=right;i++){
            int j=i;
            int temp=nums[i];
            while (j>0&&nums[j-1]>temp){
                nums[j]=nums[j-1];
                j--;
            }
            nums[j]=temp;
        }
    }

希尔：

public int[] xierSort(int[] nums){
        int len=nums.length;
        int h=1;
        while (3*h+1<len){
            h=3*h+1;
        }
        while (h>=1){
            for (int i=h;i<len;i++){
                int j=i;
                int temp=nums[i];
                while (j>=h&&nums[j-h]>temp){
                    nums[j]=nums[j-h];
                    j-=h;
                }
                nums[j]=temp;
            }
            h/=3;
        }
        return nums;
    }

(68条消息) 十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序_HK的博客-CSDN博客https://blog.csdn.net/m0_37741420/article/details/106981276?spm=1001.2014.3001.5502

该博主的写法十分详细，配有动画演示，通俗易懂 

标签：gt,temp,nums,int,希尔,冒泡,排序,left
来源： https://blog.csdn.net/qq_59539549/article/details/122800074

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。