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

Posted 2023-05-07

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 参考技术A public static void main(String[] args)
// TODO Auto-generated method stub
List list=new ArrayList();
list.add(1);
list.add(32);
list.add(4);
list.add(22);
for(int i=0;i<list.size();i++)
System.out.println(list.get(i));

for(int i=0;i<list.size();i++)
for(int j=0;j<list.size()-i-1;j++)
String c1=String.valueOf(list.get(j));//把object 类型转换成字符型
String c2=String.valueOf(list.get(j+1));
int v1=Integer.valueOf(c1);//再转换成整形
int v2=Integer.valueOf(c2);
if(v1>v2)
int temp=v2;//设置中间变量，调换两数位置
list.set(j+1, v1);
list.set(j, temp);



for(int i=0;i<list.size();i++)
System.out.println(list.get(i));



参考技术B 经测试，已成功！
import java.util.ArrayList;
public class Test1
public static void main(String[] args)

ArrayList<Integer> list=new ArrayList<Integer>();
list.add(76);
list.add(4);
list.add(786);
list.add(43);
list.add(21);
list.add(432);
list.add(10);
for(int i=0;i<list.size()-1;i++)
for(int j=1;j<list.size()-i;j++)
Integer a;
if((list.get(j-1)).compareTo(list.get(j))>0) //比较两个整数的大小

a=list.get(j-1);
list.set((j-1),list.get(j));
list.set(j,a);



for(Integer s:list)
System.out.println(s.intValue());


本回答被提问者采纳 参考技术C public void printSeqArrayList(List<Long> unit1)

int i, j;
int n = unit1.size()-1;
Boolean exchange; // 交换标志
for (i = 0; i < n; i++) // 最多做n-1趟排序
exchange = false; // 本趟排序开始前，交换标志应为假
for (j = n - 1; j >= i; j--) // 对当前无序区R[i..n]自下向上扫描
if (unit1.get(j) > unit1.get(j + 1))
Long iTemp = new Long(0);
iTemp = unit1.get(j + 1);
unit1.set(j + 1, unit1.get(j));
unit1.set(j, iTemp);
exchange=true;


if (!exchange) // 本趟排序未发生交换，提前终止算法
break;

for (i = 0; i <= n; i++)
System.out.print(unit1.get(i));
System.out.print(",");



附：冒泡排序：（将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。）

java算法面试题：排序都有哪几种方法？请列举。用JAVA实现一个快速排序。选择冒泡快速集合至少4种方法排序

package com.swift;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class QuickSort {
    /*
     * 快速排序
     */
    
    public static void main(String[] args) {
        String[] strVoid = new String[] {"11", "66", "22", "0", "55", "22", "0", "32"};
        QuickSort sort = new QuickSort();
        sort.quickSort(strVoid, 0, strVoid.length - 1);
        for (int i = 0; i < strVoid.length; i++) {
            System.out.println(strVoid[i] + " ");
        }
        //用比较器排序
        List<String> list=new ArrayList<String>();
        for(String str:strVoid) {
            list.add(str);
        }
        Collections.sort(list,new Comparator<String>() {

            @Override
            public int compare(String arg0, String arg1) {
                int num=arg1.compareTo(arg0);
                return num;
            }
            
        });
        for(String str:list) {
            System.out.print(str+" | ");
        }
    }
    
    public void quickSort(String[] strDate, int left, int right) {
        String middle, tempDate;
        int i, j;
        i = left;
        j = right;
        middle = strDate[(i + j) / 2];
        do {
            while (strDate[i].compareTo(middle) < 0 && i < right)
                i++; // 找出左边比中间值大的数
            while (strDate[j].compareTo(middle) > 0 && j > left)
                j--; // 找出右边比中间值小的数
            if (i <= j) { // 将左边大的数和右边小的数进行替换
                tempDate = strDate[i];
                strDate[i] = strDate[j];
                strDate[j] = tempDate;
                i++;
                j--;
            }
        } while (i <= j); // 当两者交错时停止

        if (i < right) {
            quickSort(strDate, i, right);// 从
        }
        if (j > left) {
            quickSort(strDate, left, j);
        }
    }
}