java（二）排序

最新推荐文章于 2024-09-14 18:46:05 发布

超俊

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量264

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/s3988477/article/details/53680109

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一冒泡排序（冠亚季一个一个从潜水出来）

/*
                       小人挑战赛
        赛事规则：参赛队伍分别挑战0号位，谁赢谁站在上面荣获冠军荣耀，按此选出亚军和季军，
                  挑战顺序按报名顺序。（冠军5000000G币）
大家好，我是本赛事的解说小G，这场赛事只有3支小人队参赛挑战，现在站在0号位的是原来的冠军得主小1队，第一次较量开始，
首先小3队打败了小1队，站在0号位，然后小2挑战失败，最后一个登场的小4队深藏不漏，使出龙象波若，打败了小3队，站在0号位，获得了冠军！！第二次较量开始站在1号位的小1队和2号位的小2队分别被站在3号位的小3队打败，挑战成功，小3队获得亚军！战况激烈的进行着，现在只剩下2号位的挑战，小2队和小1队比拼，最终小1队落败（还原来的冠军，，是不是请了外援。。。），小2队获得季军！站在2号位。（那小1对只能站在3号位了，毕竟我们只有3支队伍来挑战，已经没有挑战队伍了）
*/
        int a[]={1,3,2,4};
        for (int i = 0; i <a.length-1 ; i++) {//判断条件没有=，就是前包后不包
            // 至于为什么-1，是因为我们是挑战赛，最后一位就是现在的3号位，后面没人挑战了，那我们就不需要在进行一次较量了
            for (int j = i+1; j <a.length ; j++)
            {
                    if(a[i]<a[j]){
                        int temp=a[i];
                        a[i]=a[j];
                        a[j]=temp;
                    }
            }
        }

二选择排序（尚方宝剑版冒泡）

 /*
                     小人不摩擦地板挑战赛
        赛事规则：鉴于挑战赛，谁赢谁站上面太摩擦地板，我们资金紧张特改规则如下：
        参赛队伍分别挑战0号位，比完依旧站在原位，谁赢谁拿尚方宝剑，最终比完谁拿着尚方宝剑谁站在上面荣获冠军荣耀，按此选出亚军和季军，挑战顺序按报名顺序。（冠军5000000G币）
大家好，我依旧是本赛事的解说小G，这场赛事只有3支小人队参赛挑战，现在站在0号位的是原来的冠军得主小1队并拿着尚方宝剑，第一次较量开始，
首先小3队打败了小1队，拿着尚方宝剑，然后小2挑战失败，最后一个登场的小4队深藏不漏，使出破气式，打败了小3队，拿着尚方宝剑并能站在0号位，获得了冠军！！第二次较量开始站在3号位的小1队和2号位的小2队分别被站在1号位的小3队打败，挑战成功，小3队获得亚军！
战况激烈的进行着，现在只剩下2号位的挑战，小2队和小1队比拼，最终小1队落败（主力难道腰腿不好，请假了。。。），
小2队获得季军！站在2号位。（那小1对自从第一次较量后就一直站3号位了，然而我们只有3支队伍来挑战，已经没有挑战队伍了）
         */
        int a[]={1,3,7,2,4};
        for (int i = 0; i <a.length-1 ; i++) 
        {
            int max=i;//尚方宝剑max
            for (int j = i+1; j <a.length ; j++)
            {
                    if(a[max]<a[j])
                     max=j;           
            }
            if(i!=max){
                int temp=a[i];
                a[i]=a[max];
                a[max]=temp;
            }
        }

三插入排序

 /*
                         小人闯关赛
        赛事规则：参赛队伍依次闯前面队伍设的关卡，谁输谁往后走，谁赢谁闯关成功，并占领关卡，看谁能笑到boss关卡。闯关顺序按报名顺序。（冠军5000000G币）
大家好，我依旧是本赛事的解说小G，这场赛事第1个报名的是1号对，他们已经设了一个关卡，但是前面没有关卡，所以他们是boss关卡，
他们闯关成功，紧接着是3号对，他们闯过1号对设的关卡，那么1号对只好往后走，3号对闯关成功，后面是2号对，
他们也闯过1号设的关卡，1号再次往后走，遗憾的是2号对没有闯过3号对设的关卡，只能终止，剩下的4号对，闯过1号对关卡，
1号对再次往后，2号关卡也破，也往后，3号对关卡也抵挡不住被破，也往后走，最终，boss关卡是4号对。
         */
        int a[]={1,3,2,4};
        for(int j=1;j<a.length;j++)
        {
            int i;
            int key = a[j];
            for (i=j-1; i>-1&&a[i]<key; i--)
            {
                    a[i + 1] = a[i]; //将输队伍往后走
            }
            a[i+1]=key;    //赢到底后占领并设立关卡
        }

四折半插入排序（折半加速版插入）

/**
                         小人加速闯关赛
        赛事规则：鉴于参赛队伍依次闯关太慢，参赛队伍用二分查找术（比的快）找到该队伍能闯过的关卡范围，并最终设立关卡，设的关卡的原队伍以及后面输的往后走。闯关顺序按报名顺序。（冠军5000000G币）

*/
        int a[] = {1, 3,2,4};
        int i;
        for (int j = 1; j < a.length; j++)
        {
            int key = a[j];
            int low = 0;
            int high = j-1;

            while (low <= high)
            {
                int mid = (low + high)>>1;
                if (key > a[mid])
                    high = mid - 1;
                else
                    low = mid + 1;
            }
            for (i = j - 1; i > high ; i--)
                a[i+1] = a[i];
            a[i+1] = key;
        }

五希尔排序（分组版插入）

 /*
                        小人组内大闯关
        规则：先分好组知道步长，就可以先定一些组长，组长然后挑出来组员，每个组员依次过前面的关卡，输的退后gap步，输的依次退后，
最终把赢的设成组内boss关卡，再次分组，在设立boss关卡，直至成为一组。
*/
        int a[] = {1,     3,       0,       2,    4};
        for (int gap = a.length / 2; gap > 0; gap /= 2)
        {
            for (int i = 0; i <gap ; i++)
            {
                for (int j = i+gap; j <a.length ; j+=gap)
                {
                    if (a[j]>a[j-gap])
                    {
                        int temp=a[j];
                        int k;
                        for (k = j-gap; k>=0&&a[k] <temp ; k-=gap)
                        {
                            a[k+gap]=a[k];
                        }
                       a[k+gap]=temp;
                    }
                }
            }
        }

六快速排序

/*                            前后挑战赛
        我们这次比赛首先参赛选手要大于1位才能开始比赛，选择0号位为基准值（把0号位的值抬走当标本），
        然后从后开始依次向前比，比基准值大的填充空位，
        然后与此同时，从后向前比，比基准值小的填充空位，当前后相遇停止向前向后，最后比基准值大的在左边，比基准值小的在右边，
        然后递归直到基准值左边没选手或者右边没选手，比赛结束。
        【至于为什么开始从后向前，因为0号位的值已经抬走空出来了，如果你觉着他没空出来，那也不能开始从前比，因为你选的基准值是0号位的值但是你又从前往后比，那等于说从0号位又开始比0号位，那么就像相当于一直等于基准值，一直是等于基准值在替换（填充），真正的其他选手根本没有比基准值没有比较那比赛就不公平（方法就是不正确），我们的等于基准值是因为有和基准值实力相等的选手，比较完后还能向前向后比】
*/
{
        int[] a = {1,3,2,4};
        int start = 0;
        int end = a.length-1;
        sort(a,start,end);
}
    public static void sort(int[] a, int low, int high)
    {
        int start = low;
        int end = high;
        int key = a[low];
        while(end>start)
        {
            while(end>start&&a[end]<=key)
                end--;
                if(a[end]>key)
                {
                    int temp = a[end];
                    a[end] = a[start];
                    a[start] = temp;
                }
            while(end>start&&a[start]>=key)
                start++;
                if(a[start]<key)
                {
                    int temp = a[start];
                    a[start] = a[end];
                    a[end] = temp;
                }
        }
        if(start-1>low) sort(a,low,start-1);
        if(end+1<high) sort(a,end+1,high);
    }

七堆排序（倒着版的选择）

/*先把数组组成堆，然后调整成最小堆，依次选出最小值,交换获取冠亚季*/
    {
        int[] a = {1,3,2,4};
        heapSort(a);
        System.out.println(Arrays.toString(a));
    }
    public static void minHeap(int[] a, int p, int len)
    {
        int temp = a[p];
        for (int min = 2*p+1; min <= len; min+=1)
        {
            if (min +1<= len && a[min] > a[min + 1])
                min++;
            if (temp <= a[min])
                break;
            a[p] = a[min];
            p = min;
            min<<=1;
        }
        a[p] = temp;
    }
    public static void heapSort(int[] a)
    {
        for (int p = a.length / 2 - 1; p >= 0; p--)
        {
            minHeap(a, p, a.length -1);
        }
        for (int i = a.length -1; i > 0; i--)
        {
            int temp = a[i];
            a[i] = a[0];
            a[0] = temp;
            minHeap(a, 0, i-1);
        }
    }