java实现冒泡排序算法

Ⅰ 用java中ArrayList类实现一个冒泡排序

java.util.Collections类中有
sort
public static <T extends Comparable<? super T>> void sort(List<T> list)根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素，e1.compareTo(e2) 不得抛出 ClassCastException）。
此排序方法具有稳定性：不会因调用 sort 方法而对相等的元素进行重新排序。

指定列表必须是可修改的，但不必是大小可调整的。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n log(n) 性能。 此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置处每个元素的列表上进行迭代。这避免了由于试图原地对链接列表进行排序而产生的 n2 log(n) 性能。

参数：
list - 要排序的列表。
抛出：
ClassCastException - 如果列表包含不可相互比较 的元素（例如，字符串和整数）。
UnsupportedOperationException - 如果指定列表的列表迭代器不支持 set 操作。
另请参见：
Comparable

--------------------------------------------------------------------------------

sort
public static <T> void sort(List<T> list,
Comparator<? super T> c)根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较（也就是说，对于列表中的任意 e1 和 e2 元素，c.compare(e1, e2) 不得抛出 ClassCastException）。
此排序被保证是稳定的：不会因调用 sort 而对相等的元素进行重新排序。

排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n log(n) 性能。 指定列表必须是可修改的，但不必是可大小调整的。此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置每个元素的列表上进行迭代。这避免了由于试图原地对链接列表进行排序而产生的 n2 log(n) 性能。

参数：
list - 要排序的列表。
c - 确定列表顺序的比较器。null 值指示应该使用元素的自然顺序。
抛出：
ClassCastException - 如果列表中包含不可使用指定比较器相互比较 的元素。
UnsupportedOperationException - 如果指定列表的列表迭代器不支持 set 操作。
另请参见：
Comparator

Ⅱ java字符串数组怎么排序

Java中对字符串数组进行排序可以通过多种方法实现，这里提供一个简单的冒泡排序算法示例。首先定义一个字符串数组，然后通过比较数组中每个字符串的长度来进行排序。

以下是具体的代码实现：

package Demo;

public class Demo_120901 {

public static void sortStringArray(String[] arrStr) {

String temp;

for (int i = 0; i < arrStr.length; i++) {

for (int j = arrStr.length - 1; j > i; j--) {

if (arrStr[i].length() > arrStr[j].length()) {

temp = arrStr[i];

arrStr[i] = arrStr[j];

arrStr[j] = temp;

}

}

}

}

public static void main(String[] args) {

String[] arrStr = { "yours", "am", "I" };

sortStringArray(arrStr);

for (int i = 0; i < arrStr.length; i++) {

System.out.println(arrStr[i]);

}

}

}

这个示例中，我们首先定义了一个字符串数组arrStr，然后调用sortStringArray方法进行排序。排序的过程是通过比较每个字符串的长度来实现的，如果当前字符串的长度大于下一个字符串的长度，则交换它们的位置。最终，数组中的字符串会按照长度从小到大的顺序排列。

在main方法中，我们通过遍历排序后的数组并打印每个元素来验证排序是否正确。

希望这个例子对你有所帮助。如果你还有其他问题，欢迎继续提问。

Ⅲ Java冒泡排序的原理

冒泡排序是所欲排序算法里最好理解的了。
1、排序算法：
A)比较相邻的元素。如果第一个比第二个大，就交换他们两个。
B)对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
C)针对所有的元素重复以上的步骤，除了最后一个。
D)持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
2、给你一个java的实现代码：
public class BubbleSort{
     public static void main(String[] args){
         int score[] = {67, 69, 75, 87, 89, 90, 99, 100};
         for (int i = 0; i < score.length -1; i++){ //最多做n-1趟排序
             for(int j = 0 ;j < score.length - i - 1; j++){ //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
                 if(score[j] < score[j + 1]){ //把小的值交换到后面
                     int temp = score[j];
                     score[j] = score[j + 1];
                     score[j + 1] = temp;
                 }
             }
             System.out.print("第" + (i + 1) + "次排序结果：");
             for(int a = 0; a < score.length; a++){
                 System.out.print(score[a] + "\t");
             }
             System.out.println("");
         }
             System.out.print("最终排序结果：");
             for(int a = 0; a < score.length; a++){
                 System.out.print(score[a] + "\t");
        }
     }
 }

Ⅳ 冒泡排序java是

冒泡排序算法：

int类型的数组：3 1 6 2 5

算法：取出最大的放在最后，下次就不用比较最后一个了。*/

public class BubbleSort{

public static void main(String[] args){

int[] a = {3,1,6,2,5};

//开始排序

for(int i=a.length-1;i>0;i--){

for(int j=0;j<i;j++){

if(a[j]>a[j+1]){

//交换位置

int temp;

temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

//遍历

for(int i=0;i<a.length;i++){

System.out.println(a[i]);

}

算法原理

冒泡排序算法的运作如下：（从后往前）

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

Ⅳ 用java冒泡排序和递归算法

冒泡排序

（1）基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

（2）用java实现

ublicclassbubbleSort{

publicbubbleSort(){

inta[]={1,54,6,3,78,34,12,45};

inttemp=0;

for(inti=0;i<a.length;i++){

for(intj=i+1;j<a.length;j++){

if(a[i]>a[j]){

temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}

}

for(inti=0;i<a.length;i++)

System.out.println(a[i]);

}

}

递归

递归算法，就是程序的自身调用。表现在一段程序中往往会遇到调用自身的那样一种coding策略，可以利用大道至简的思想，把一个大的复杂的问题层层转换为一个小的和原问题相似的问题来求解的这样一种策略。能看到我们会用很少的语句解决了非常大的问题，所以递归策略的最主要体现就是小的代码量解决了非常复杂的问题。

java代码：

packagecom.cjq.filedown;

publicclassFab{

publicstaticvoidmain(Stringargs[]){
System.out.println(fab(5));
}

privatestaticintfab(intindex){
if(index==1||index==2){
return1;
}else{
returnfab(index-1)+fab(index-2);
}
}
}

Ⅵ java实现几种常见排序算法

下面给你介绍四种常用排序算法：

1、冒泡排序

特点：效率低，实现简单

思想（从小到大排）：每一趟将待排序序列中最大元素移到最后，剩下的为新的待排序序列，重复上述步骤直到排完所有元素。这只是冒泡排序的一种，当然也可以从后往前排。

Ⅶ java中编写冒泡排序算法 bubbleSort(int[]arr)

/**
*des:冒泡排序算法的一般性策略：搜索整个值列，比较相邻元素，如果两者的相对次序不对，
*则交换它们，其结果是最大值“想水泡一样”移动到值列的最后一个位置上，
*这也是它在最终完成排序的值列中合适的位置。
*然后再次搜索值列，将第二大的值移动至倒数第二个位置上，重复该过程，直至将所有元素移动到正确的位置上。
*2014-4-9-zbl
**/
publicclassBubbleSort{

/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Comparable[]a={4,9,23,1,45,27,5,2};
bubbleSort1(a);

Comparable[]b={4,9,23,1,45,27,5,2};
bubbleSort2(b);

int[]c={4,9,23,1,45,27,5,2};
bubbleSort3(c);
}

publicstaticvoidbubbleSort3(int[]data)
{
inttemp;
for(inti=0;i<data.length;i++){
intflag=0;
for(intj=0;j<data.length-i-1;j++){
if(data[j]<data[j+1]){
temp=data[j];
data[j]=data[j+1];
data[j+1]=temp;
flag=1;
}
}
if(flag==0)break;
System.out.print("第"+i+"遍:{");
for(intk=0;k<data.length;k++){
System.out.print(data[k]+",");
}
System.out.println("}");
}
}

publicstaticvoidbubbleSort1(Comparable[]data)
{
Comparabletemp;
for(intposition=data.length-1;position>=0;position--){
intflag=0;
for(intscan=0;scan<position;scan++){
if(data[scan].compareTo(data[scan+1])<0){
temp=data[scan];
data[scan]=data[scan+1];
data[scan+1]=temp;
flag=1;
}
}
if(flag==0){
break;
}
System.out.print("第"+position+"遍:{");
for(inti=0;i<data.length;i++){
System.out.print(data[i]+",");
}
System.out.println("}");
}
}

publicstaticvoidbubbleSort2(Comparable[]data)
{
Comparabletemp;
for(intposition=0;position<data.length-1;position++){
intflag=0;
for(intscan=0;scan<data.length-1-position;scan++){
if(data[scan].compareTo(data[scan+1])<0){
temp=data[scan];
data[scan]=data[scan+1];
data[scan+1]=temp;
flag=1;
}
}
if(flag==0){
break;
}
System.out.print("第"+position+"遍:{");
for(inti=0;i<data.length;i++){
System.out.print(data[i]+",");
}
System.out.println("}");
}
}

}