java中的接口是类吗
232
2023-08-03
快速排序和分治排序介绍
快速排序让我看了很久,也折磨了我很长时间,因为大体上的思路我是有了,但是写代码时总是出现各种问题,要想把它调试出来对我个人来说还是有一定难度的,而且因为工作和偷懒的原因,导致之前调试不出来的错误放了很久,今天终于出来啦,还是有些小激动的哦,下面来分享一下我的代码并做一点点说明。
要学会快速排序,就必须先要学会分治法,分治的思想是给一串乱序的数字(数字是假设,也可以是其他的对象,当然方法的参数可以自己定义哦,我在这里假设有一个整型的数组吧)然后给他一个中间数,分治法会把这些数字以给他的那个是中间数为分界分为两部分,一部分在中间数的左边,另一部分在右边,以这个数为分界点,两边的数现在还是乱序的,我给他定义的方法如下:
//left是数组的想分治部分的左端点,right是数组分治部分的总端点,如长度为10的数组,我想对前5个整数进行分治,则传0,4即可
public int signalFenZhi(int left,int right){
if(left<0||left>n-1||right<0||right>n-1){
return -1;
}
int temp = test[left];
int j=right;
int i=left;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
for(int m=0;m
System.out.print(test[m]+" ");
}
return i;
}
当然,也可以把那个中间数当参数传进来,现在我只是单纯的以数组的传进来的第left数做为分界数,这只是为了说明。
明白了分治,那么快速排序也就简单了,那就是对已经分为两部分的数再进行分治,依次类推,直到全部的数字都有序为止,代码如下:
public void quickSort(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhi(left, right);
System.out.println(point);
//if(point!=left&&point!=right){
quickSort(left,point-1);
quickSort(point+1,right);
//}
}
}
快速排序的效率在众多的排序算法中是很优秀的,时间复杂度为O(N*log2n),但是如果分治的分界点选的不好的话,时间复杂度将会降到(n的平方),因为如果正好这个数组是有序的,然后我们每次都取传过来的最左端的数,那么效率就会很低,所以要避免发生这种情况,如果检测所有的选项,那么将会很花时间,所以一个折中的办法 ,就是把最左端的数和最右端的数加上一个中间的数,找到他们三个中间的数,以这个为分界值就会变的好一点,在上面方法的基础上,修改以后的代码如下,但是我做完了以后这样的做法不是很好,应该把分界值也当做传给分治的方法会好些,细心的朋友可以自己试一下,我在这里就不试了哈,大体上是一样的哦!
package com.jll;
public class FenZhi {
int[] test;
int n=10;
public FenZhi(){
test = new int[10];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
System.out.print(test[i]+" ");
}
System.out.println();
}
public FenZhi(int n){
if(n>0){
this.n=n;
test = new int[n];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
}
}
}
public int signalFenZhiMajorizationFirst(int left,int right){
if(left<0||left>n-1||right<0||right>n-1||left>=right){
return -1;
}
if(right-left>=2){
int middle = (right+left)/2;
if(test[left]>test[middle]){
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
}
if(test[left]>test[right]){
int temp = test[left];
test[left] = test[right];
test[right] = temp;
}
if(test[middle]>test[right]){
int temp = test[middle];
test[middle] = test[right];
test[right] = temp;
}
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
int j=right-1;
int i=left+1;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
for(int m=0;m
System.out.print(test[m]+" ");
}
return i;
}
当然,也可以把那个中间数当参数传进来,现在我只是单纯的以数组的传进来的第left数做为分界数,这只是为了说明。
明白了分治,那么快速排序也就简单了,那就是对已经分为两部分的数再进行分治,依次类推,直到全部的数字都有序为止,代码如下:
public void quickSort(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhi(left, right);
System.out.println(point);
//if(point!=left&&point!=right){
quickSort(left,point-1);
quickSort(point+1,right);
//}
}
}
快速排序的效率在众多的排序算法中是很优秀的,时间复杂度为O(N*log2n),但是如果分治的分界点选的不好的话,时间复杂度将会降到(n的平方),因为如果正好这个数组是有序的,然后我们每次都取传过来的最左端的数,那么效率就会很低,所以要避免发生这种情况,如果检测所有的选项,那么将会很花时间,所以一个折中的办法 ,就是把最左端的数和最右端的数加上一个中间的数,找到他们三个中间的数,以这个为分界值就会变的好一点,在上面方法的基础上,修改以后的代码如下,但是我做完了以后这样的做法不是很好,应该把分界值也当做传给分治的方法会好些,细心的朋友可以自己试一下,我在这里就不试了哈,大体上是一样的哦!
package com.jll;
public class FenZhi {
int[] test;
int n=10;
public FenZhi(){
test = new int[10];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
System.out.print(test[i]+" ");
}
System.out.println();
}
public FenZhi(int n){
if(n>0){
this.n=n;
test = new int[n];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
}
}
}
public int signalFenZhiMajorizationFirst(int left,int right){
if(left<0||left>n-1||right<0||right>n-1||left>=right){
return -1;
}
if(right-left>=2){
int middle = (right+left)/2;
if(test[left]>test[middle]){
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
}
if(test[left]>test[right]){
int temp = test[left];
test[left] = test[right];
test[right] = temp;
}
if(test[middle]>test[right]){
int temp = test[middle];
test[middle] = test[right];
test[right] = temp;
}
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
int j=right-1;
int i=left+1;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
j--;
}
while(test[i]<=test[left]&&i
i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
for(int m=0;m
System.out.print(test[m]+" ");
}
return i;
}
当然,也可以把那个中间数当参数传进来,现在我只是单纯的以数组的传进来的第left数做为分界数,这只是为了说明。
明白了分治,那么快速排序也就简单了,那就是对已经分为两部分的数再进行分治,依次类推,直到全部的数字都有序为止,代码如下:
public void quickSort(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhi(left, right);
System.out.println(point);
//if(point!=left&&point!=right){
quickSort(left,point-1);
quickSort(point+1,right);
//}
}
}
快速排序的效率在众多的排序算法中是很优秀的,时间复杂度为O(N*log2n),但是如果分治的分界点选的不好的话,时间复杂度将会降到(n的平方),因为如果正好这个数组是有序的,然后我们每次都取传过来的最左端的数,那么效率就会很低,所以要避免发生这种情况,如果检测所有的选项,那么将会很花时间,所以一个折中的办法 ,就是把最左端的数和最右端的数加上一个中间的数,找到他们三个中间的数,以这个为分界值就会变的好一点,在上面方法的基础上,修改以后的代码如下,但是我做完了以后这样的做法不是很好,应该把分界值也当做传给分治的方法会好些,细心的朋友可以自己试一下,我在这里就不试了哈,大体上是一样的哦!
package com.jll;
public class FenZhi {
int[] test;
int n=10;
public FenZhi(){
test = new int[10];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
System.out.print(test[i]+" ");
}
System.out.println();
}
public FenZhi(int n){
if(n>0){
this.n=n;
test = new int[n];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
}
}
}
public int signalFenZhiMajorizationFirst(int left,int right){
if(left<0||left>n-1||right<0||right>n-1||left>=right){
return -1;
}
if(right-left>=2){
int middle = (right+left)/2;
if(test[left]>test[middle]){
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
}
if(test[left]>test[right]){
int temp = test[left];
test[left] = test[right];
test[right] = temp;
}
if(test[middle]>test[right]){
int temp = test[middle];
test[middle] = test[right];
test[right] = temp;
}
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
int j=right-1;
int i=left+1;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
for(int m=0;m
System.out.print(test[m]+" ");
}
return i;
}
当然,也可以把那个中间数当参数传进来,现在我只是单纯的以数组的传进来的第left数做为分界数,这只是为了说明。
明白了分治,那么快速排序也就简单了,那就是对已经分为两部分的数再进行分治,依次类推,直到全部的数字都有序为止,代码如下:
public void quickSort(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhi(left, right);
System.out.println(point);
//if(point!=left&&point!=right){
quickSort(left,point-1);
quickSort(point+1,right);
//}
}
}
快速排序的效率在众多的排序算法中是很优秀的,时间复杂度为O(N*log2n),但是如果分治的分界点选的不好的话,时间复杂度将会降到(n的平方),因为如果正好这个数组是有序的,然后我们每次都取传过来的最左端的数,那么效率就会很低,所以要避免发生这种情况,如果检测所有的选项,那么将会很花时间,所以一个折中的办法 ,就是把最左端的数和最右端的数加上一个中间的数,找到他们三个中间的数,以这个为分界值就会变的好一点,在上面方法的基础上,修改以后的代码如下,但是我做完了以后这样的做法不是很好,应该把分界值也当做传给分治的方法会好些,细心的朋友可以自己试一下,我在这里就不试了哈,大体上是一样的哦!
package com.jll;
public class FenZhi {
int[] test;
int n=10;
public FenZhi(){
test = new int[10];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
System.out.print(test[i]+" ");
}
System.out.println();
}
public FenZhi(int n){
if(n>0){
this.n=n;
test = new int[n];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
}
}
}
public int signalFenZhiMajorizationFirst(int left,int right){
if(left<0||left>n-1||right<0||right>n-1||left>=right){
return -1;
}
if(right-left>=2){
int middle = (right+left)/2;
if(test[left]>test[middle]){
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
}
if(test[left]>test[right]){
int temp = test[left];
test[left] = test[right];
test[right] = temp;
}
if(test[middle]>test[right]){
int temp = test[middle];
test[middle] = test[right];
test[right] = temp;
}
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
int j=right-1;
int i=left+1;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
for(int m=0;m
System.out.print(test[m]+" ");
}
return i;
}
当然,也可以把那个中间数当参数传进来,现在我只是单纯的以数组的传进来的第left数做为分界数,这只是为了说明。
明白了分治,那么快速排序也就简单了,那就是对已经分为两部分的数再进行分治,依次类推,直到全部的数字都有序为止,代码如下:
public void quickSort(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhi(left, right);
System.out.println(point);
//if(point!=left&&point!=right){
quickSort(left,point-1);
quickSort(point+1,right);
//}
}
}
快速排序的效率在众多的排序算法中是很优秀的,时间复杂度为O(N*log2n),但是如果分治的分界点选的不好的话,时间复杂度将会降到(n的平方),因为如果正好这个数组是有序的,然后我们每次都取传过来的最左端的数,那么效率就会很低,所以要避免发生这种情况,如果检测所有的选项,那么将会很花时间,所以一个折中的办法 ,就是把最左端的数和最右端的数加上一个中间的数,找到他们三个中间的数,以这个为分界值就会变的好一点,在上面方法的基础上,修改以后的代码如下,但是我做完了以后这样的做法不是很好,应该把分界值也当做传给分治的方法会好些,细心的朋友可以自己试一下,我在这里就不试了哈,大体上是一样的哦!
package com.jll;
public class FenZhi {
int[] test;
int n=10;
public FenZhi(){
test = new int[10];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
System.out.print(test[i]+" ");
}
System.out.println();
}
public FenZhi(int n){
if(n>0){
this.n=n;
test = new int[n];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
}
}
}
public int signalFenZhiMajorizationFirst(int left,int right){
if(left<0||left>n-1||right<0||right>n-1||left>=right){
return -1;
}
if(right-left>=2){
int middle = (right+left)/2;
if(test[left]>test[middle]){
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
}
if(test[left]>test[right]){
int temp = test[left];
test[left] = test[right];
test[right] = temp;
}
if(test[middle]>test[right]){
int temp = test[middle];
test[middle] = test[right];
test[right] = temp;
}
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
int j=right-1;
int i=left+1;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
System.out.print(test[m]+" ");
}
return i;
}
当然,也可以把那个中间数当参数传进来,现在我只是单纯的以数组的传进来的第left数做为分界数,这只是为了说明。
明白了分治,那么快速排序也就简单了,那就是对已经分为两部分的数再进行分治,依次类推,直到全部的数字都有序为止,代码如下:
public void quickSort(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhi(left, right);
System.out.println(point);
//if(point!=left&&point!=right){
quickSort(left,point-1);
quickSort(point+1,right);
//}
}
}
快速排序的效率在众多的排序算法中是很优秀的,时间复杂度为O(N*log2n),但是如果分治的分界点选的不好的话,时间复杂度将会降到(n的平方),因为如果正好这个数组是有序的,然后我们每次都取传过来的最左端的数,那么效率就会很低,所以要避免发生这种情况,如果检测所有的选项,那么将会很花时间,所以一个折中的办法 ,就是把最左端的数和最右端的数加上一个中间的数,找到他们三个中间的数,以这个为分界值就会变的好一点,在上面方法的基础上,修改以后的代码如下,但是我做完了以后这样的做法不是很好,应该把分界值也当做传给分治的方法会好些,细心的朋友可以自己试一下,我在这里就不试了哈,大体上是一样的哦!
package com.jll;
public class FenZhi {
int[] test;
int n=10;
public FenZhi(){
test = new int[10];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
System.out.print(test[i]+" ");
}
System.out.println();
}
public FenZhi(int n){
if(n>0){
this.n=n;
test = new int[n];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
}
}
}
public int signalFenZhiMajorizationFirst(int left,int right){
if(left<0||left>n-1||right<0||right>n-1||left>=right){
return -1;
}
if(right-left>=2){
int middle = (right+left)/2;
if(test[left]>test[middle]){
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
}
if(test[left]>test[right]){
int temp = test[left];
test[left] = test[right];
test[right] = temp;
}
if(test[middle]>test[right]){
int temp = test[middle];
test[middle] = test[right];
test[right] = temp;
}
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
int j=right-1;
int i=left+1;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
test[i]=(int)(Math.random()*100)+1;
System.out.print(test[i]+" ");
}
System.out.println();
}
public FenZhi(int n){
if(n>0){
this.n=n;
test = new int[n];
for(int i=0;i
test[i]=(int)(Math.random()*100)+1;
}
}
}
public int signalFenZhiMajorizationFirst(int left,int right){
if(left<0||left>n-1||right<0||right>n-1||left>=right){
return -1;
}
if(right-left>=2){
int middle = (right+left)/2;
if(test[left]>test[middle]){
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
}
if(test[left]>test[right]){
int temp = test[left];
test[left] = test[right];
test[right] = temp;
}
if(test[middle]>test[right]){
int temp = test[middle];
test[middle] = test[right];
test[right] = temp;
}
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
int j=right-1;
int i=left+1;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
test[i]=(int)(Math.random()*100)+1;
}
}
}
public int signalFenZhiMajorizationFirst(int left,int right){
if(left<0||left>n-1||right<0||right>n-1||left>=right){
return -1;
}
if(right-left>=2){
int middle = (right+left)/2;
if(test[left]>test[middle]){
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
}
if(test[left]>test[right]){
int temp = test[left];
test[left] = test[right];
test[right] = temp;
}
if(test[middle]>test[right]){
int temp = test[middle];
test[middle] = test[right];
test[right] = temp;
}
int temp = test[middle];
test[middle] = test[left];
test[left] = temp;
int j=right-1;
int i=left+1;
while(i
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
while(test[j]>=test[left]&&i
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
j--;
}
while(test[i]<=test[left]&&i
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
YdJeOTRx i++;
}
if(i
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
temp = test[i];
test[i]=test[j];
test[j]=temp;
}
}
if(i==j){
temp = test[i];
test[i]=test[left];
test[left]=temp;
}
/*if(i==j){
temp = test[middle];
test[middle]=test[i];
test[i]=temp;
}*/
/*for(int m=0;m
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
System.out.print(test[m]+" ");
}*/
return i;
}else {
if(test[right]
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
int temp = test[right];
test[right] = test[left];
test[left] = temp;
}
return right;
}
}
public void quickSortMajorizationFirst(int left,int right){
if(right-left<1){
return ;
}else{
int point = this.signalFenZhiMajorizationFirst(left, right);
System.out.println("the point is:"+point);
quickSortMajorizationFirst(left,point-1);
quickSortMajorizationFirst(point+1,right);
}
}
public static void main(String[] args) {
FenZhi f = new FenZhi();
System.out.println(f.signalFenZhiMajorizationFirst(0, 9));
System.out.println();
f.quickSortMajorizationFirst(0,f.n-1);
//f.quickSort(0,f.test.length-1);
for(int i:f.test){
System.out.print(i+" ");
}
}
}
代码运行如下:
95 40 64 18 78 23 73 84 40
the point is:4
the point is:1
the point is:3
the point is:7
the point is:6
the point is:9
18 23 40 40 64 73 78 84 95
以上就是我学习到的东西,记录一下,以备后面查阅。
版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。
发表评论
暂时没有评论,来抢沙发吧~