BubbleSort实施
我试图实现冒泡排序，但我不确定它是否正确。 如果你可以看一看，如果它是一个泡沫排序，可以更好地完成，请不要害羞。 这是代码：
package Exercises; import java.util.*; public class BubbleSort_6_18 { public static void main(String[] args) { Random generator = new Random(); int[] list = new int[11]; for(int i=0; i<list.length; i++) { list[i] = generator.nextInt(10); } System.out.println("Original Random array: "); printArray(list); bubbleSort(list); System.out.println("\nAfter bubble sort: "); printArray(list); } public static void bubbleSort(int[] list) { for(int i=0; i<list.length; i++) { for(int j=i + 1; j list[j]) { int temp = list[i]; list[i] = list[j]; list[j] = temp; } } } } public static void printArray(int[] list) { for(int i=0; i<list.length; i++) { System.out.print(list[i] + ", "); } } } 这是冒泡排序的calssical实现，似乎没问题。 有几个优化可以完成，但总体思路是一样的。 以下是一些想法：
- 如果在内循环中没有执行交换时存在外循环的迭代，则中断，不再继续使用
- 在外循环的每次迭代中交换内部循环的方向 – 从左到右进行一次，然后从右到左进行一次（这有助于避免元素缓慢向右端移动）。
private static int [] bublesort (int[] list , int length) { boolean swap = true; int temp; while(swap){ swap = false; for(int i = 0;i < list.length-1; i++){ if(list[i] > list[i+1]){ temp = list[i]; list[i] = list[i+1]; list[i+1] = temp; swap = true; } } } return list; }
Mohammod Hossain的实现相当不错，但是他做了很多不必要的迭代，遗憾的是他没有接受我的编辑，我不能评论由于声誉点，所以这里是它应该是这样的：
public void sort(int[] array) { int temp = 0; boolean swap = true; int range = array.length - 1; while (swap) { swap = false; for (int i = 0; i < range; i++) { if (array[i] > array[i + 1]) { temp = array[i]; array[i] = array[i + 1]; array[i + 1] = temp; swap = true; } } range--; } }
{ System.out.println("The Elments Before Sorting:"); for(i=0;i(a[j+1])) { temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } System.out.println("The Elements After Sorting:"); for(i=0;i
我认为你通过查看你的代码得到了冒泡排序的想法：
冒泡排序通常如下所示：假设aNumber是一些随机数：
for (int i = 0; i < aNumber; i++) { for(int j = 0; j < aNumber; j++) //Doing something with i and j, usually running it as a loop for 2D array //array[i][j] will give you a complete sort. }
泡泡排序如何迭代遍历数组的每个可能的点。 ixj times这个问题的不利之处在于，它会对排序的东西进行平方。 效率不高，但它确实以最简单的方式完成工作。
简答：这绝对不是冒泡排序。 它是选择排序的变体（比通常已知的变体效率更低）。
查看它们在VisuAlgo上的工作方式可能会有所帮助
为什么这不是泡沫排序？
因为您遍历数组并将每个元素与其右侧的每个元素进行比较。 如果正确的元素较小，则交换。 因此，在第一个外循环迭代结束时，您将在最左侧位置具有最小元素，并且在最坏的情况下您已经完成了N个交换（考虑反向排序的数组）。
如果你考虑一下，你真的不需要做所有这些交换，你可以在找到交换之后在右边搜索最小值。 这只是选择排序的想法，您选择剩余未排序元素的最小值并将其放在正确的位置。
泡泡排序怎么样呢？
在冒泡排序中，您始终比较两个相邻的元素，并将较大的元素向右气泡。 在外循环的第一次迭代结束时，您将在最右侧位置具有最大元素。 当数组已经排序时， swap标志会停止外部循环。
void bubbleSort(int[] arr) { boolean swap = true; for(int i = arr.length - 1; i > 0 && swap; i--) { swap = false; // for the unsorted part of the array, bubble the largest element to the right. for (int j = 0; j < i; j++) { if (arr[j] > arr[j+1]) { // swap int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; swap = true; } } } }
- 您可以遍历数组，直到不再交换元素
- 当您将元素放在最后一个位置时，您知道它是最大的，因此您可以将内部循环计算为1
我的第一个本科学年（“蓝色时代”）的while循环的bubbleort版本。
public static void bubbleSort() { int[] r = randomArrayDisplayer(); int i = r.length; while(i!=0){ int j = 0; while(j!=i-1){ if(r[j+1]
我的建议是显示每一步，以确保正确的行为。
public class BubbleSort { public static void main(String[] args) { int arr[] = {64, 34, 25, 12, 22, 11, 90}; BubbleSort client=new BubbleSort(); int[] result=client.bubbleSort(arr); for(int i:result) { System.out.println(i); } } public int[] bubbleSort(int[] arr) { int n=arr.length; for(int i=0;iarr[j+1]) swap(arr,j,j+1); } return arr; } private int[] swap(int[] arr, int i, int j) { int temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; return arr; } }
上面的代码看起来像实现Selection sort，它不是冒泡排序。
请查找下面的冒泡排序代码。
Class BubbleSort { public static void main(String []args) { int n, c, d, swap; Scanner in = new Scanner(System.in); System.out.println("Input number of integers to sort"); n = in.nextInt(); int array[] = new int[n]; System.out.println("Enter " + n + " integers"); for (c = 0; c < n; c++) array[c] = in.nextInt(); for (c = 0; c < ( n - 1 ); c++) { for (d = 0; d < n - c - 1; d++) { if (array[d] > array[d+1]) /* For descending order use < */ { swap = array[d]; array[d] = array[d+1]; array[d+1] = swap; } } } System.out.println("Sorted list of numbers"); for (c = 0; c < n; c++) System.out.println(array[c]); } }
/* Implementation of Bubble sort using Java */ import java.util.Arrays; import java.util.Scanner; public class BubbleSort { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); System.out.println("Enter the number of elements of array"); int n = in.nextInt(); int []a = new int[n]; System.out.println("Enter the integer array"); for(int i=0; ia[j]) { int temp = a[j-1]; a[j-1]=a[j]; a[j]=temp; } } } System.out.println("Sorted array: "+ Arrays.toString(a)); } } /* **************************************** Time Complexity: O(n*n) Space Complexity: O(1) **************************************** */
class BubbleSort { public static void main(String[] args) { int a[] = {5,4,3,2,1}; int length = a.length - 1; for (int i = 0 ; i < length ; i++) { for (int j = 0 ; j < length-i ; j++) { if (a[j] > a[j+1]) { int swap = a[j]; a[j] = a[j+1]; a[j+1] = swap; } } } for (int x : a) { System.out.println(x); } }
}
是的，它似乎是冒泡排序元素
冒泡排序
void bubbleSort(int arr[]) { int n = arr.length; for (int i = 0; i < n-1; i++) for (int j = 0; j < ni-1; j++) if (arr[j] > arr[j+1]) { // swap temp and arr[i] int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } }
它将在最坏的情况下给出O（n ^ 2），即使数组已经排序。
int[] nums = new int[] { 6, 3, 2, 1, 7, 10, 9 }; for(int i = nums.Length-1; i>=0; i--) for(int j = 0; j