实现Java代码，对23 5 9 56 34 8 1进行冒泡排序

好的，以下是对23 5 9 56 34 8 1进行冒泡排序的Java代码：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {23, 5, 9, 56, 34, 8, 1};
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

输出结果为：

1 5 8 9 23 34 56

相关问题

[34,12,5,56,24,18,9] java 冒泡排序

以下是冒泡排序的 Java 代码：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {34, 12, 5, 56, 24, 18, 9};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

这段代码可以对给定的数组进行冒泡排序，最终输出排序后的结果。

已知数组A[10] = {10, 2,5,7,11,56,78,1,8,12}请分别使用以下排序方法实现对数组的升序排序 • 冒泡排序 • 堆排序 • 插入排序 • 归并排序 • 选择排序 • 桶排序 java

在Java中，我们可以分别用不同的排序算法来对给定的整数数组`A[10] = {10, 2, 5, 7, 11, 56, 78, 1, 8, 12}`进行升序排序：

1. **冒泡排序**:

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

2. **堆排序**:

void heapSort(int[] A) {
   // 将数组构建成最大堆
   buildMaxHeap(A);
   for (int i = A.length - 1; i >= 1; i--) {
       // 将最大值放到末尾，然后调整剩余部分成新的最大堆
       swap(A, 0, i);
       siftDown(A, 0, i - 1);
   }
}

3. **插入排序**:

void insertionSort(int[] A) {
   for (int i = 1; i < A.length; i++) {
       int key = A[i];
       int j = i - 1;
       while (j >= 0 && A[j] > key) {
           A[j + 1] = A[j];
           j--;
       }
       A[j + 1] = key;
   }
}

4. **归并排序**:

void mergeSort(int[] A, int left, int right) {
   if (left < right) {
       int mid = (left + right) / 2;
       mergeSort(A, left, mid);
       mergeSort(A, mid + 1, right);
       merge(A, left, mid, right);
   }
}
// 合并方法...

5. **选择排序**:

void selectionSort(int[] A) {
   for (int i = 0; i < A.length - 1; i++) {
       int minIndex = i;
       for (int j = i + 1; j < A.length; j++) {
           if (A[j] < A[minIndex]) {
               minIndex = j;
           }
       }
       swap(A, i, minIndex);
   }
}

6. **桶排序** (适用于特定数据范围，这里简化了示例):

void bucketSort(int[] A, int maxVal) {
   int[] buckets = new int[maxVal + 1];
   for (int num : A) {
       buckets[num]++;
   }

   int index = 0;
   for (int i = 0; i < buckets.length; i++) {
       while (buckets[i] > 0) {
           A[index++] = i;
           buckets[i]--;
       }
   }
}

记得在实际应用中根据需求选择合适的排序算法，因为它们的时间复杂度各不相同。对于小规模数据，简单的插入排序可能足够；大规模数据时，通常会选择快速排序、归并排序或堆排序。