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