氣泡提示解決思路如下：
創(chuàng)新互聯(lián)是一家專業(yè)提供太和企業(yè)網(wǎng)站建設(shè),專注與成都網(wǎng)站建設(shè)、做網(wǎng)站、H5網(wǎng)站設(shè)計(jì)、小程序制作等業(yè)務(wù)。10年已為太和眾多企業(yè)、政府機(jī)構(gòu)等服務(wù)。創(chuàng)新互聯(lián)專業(yè)網(wǎng)站制作公司優(yōu)惠進(jìn)行中。
1、非模態(tài)彈出對話框。
2、去掉彈出對話框的邊框和標(biāo)題欄。
3、對話框上用于顯示的控件全部自繪，以達(dá)到絢麗的效果。
4、設(shè)置對話框彈出位置。
5、定時(shí)器控制對話框消失。
冒泡排序是所欲排序算法里最好理解的了。
1、排序算法：
A)比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)。
B)對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對。在這一點(diǎn)，最后的元素應(yīng)該會(huì)是最大的數(shù)。
C)針對所有的元素重復(fù)以上的步驟，除了最后一個(gè)。
D)持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。
2、給你一個(gè)java的實(shí)現(xiàn)代碼：
public class BubbleSort{
public static void main(String[] args){
? ?int score[] = {67, 69, 75, 87, 89, 90, 99, 100};
? ?for (int i = 0; i score.length -1; i++){ //最多做n-1趟排序
? ? ? ?for(int j = 0 ;j score.length - i - 1; j++){ //對當(dāng)前無序區(qū)間score[0......length-i-1]進(jìn)行排序(j的范圍很關(guān)鍵，這個(gè)范圍是在逐步縮小的)
? ? ? ? ? ?if(score[j] score[j + 1]){ //把小的值交換到后面
? ? ? ? ? ? ? ?int temp = score[j];
? ? ? ? ? ? ? ?score[j] = score[j + 1];
? ? ? ? ? ? ? ?score[j + 1] = temp;
? ? ? ? ? ?}
? ? ? ?}
? ? ? ?System.out.print("第" + (i + 1) + "次排序結(jié)果：");
? ? ? ?for(int a = 0; a score.length; a++){
? ? ? ? ? ?System.out.print(score[a] + "\t");
? ? ? ?}
? ? ? ?System.out.println("");
? ?}
? ? ? ?System.out.print("最終排序結(jié)果：");
? ? ? ?for(int a = 0; a score.length; a++){
? ? ? ? ? ?System.out.print(score[a] + "\t");
? }
}
}
其實(shí)就是兩個(gè)布局，里面頭像，對話框控件的android:id一樣，然后再adapter中g(shù)etview()根據(jù)用戶判斷選擇不同的加載就OK了，代碼類似于
if (判斷) {
view = LayoutInflater.from(activity).inflate(
R.layout.left, null);//左邊的布局
} else {
view = LayoutInflater.from(activity).inflate(
R.layout.right, null);//右邊的布局
}
ImageView avatar = (ImageView) view.findViewById();//頭像
TextView msg = (TextView) view.findViewById(R.id.);//對話框
實(shí)例說明?
用冒泡排序方法對數(shù)組進(jìn)行排序。?
實(shí)例解析?
交換排序的基本思想是兩兩比較待排序記錄的關(guān)鍵字，發(fā)現(xiàn)兩個(gè)記錄的次序相反時(shí)即進(jìn)行交換，直到?jīng)]有反序的記錄為止。?
應(yīng)用交換排序基本思想的主要排序方法有冒泡排序和快速排序。?
冒泡排序?
將被排序的記錄數(shù)組 R[1..n] 垂直排列，每個(gè)記錄 R[i] 看做是重量為 R[i].key 的氣泡。根據(jù)輕氣泡不能在重氣泡之下的原則，從下往上掃描數(shù)組 R 。凡掃描到違反本原則的輕氣泡，就使其向上“漂浮”。如此反復(fù)進(jìn)行，直到最后任何兩個(gè)氣泡都是輕者在上，重者在下為止。?
(1) 初始， R[1..n] 為無序區(qū)。?
(2) 第一趟掃描，從無序區(qū)底部向上依次比較相鄰的兩個(gè)氣泡的重量，若發(fā)現(xiàn)輕者在下、重者在上，則交換二者的位置。即依次比較 (R[n],R[n-1]) 、 (R[n-1],R[n-2]) 、 … 、 (R[2],R[1]); 對于每對氣泡 (R[j+1],R[j]), 若 R[j+1].keyR[j].key, 則交換 R[j+1] 和 R[j] 的內(nèi)容。?
第一趟掃描完畢時(shí)，“最輕”的氣泡就飄浮到該區(qū)間的頂部，即關(guān)鍵字最小的記錄被放在最高位置 R[1] 上。?
(3) 第二趟掃描，掃描 R[2..n]。掃描完畢時(shí)，“次輕”的氣泡飄浮到 R[2] 的位置上 …… 最后，經(jīng)過 n-1 趟掃描可得到有序區(qū) R[1..n]。?
注意：第 i 趟掃描時(shí)， R[1..i-1] 和 R[i..n] 分別為當(dāng)前的有序區(qū)和無序區(qū)。掃描仍是從無序區(qū)底部向上直至該區(qū)頂部。掃描完畢時(shí)，該區(qū)中最輕氣泡漂浮到頂部位置 R[i] 上，結(jié)果是 R[1..i] 變?yōu)樾碌挠行騾^(qū)。?
冒泡排序算法?
因?yàn)槊恳惶伺判蚨际褂行騾^(qū)增加了一個(gè)氣泡，在經(jīng)過 n-1 趟排序之后，有序區(qū)中就有 n-1 個(gè)氣泡，而無序區(qū)中氣泡的重量總是大于等于有序區(qū)中氣泡的重量，所以整個(gè)冒泡排序過程至多需要進(jìn)行 n-1 趟排序。?
若在某一趟排序中未發(fā)現(xiàn)氣泡位置的交換，則說明待排序的無序區(qū)中所有氣泡均滿足輕者在上，重者在下的原則，因此，冒泡排序過程可在此趟排序后終止。為此，在下面給出的算法中，引入一個(gè)布爾量 exchange, 在每趟排序開始前，先將其置為 FALSE 。若排序過程中發(fā)生了交換，則將其置為 TRUE 。各趟排序結(jié)束時(shí)檢查 exchange, 若未曾發(fā)生過交換則終止算法，不再進(jìn)行下趟排序。
具體算法如下：?
void BubbleSort(SeqList R){?
//R(1..n) 是待排序的文件，采用自下向上掃描，對 R 做冒泡排序?
int i,j;?
Boolean exchange; // 交換標(biāo)志?
for(i=1;in;i++){ // 最多做 n-1 趟排序?
exchange=FALSE; // 本趟排序開始前，交換標(biāo)志應(yīng)為假?
for(j=n-1;j=i;j--) // 對當(dāng)前無序區(qū) R[i..n] 自下向上掃描?
if(R[j+1].keyR[j].key){ // 交換記錄?
R[0]=R[j+1]; //R[0] 不是哨兵，僅做暫存單元?
R[j+1]=R[j];?
R[j]=R[0];?
exchange=TRUE; // 發(fā)生了交換，故將交換標(biāo)志置為真?
}?
if(!exchange) // 本趟排序未發(fā)生交換，提前終止算法?
return;?
} //endfor( 外循環(huán) )?
}//BubbleSort
public?class?BubbleSort?{
public?static?void?main(String[]?args)?{
//?TODO?Auto-generated?method?stub
ListInteger?lstInteger?=?new?ArrayListInteger();
lstInteger.add(1);
lstInteger.add(1);
lstInteger.add(3);
lstInteger.add(2);
lstInteger.add(1);
for(int?i?=?0;?ilstInteger.size();?i++){
System.out.println(lstInteger.get(i));
}
System.out.println("排序之后-----------------");
lstInteger?=?sortList(lstInteger);
for(int?i?=?0;?ilstInteger.size();?i++){
System.out.println(lstInteger.get(i));
}
}
public?static?ListInteger?sortList(ListInteger?lstInteger){
int?i,j,m;
boolean?blChange;
int?n?=?lstInteger.size();
for(i=0;in;i++){
blChange?=?false;
for(j?=?n-1;?ji?;?j--?){
if(lstInteger.get(j)lstInteger.get(j-1)){
m?=?lstInteger.get(j-1);
lstInteger.set(j-1,?lstInteger.get(j));
lstInteger.set(j,?m);
blChange?=?true;
}
}
if(!blChange){
return?lstInteger;
}
}
return?lstInteger;
}
}
歸納注釋?
算法的最好時(shí)間復(fù)雜度:?若文件的初始狀態(tài)是正序的,?一趟掃描即可完成排序。所需的關(guān)鍵字比較次數(shù)?C?和記錄移動(dòng)次數(shù)?M?均達(dá)到最小值，即?C(min)=n-1,?M(min)=?0?。冒泡排序最好的時(shí)間復(fù)雜度為?O(n)。?
算法的最壞時(shí)間復(fù)雜度:?若初始文件是反序的，需要進(jìn)行?n-1?趟排序。每趟排序要進(jìn)行?n-1?次關(guān)鍵字的比較?(1=i=n-1),?且每次比較都必須移動(dòng)記錄?3?次。在這種情況下，比較和移動(dòng)次數(shù)均達(dá)到最大值，即?C(max)=n(n-1)/2=O(n?^2?)，M(max)=3n(n-1)/2=O(n?^2?)。冒泡排序的最壞時(shí)間復(fù)雜度為?O(n^2?)。?
算法的平均時(shí)間復(fù)雜度為?O(n^2?)。雖然冒泡排序不一定要進(jìn)行?n-1?趟，但由于它的記錄移動(dòng)次數(shù)較多，故平均時(shí)間性能比直接插入排序要差得多。?
算法穩(wěn)定性：冒泡排序是就地排序，且它是穩(wěn)定的。?
算法改進(jìn)：上述的冒泡排序還可做如下的改進(jìn)，①?記住最后一次交換發(fā)生位置?lastExchange?的冒泡排序(?該位置之前的相鄰記錄均已有序?)。下一趟排序開始時(shí)，R[1..lastExchange-1]?是有序區(qū)，?R[lastExchange..n]?是無序區(qū)。這樣，一趟排序可能使當(dāng)前有序區(qū)擴(kuò)充多個(gè)記錄，從而減少排序的趟數(shù)。②?改變掃描方向的冒泡排序。冒泡排序具有不對稱性。能一趟掃描完成排序的情況，只有最輕的氣泡位于?R[n]?的位置，其余的氣泡均已排好序，那么也只需一趟掃描就可以完成排序。如對初始關(guān)鍵字序列?12、18、42、44、45、67、94、10?就僅需一趟掃描。需要?n-1?趟掃描完成排序情況，當(dāng)只有最重的氣泡位于?R[1]?的位置，其余的氣泡均已排好序時(shí)，則仍需做?n-1?趟掃描才能完成排序。比如對初始關(guān)鍵字序列：94、10、12、18、42、44、45、67?就需?7?趟掃描。造成不對稱性的原因是每趟掃描僅能使最重氣泡“下沉”一個(gè)位置，因此使位于頂端的最重氣泡下沉到底部時(shí)，需做?n-1?趟掃描。在排序過程中交替改變掃描方向，可改進(jìn)不對稱性
重慶分公司
重慶分公司
