这个蛋疼的随机产生结果的快速排序

 

public static void quickSort2(int[] sourse, int low, int high)
    {   
        if(low>high)
            return;
        int pivot=sourse[low];
        int i=low;
        int j=high;
        if(i<j)
        {
            while(i<j)
            {
                while(sourse[i]<pivot&&i<high)
                {
                    i++;
                }
                while(sourse[j]>pivot&&j>low)
                {
                    j--;
                }
                if(i<j)
                {
                    swap(sourse,i,j);
                }
            }
            if(i>j)
                swap(sourse,low,j);
            
            quickSort2(sourse,low,j-1);
            quickSort2(sourse,j+1,high);
        }
    }
    
    public static void main(String[] args)
    {
        int[] sourse ;
        
        sourse=new int[]{1,23,5,-2,-45,73,9,4,7,12,47,126,0,71,40,51,99};
        quickSort2(sourse, 0, sourse.length-1);
        System.out.println("快速排序:");
        printArray(sourse);// 输出到转后数组的值
        
        
    }

 
以上是自己写的一个快速排序的函数,小测了一下,第一次可以正确执行,第二次CPU就卡在50%,有时候还会报越界错误,真不知道是咋回事?排除了一下是不是因为数组长度太大的问题,但好像与这个没有必然联系,虽然大的时候更容易错。

现在测试,又正常了,悲勒个剧的,难道还有随机性?!
有木有同学可以帮忙挑一下刺儿的,分析一下代码哪里不太合适?

 

ps:谢谢一楼的回复,三楼有正确答案,这个快速排序和书上一般见到的不太一样,自己看吧。

 


问题补充
好,我改改看
问题补充

改好后的,注意判断等号,i<j,i==j时的基准与sourse[i]大小的问题:

 

public static void quickSort2(int[] sourse, int low, int high)
    {   
        //System.out.println("基准值:"+sourse[low]);
        int i=low;
        int j=high;
        if(i<j)
        {   
            int pivot=sourse[low];
            while(i<j)
            {
                
                while(sourse[i]<= pivot&&i<j)
                {
                    i++;
                }
                while(sourse[j]>pivot&&i<j)
                {
                    j--;
                }
                if(i<j)
                {
                    swap(sourse,i,j);
                }

            }
            
            if(pivot<sourse[i])
                 i--;
            
            swap(sourse,low,i);
            
            
            quickSort2(sourse,low,i-1);
            quickSort2(sourse,i+1,high);
        }
    }
public static void main(String[] args)
    {
        int[] sourse ;
        
        sourse = createArray(20);
        //sourse=new int[]{1,23,5,-2,-45,73,9,4,7,12,47,126,0,71,40,51,99,99,40,7,12,126};
        quickSort2(sourse, 0, sourse.length-1);
        System.out.println("快速排序:");
        printArray(sourse);// 输出到转后数组的值
        
        
    }

 
问题补充
其它的我都实现了,就是自己写快速时碰到了问题,还是写代码不够仔细

2个回答

对相等的处理有问题导致了死循环

每次递归的第一次 sourse[i]总是等于pivot 无意义

另外一开始有个if(low>high)的判断

后边为啥还要有if(i<j) 而且还漏掉了=

int[] sourse=new int[]{1,23,5,-2,-45,73,9,4,7,12,47,126,0,71,40,51,99};

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

     for (int i = 0; i < sourse.length; i++) {
        System.out.println(sourse[i]);
    }

这样用冒泡不就行了吗?

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
立即提问
相关内容推荐