java冒泡排序算法代码

冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

以下是一个Java版本的冒泡排序代码：

java复制代码
public class BubbleSort {  
    public static void main(String[] args) {  
        int[] array = {64, 34, 25, 12, 22, 11, 90};  
        bubbleSort(array);  
        System.out.println("Sorted array: ");  
        printArray(array);  
    }  
  
    static void bubbleSort(int[] array) {  
        int n = array.length;  
        for (int i = 0; i < n-1; i++) {  
            for (int j = 0; j < n-i-1; j++) {  
                if (array[j] > array[j+1]) {  
                    // swap array[j+1] and array[j]  
                    int temp = array[j];  
                    array[j] = array[j+1];  
                    array[j+1] = temp;  
                }  
            }  
        }  
    }  
  
    /* Prints the array */  
    static void printArray(int array[]) {  
        int n = array.length;  
        for (int i=0; i<n; ++i)  
            System.out.print(array[i] + " ");  
        System.out.println();  
    }  
}

在这个代码中，我们首先定义了一个要排序的数组。然后，我们使用bubbleSort函数来对这个数组进行排序。这个函数包含两个嵌套的for循环。外部循环负责遍历数组，而内部循环则负责进行实际的元素比较和交换。如果发现当前元素大于下一个元素，那么就交换它们的位置。最后，我们使用printArray函数来打印排序后的数组。

上面的代码是一个典型的冒泡排序实现，它通过比较相邻元素并交换它们（如果它们的顺序错误）来工作。这个过程会重复进行，直到整个数组排序完成。

冒泡排序的时间复杂度在最坏和平均情况下都是O(n^2)，其中n是数组的长度。这是因为，无论输入数组的初始顺序如何，冒泡排序都需要检查每一对相邻的元素。如果数组已经是有序的，那么冒泡排序仍然会执行所有的比较操作，尽管它不会进行任何交换。

冒泡排序的一个优化是添加一个标志位，用于检查在一次完整的遍历中是否发生了交换。如果没有发生交换，那么数组已经是有序的，可以提前结束排序。这个优化可以减少不必要的比较次数，特别是在数组已经部分有序的情况下。

下面是一个优化后的冒泡排序的Java实现：

java复制代码
public class OptimizedBubbleSort {  
    public static void main(String[] args) {  
        int[] array = {64, 34, 25, 12, 22, 11, 90};  
        bubbleSort(array);  
        System.out.println("Sorted array: ");  
        printArray(array);  
    }  
  
    static void bubbleSort(int[] array) {  
        int n = array.length;  
        boolean swapped;  
        for (int i = 0; i < n - 1; i++) {  
            swapped = false;  
            for (int j = 0; j < n - i - 1; j++) {  
                if (array[j] > array[j + 1]) {  
                    // swap array[j+1] and array[j]  
                    int temp = array[j];  
                    array[j] = array[j + 1];  
                    array[j + 1] = temp;  
                    swapped = true;  
                }  
            }  
            // 如果在内层循环中没有发生交换，则数组已经有序  
            if (!swapped) {  
                break;  
            }  
        }  
    }  
  
    static void printArray(int array[]) {  
        int n = array.length;  
        for (int i = 0; i < n; ++i) {  
            System.out.print(array[i] + " ");  
        }  
        System.out.println();  
    }  
}

在这个优化版本中，我们添加了一个swapped布尔变量，它在每次内层循环开始时被设置为false。如果在内层循环中进行了交换，那么swapped就会被设置为true。在每次外层循环结束时，我们检查swapped的值。如果它仍然是false，这意味着在内层循环中没有进行任何交换，因此数组已经是有序的，我们可以提前结束排序。

虽然冒泡排序对于小规模数据或几乎有序的数据集来说可能是可行的，但通常不建议用于大型数据集，因为其效率相对较低。在实际应用中，更高效的排序算法（如快速排序、归并排序、堆排序等）通常会被优先考虑。