1. C 冒泡排序 求優化

優化很簡單.
當你比較時發現它一次都沒有交換時就證明已經排好序,這時就可以中斷排序了.
具體代碼你自己寫吧,很簡單的

2. jQuery 冒泡排序 性能優化求助

必須重新讀一個#items .body的集合 可以告訴你，這樣對性能幾乎沒影響。

3. 冒泡排序最好時間復雜度為什麼是O

冒泡排序的最好時間復雜度為O（n），但原始演算法是達不到的，需要做簡單優化，在外層循環中加入flag量進行判斷——若本輪遍歷沒有發生任何一次交換，則終止循環。

具體實現參考如下（JS）

	functionbubbleSort(arr){
	letloopTimes=0
	for(leti=0,len=arr.length;i<len;i++){
	letfinished=true
	for(letj=0,len=arr.length-i-1;j<len;j++){
	if(arr[j]>arr[j+1]){
	finished=false;
	temp=arr[j+1]
	arr[j+1]=arr[j]
	arr[j]=temp
	}
	}
	loopTimes++;
	if(finished)
	break
	}
	returnloopTimes
	}
	
	letarr=[2,3,9,4,5]
	letres=bubbleSort(arr)
	console.log('loopTimes:'+bubbleSort(arr))
	console.log('theArrayaftersorting:'+arr)

更詳細的解釋可參考——冒泡排序優化（T-T歡迎關注我的博客，多多指教，嚶嚶嚶）

4. 選擇排序演算法是冒泡排序演算法的優化嗎

選擇排序總是會比冒泡排序效率高，因為選擇排序每輪至多隻交換1歡，但從演算法角度考慮，時間復雜度並沒有什麼改進，因為都是o(n^2)演算法！

5. c語言編程改進冒泡排序,讓冒泡排序一旦排好序就停止循環,提高程序的效率

#include<stdio.h>
void bubble_sort_1(int a[],int n)
{ int i,j,x,flag=1;
j=0;
while (flag) // 存在交換，進入循環
{ flag=0; // 初始化，不存在交換
for(i=n-2;i>=j;i--)
if(a[i]>a[i+1])
{ x=a[i]; a[i]=a[i+1]; a[i+1]=x;
flag=1; // 發現交換，說明無序
}
j++;
}
}
int main(){
}

6. java 關於冒泡排序的優化，下面這種優化的原理是什麼

冒泡排序的優化版原理在於如果循環體發生過交換那麼它的哨兵肯定是變化過的，反之哨兵還是原來的。而這個哨兵你可以用數組下標為0即首元素作為哨兵也可以，也可以藉助其它輔助變數。例如下面的演算法冒泡演算法優化版是藉助了flag作為哨兵:

//冒泡演算法優化版
staticvoidbubbleSort(int...array){
		inti,j;
		booleanflag=true;
		for(i=0;i<array.length&&flag;i++){
			flag=false;
			for(j=array.length-2;j>=i;j--){//由後往前逆推
				if(array[j]>array[j+1]){
					inttemp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
					flag=true;
				}
			}
		}
		
		for(intitem:array){
			System.out.println(item);
		}
}

7. 排序一 幾種冒泡排序的比較和優化

packagecom.asin.algorithm;

importjava.util.Arrays;

publicclassBubbleSort{

	privatestaticvoidswap(int[]arr,inti,intj){
		inttemp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}

	/**
	*最簡單的排序實現
	*
	*當i=1,j=8時，雖然把2排到前面了，但是也把3排到了最後，效率非常低
	*/
	privatestaticvoidsort1(int[]arr){

		intsumSwap=0,sumIn=0,sumOut=0;
		for(inti=0;i<arr.length;i++){
			for(intj=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					swap(arr,i,j);
					sumSwap++;
				}
				sumIn++;
			}
			sumOut++;
		}
		System.out.println("sort1執行次數：sumSwap:"+sumSwap+"sumIn:"+sumIn+"sumOut:"+sumOut);
		System.out.println(Arrays.toString(arr));
	}

	/**
	*冒泡排序，從底往上遍歷
	*
	*當i=2時，把4往前排了，還把3往前排了，最終把2排到第二位
	*/
	privatestaticvoidsort2(int[]arr){

		intsumSwap=0,sumIn=0,sumOut=0;
		for(inti=0;i<arr.length;i++){
			for(intj=arr.length-1;j>i;j--){
				if(arr[j-1]>arr[j]){
					swap(arr,j-1,j);
					sumSwap++;
				}
				sumIn++;
			}
			sumOut++;
		}
		System.out.println("sort2執行次數：sumSwap:"+sumSwap+"sumIn:"+sumIn+"sumOut:"+sumOut);
		System.out.println(Arrays.toString(arr));
	}

	/**
	*冒泡排序優化，避免了已經是有序的情況下的無意義的循環
	*
	*9,1,5,8,3,7,4,6,2
	*
	*2,1,3,4,5,6,7,8,9這種情況下，只需要把2和1交換
	*/
	privatestaticvoidsort3(int[]arr){

		intsumSwap=0,sumIn=0,sumOut=0;
		booleanflag=true;
		for(inti=0;i<arr.length&&flag;i++){//i<arr.length&&flag
			flag=false;
			for(intj=arr.length-1;j>i;j--){
				if(arr[j-1]>arr[j]){//數組是否有序
					swap(arr,j-1,j);
					flag=true;//交換後，再判斷
					sumSwap++;
				}
				sumIn++;
			}
			sumOut++;
		}
		System.out.println("sort3執行次數：sumSwap:"+sumSwap+"sumIn:"+sumIn+"sumOut:"+sumOut);
		System.out.println(Arrays.toString(arr));
	}

	/**
	*測試比較混亂的數組
	*/
	privatestaticvoidarr1(){
		int[]arr1={9,1,5,8,3,7,4,6,2};
		sort1(arr1);
		int[]arr2={9,1,5,8,3,7,4,6,2};
		sort2(arr2);
		int[]arr3={9,1,5,8,3,7,4,6,2};
		sort3(arr3);
	}

	/**
	*測試不太混亂的數組
	*/
	privatestaticvoidarr2(){
		int[]arr1={2,1,3,4,5,6,7,8,9};
		sort1(arr1);
		int[]arr2={2,1,3,4,5,6,7,8,9};
		sort2(arr2);
		int[]arr3={2,1,3,4,5,6,7,8,9};
		sort3(arr3);
	}

	publicstaticvoidmain(String[]args){

		arr1();//比較混亂的數組
		arr2();//不太混亂的數組
	}

8. VB中,冒泡法 最優化的公式...

要的是演算法嗎？如果是請看下面：
Public Sub Sort(ByVal arr() As Integer)
Dim i As Integer,j As Integer,temp As Integer
Dim done As Boolean = False
j = 1
While (j < arr.Length) &&(Not done)
done = True
For i = 0 To arr.Length - j- 1 Step i + 1
If arr(i) > arr(i + 1) Then
done = False
temp = arr(i)
arr(i) = arr(i + 1)'交換數據
arr(i + 1) = temp
End If
Next
j = j + 1
End While
End Sub