冒泡法排序vb

合集下载

VB NET实现选择排序与冒泡排序

Public Class Form1Dim arr(5) As IntegerDim a(5, 5) As TextBoxPrivate Sub delaytime()Dim i, j As LongFor i = 1 To 20000For j = 1 To 20000i = i + 1i = i - 1Next jNext iEnd SubPrivate Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.LoadLabel1.Text = "数ºy组Á¨¦元a素?值¦Ì：êo"Label2.Text = "第Ì¨²一°?轮?：êo"Label3.Text = "第Ì¨²二t轮?：êo"Label4.Text = "第Ì¨²三¨y轮?：êo"Label5.Text = "第Ì¨²四?轮?：êo"Label6.Text = "第Ì¨²五?轮?：êo"Button1.Text = "产¨²生¦¨²数ºy组Á¨¦"Button2.Text = "选?择?法¤¡§演Y示º?"Button3.Text = "冒¡ã泡Y法¤¡§演Y示º?"Button4.Text = "重?新?开a始º?"Button5.Text = "退ª?出?"Dim i, j As IntegerDim leftlen, toplen As Integerleftlen = 120 : toplen = 32Randomize()For i = 0 To 5For j = 0 To 5a(i, j) = New TextBoxa(i, j).Width = 30 : a(i, j).Height = 30a(i, j).Left = leftlen + j * 40 : a(i, j).Top = toplen + i * 32a(i, j).Parent = Me : a(i, j).Visible = TrueNext jNext iEnd SubPrivate Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.ClickDim i, j As IntegerFor i = 0 To 5arr(i) = Int(10 + 89 * Rnd()) + 1a(0, i).Text = arr(i)Next iEnd SubPrivate Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.ClickDim i, j As IntegerDim min, min_i As IntegerDim t As IntegerFor i = 0 To 5 - 1min = arr(i) : min_i = iFor j = i + 1 To 5If min > arr(j) Thenmin = arr(j) : min_i = jEnd IfNext ja(i, min_i).BackColor = System.Drawing.Color.Yellowa(i, i).BackColor = System.Drawing.Color.LightCyanMe.Refresh()If min_i <> i Thent = arr(min_i) : arr(min_i) = arr(i) : arr(i) = tEnd IfFor j = 0 To 5a(i + 1, j).Text = arr(j)Next jCall delaytime()Me.Refresh()Next iEnd SubPrivate Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.ClickDim i, j, k, t As IntegerFor i = 1 To 5For k = 0 To 5a(i, k).Text = arr(k)Next kMe.Refresh()Call delaytime()For j = 0 To 5 - ia(i, j).BackColor = System.Drawing.Color.LightCyana(i, j + 1).BackColor = System.Drawing.Color.LightC yanMe.Refresh()Call delaytime()If arr(j) > arr(j + 1) Thent = arr(j) : arr(j) = arr(j + 1) : arr(j + 1) = ta(i, j).Text = arr(j) : a(i, j + 1).Text = arr(j + 1)End IfMe.Refresh()Call delaytime()a(i, j).BackColor = System.Drawing.Color.WhiteSmokea(i, j + 1).BackColor = System.Drawing.Color.WhiteSmokeNext jNext iEnd SubPrivate Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.ClickDim i, j As IntegerFor i = 0 To 5For j = 0 To 5a(i, j).Text = ""a(i, j).BackColor = System.Drawing.Color.WhiteSmokeNext jNext iEnd SubPrivate Sub Button5_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button5.ClickEndEnd SubEnd Class。

VBA排序的十种算法

在使用VBA进行写程序时，经常会做排序，下面将会给出一些常用的排序算法的实现，方便大家写程序参考，若代码中出现了错误，欢迎高手指正。

主要算法有：1、（冒泡排序）Bubble sort2、（选择排序）Selection sort3、（插入排序）Insertion sort4、（快速排序）Quick sort5、（合并排序）Merge sort6、（堆排序）Heap sort7、（组合排序）Comb Sort8、（希尔排序）Shell Sort9、（基数排序）Radix Sort10、Shaker Sort第一种（冒泡排序）Bubble sortPublic Sub BubbleSort(ByRef lngArray() As Long)Dim iOuter As LongDim iInner As LongDim iLBound As LongDim iUBound As LongDim iTemp As LongiLBound = LBound(lngArray)iUBound = UBound(lngArray)'冒泡排序For iOuter = iLBound To iUBound - 1For iInner = iLBound To iUBound - iOuter - 1'比较相邻项If lngArray(iInner) > lngArray(iInner + 1) Then'交换值iTemp = lngArray(iInner)lngArray(iInner) = lngArray(iInner + 1)lngArray(iInner + 1) = iTempEnd IfNext iInnerNext iOuterEnd Sub2、（选择排序）Selection sort1.Public Sub SelectionSort(ByRef lngArray() As Long)2.Dim iOuter As Long3.Dim iInner As Long4.Dim iLBound As Long5.Dim iUBound As Long6.Dim iTemp As Long7.Dim iMax As Long8.9.iLBound = LBound(lngArray)10.iUBound = UBound(lngArray)11.12.'选择排序13.For iOuter = iUBound To iLBound + 1 Step -114.15.iMax = 016.17.'得到最大值得索引18.For iInner = iLBound To iOuter19.If lngArray(iInner) > lngArray(iMax) Then iMax = iInner20.Next iInner21.22.'值交换23.iTemp = lngArray(iMax)24.lngArray(iMax) = lngArray(iOuter)25.lngArray(iOuter) = iTemp26.27.Next iOuter28.End Sub复制代码第三种（插入排序）Insertion sort1.Public Sub InsertionSort(ByRef lngArray() As Long)2.Dim iOuter As Long3.Dim iInner As Long4.Dim iLBound As Long5.Dim iUBound As Long6.Dim iTemp As Long7.8.iLBound = LBound(lngArray)9.iUBound = UBound(lngArray)10.11.For iOuter = iLBound + 1 To iUBound12.13.'取得插入值14.iTemp = lngArray(iOuter)15.16.'移动已经排序的值17.For iInner = iOuter - 1 To iLBound Step -118.If lngArray(iInner) <= iTemp Then Exit For19.lngArray(iInner + 1) = lngArray(iInner)20.Next iInner21.22.'插入值23.lngArray(iInner + 1) = iTemp24.Next iOuter25.End Sub复制代码第四种（快速排序）Quick sort1.Public Sub QuickSort(ByRef lngArray() As Long)2.Dim iLBound As Long3.Dim iUBound As Long4.Dim iTemp As Long5.Dim iOuter As Long6.Dim iMax As Long7.8.iLBound = LBound(lngArray)9.iUBound = UBound(lngArray)10.11.'若只有一个值，不排序12.If (iUBound - iLBound) Then13.For iOuter = iLBound To iUBound14.If lngArray(iOuter) > lngArray(iMax) Then iMax = iOuter15.Next iOuter16.17.iTemp = lngArray(iMax)18.lngArray(iMax) = lngArray(iUBound)19.lngArray(iUBound) = iTemp20.21.'开始快速排序22.InnerQuickSort lngArray, iLBound, iUBound23.End If24.End Sub25.26.Private Sub InnerQuickSort(ByRef lngArray() As Long, ByVal iLeftEnd As Long, ByValiRightEnd As Long)27.Dim iLeftCur As Long28.Dim iRightCur As Long29.Dim iPivot As Long30.Dim iTemp As Long31.32.If iLeftEnd >= iRightEnd Then Exit Sub33.34.iLeftCur = iLeftEnd35.iRightCur = iRightEnd + 136.iPivot = lngArray(iLeftEnd)37.38.Do39.Do40.iLeftCur = iLeftCur + 141.Loop While lngArray(iLeftCur) < iPivot42.43.Do44.iRightCur = iRightCur - 145.Loop While lngArray(iRightCur) > iPivot46.47.If iLeftCur >= iRightCur Then Exit Do48.49.'交换值50.iTemp = lngArray(iLeftCur)51.lngArray(iLeftCur) = lngArray(iRightCur)52.lngArray(iRightCur) = iTemp53.Loop54.55.'递归快速排序56.lngArray(iLeftEnd) = lngArray(iRightCur)57.lngArray(iRightCur) = iPivot58.59.InnerQuickSort lngArray, iLeftEnd, iRightCur - 160.InnerQuickSort lngArray, iRightCur + 1, iRightEnd61.End Sub复制代码第五种（合并排序）Merge sort1.Public Sub MergeSort(ByRef lngArray() As Long)2.Dim arrTemp() As Long3.Dim iSegSize As Long4.Dim iLBound As Long5.Dim iUBound As Long6.7.iLBound = LBound(lngArray)8.iUBound = UBound(lngArray)9.10.ReDim arrTemp(iLBound To iUBound)11.12.iSegSize = 113.Do While iSegSize < iUBound - iLBound14.15.'合并A到B16.InnerMergePass lngArray, arrTemp, iLBound, iUBound, iSegSize17.iSegSize = iSegSize + iSegSize18.19.'合并B到A20.InnerMergePass arrTemp, lngArray, iLBound, iUBound, iSegSize21.iSegSize = iSegSize + iSegSize22.23.Loop24.End Sub25.26.Private Sub InnerMergePass(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByVal iLBoundAs Long, iUBound As Long, ByVal iSegSize As Long)27.Dim iSegNext As Long28.29.iSegNext = iLBound30.31.Do While iSegNext <= iUBound - (2 * iSegSize)32.'合并33.InnerMerge lngSrc, lngDest, iSegNext, iSegNext + iSegSize - 1, iSegNext + iSegSize +iSegSize - 134.35.iSegNext = iSegNext + iSegSize + iSegSize36.Loop37.38.If iSegNext + iSegSize <= iUBound Then39.InnerMerge lngSrc, lngDest, iSegNext, iSegNext + iSegSize - 1, iUBound40.Else41.For iSegNext = iSegNext To iUBound42.lngDest(iSegNext) = lngSrc(iSegNext)43.Next iSegNext44.End If45.46.End Sub47.48.Private Sub InnerMerge(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByVal iStartFirstAs Long, ByVal iEndFirst As Long, ByVal iEndSecond As Long)49.Dim iFirst As Long50.Dim iSecond As Long51.Dim iResult As Long52.Dim iOuter As Long53.54.iFirst = iStartFirst55.iSecond = iEndFirst + 156.iResult = iStartFirst57.58.Do While (iFirst <= iEndFirst) And (iSecond <= iEndSecond)59.60.If lngSrc(iFirst) <= lngSrc(iSecond) Then61.lngDest(iResult) = lngSrc(iFirst)62.iFirst = iFirst + 163.Else64.lngDest(iResult) = lngSrc(iSecond)65.iSecond = iSecond + 166.End If67.68.iResult = iResult + 169.Loop70.71.If iFirst > iEndFirst Then72.For iOuter = iSecond To iEndSecond73.lngDest(iResult) = lngSrc(iOuter)74.iResult = iResult + 175.Next iOuter76.Else77.For iOuter = iFirst To iEndFirst78.lngDest(iResult) = lngSrc(iOuter)79.iResult = iResult + 180.Next iOuter81.End If82.End Sub复制代码第六种（堆排序）Heap sort1.Public Sub HeapSort(ByRef lngArray() As Long)2.Dim iLBound As Long3.Dim iUBound As Long4.Dim iArrSize As Long5.Dim iRoot As Long6.Dim iChild As Long7.Dim iElement As Long8.Dim iCurrent As Long9.Dim arrOut() As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)13.iArrSize = iUBound - iLBound14.15.ReDim arrOut(iLBound To iUBound)16.17.'Initialise the heap18.'Move up the heap from the bottom19.For iRoot = iArrSize \ 2 To 0 Step -120.21.iElement = lngArray(iRoot + iLBound)22.iChild = iRoot + iRoot23.24.'Move down the heap from the current position25.Do While iChild < iArrSize26.27.If iChild < iArrSize Then28.If lngArray(iChild + iLBound) < lngArray(iChild + iLBound + 1) Then29.'Always want largest child30.iChild = iChild + 131.End If32.End If33.34.'Found a slot, stop looking35.If iElement >= lngArray(iChild + iLBound) Then Exit Do36.37.lngArray((iChild \ 2) + iLBound) = lngArray(iChild + iLBound)38.iChild = iChild + iChild39.Loop40.41.'Move the node42.lngArray((iChild \ 2) + iLBound) = iElement43.Next iRoot44.45.'Read of values one by one (store in array starting at the end)46.For iRoot = iUBound To iLBound Step -147.48.'Read the value49.arrOut(iRoot) = lngArray(iLBound)50.'Get the last element51.iElement = lngArray(iArrSize + iLBound)52.53.iArrSize = iArrSize - 154.iCurrent = 055.iChild = 156.57.'Find a place for the last element to go58.Do While iChild <= iArrSize59.60.If iChild < iArrSize Then61.If lngArray(iChild + iLBound) < lngArray(iChild + iLBound + 1) Then62.'Always want the larger child63.iChild = iChild + 164.End If65.End If66.67.'Found a position68.If iElement >= lngArray(iChild + iLBound) Then Exit Do69.70.lngArray(iCurrent + iLBound) = lngArray(iChild + iLBound)71.iCurrent = iChild72.iChild = iChild + iChild73.74.Loop75.76.'Move the node77.lngArray(iCurrent + iLBound) = iElement78.Next iRoot79.80.'Copy from temp array to real array81.For iRoot = iLBound To iUBound82.lngArray(iRoot) = arrOut(iRoot)83.Next iRoot84.End Sub复制代码第七种（组合排序）Comb Sort1.Public Sub CombSort(ByRef lngArray() As Long)2.Dim iSpacing As Long3.Dim iOuter As Long4.Dim iInner As Long5.Dim iTemp As Long6.Dim iLBound As Long7.Dim iUBound As Long8.Dim iArrSize As Long9.Dim iFinished As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)14.'Initialise comb width15.iSpacing = iUBound - iLBound16.17.Do18.If iSpacing > 1 Then19.iSpacing = Int(iSpacing / 1.3)20.21.If iSpacing = 0 Then22.iSpacing = 1 'Dont go lower than 123.ElseIf iSpacing > 8 And iSpacing < 11 Then24.iSpacing = 11 'This is a special number, goes faster than 9 and 1025.End If26.End If27.28.'Always go down to 1 before attempting to exit29.If iSpacing = 1 Then iFinished = 130.31.'Combing pass32.For iOuter = iLBound To iUBound - iSpacing33.iInner = iOuter + iSpacing34.35.If lngArray(iOuter) > lngArray(iInner) Then36.'Swap37.iTemp = lngArray(iOuter)38.lngArray(iOuter) = lngArray(iInner)39.lngArray(iInner) = iTemp40.41.'Not finished42.iFinished = 043.End If44.Next iOuter46.Loop Until iFinished47.End Sub复制代码第八种（希尔排序）Shell Sort1.Public Sub ShellSort(ByRef lngArray() As Long)2.Dim iSpacing As Long3.Dim iOuter As Long4.Dim iInner As Long5.Dim iTemp As Long6.Dim iLBound As Long7.Dim iUBound As Long8.Dim iArrSize As Long9.10.iLBound = LBound(lngArray)11.iUBound = UBound(lngArray)12.13.'Calculate initial sort spacing14.iArrSize = (iUBound - iLBound) + 115.iSpacing = 116.17.If iArrSize > 13 Then18.Do While iSpacing < iArrSize19.iSpacing = (3 * iSpacing) + 120.Loop21.22.iSpacing = iSpacing \ 923.End If24.25.'Start sorting26.Do While iSpacing28.For iOuter = iLBound + iSpacing To iUBound29.30.'Get the value to be inserted31.iTemp = lngArray(iOuter)32.33.'Move along the already sorted values shifting along34.For iInner = iOuter - iSpacing To iLBound Step -iSpacing35.'No more shifting needed, we found the right spot!36.If lngArray(iInner) <= iTemp Then Exit For37.38.lngArray(iInner + iSpacing) = lngArray(iInner)39.Next iInner40.41.'Insert value in the slot42.lngArray(iInner + iSpacing) = iTemp43.Next iOuter44.45.'Reduce the sort spacing46.iSpacing = iSpacing \ 347.Loop48.49.End Sub复制代码第九种（基数排序）Radix Sort1.Public Sub RadixSort(ByRef lngArray() As Long)2.Dim arrTemp() As Long3.Dim iLBound As Long4.Dim iUBound As Long5.Dim iMax As Long6.Dim iSorts As Long7.Dim iLoop As Long8.9.iLBound = LBound(lngArray)10.iUBound = UBound(lngArray)11.12.'Create swap array13.ReDim arrTemp(iLBound To iUBound)14.15.iMax = &H8000000016.'Find largest17.For iLoop = iLBound To iUBound18.If lngArray(iLoop) > iMax Then iMax = lngArray(iLoop)19.Next iLoop20.21.'Calculate how many sorts are needed22.Do While iMax23.iSorts = iSorts + 124.iMax = iMax \ 25625.Loop26.27.iMax = 128.29.'Do the sorts30.For iLoop = 1 To iSorts31.32.If iLoop And 1 Then33.'Odd sort -> src to dest34.InnerRadixSort lngArray, arrTemp, iLBound, iUBound, iMax35.Else36.'Even sort -> dest to src37.InnerRadixSort arrTemp, lngArray, iLBound, iUBound, iMax38.End If39.40.'Next sort factor41.iMax = iMax * 25642.Next iLoop43.44.'If odd number of sorts we need to swap the arrays45.If (iSorts And 1) Then46.For iLoop = iLBound To iUBound47.lngArray(iLoop) = arrTemp(iLoop)48.Next iLoop49.End If50.End Sub51.52.Private Sub InnerRadixSort(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByVal iLBoundAs Long, ByVal iUBound As Long, ByVal iDivisor As Long)53.Dim arrCounts(255) As Long54.Dim arrOffsets(255) As Long55.Dim iBucket As Long56.Dim iLoop As Long57.58.'Count the items for each bucket59.For iLoop = iLBound To iUBound60.iBucket = (lngSrc(iLoop) \ iDivisor) And 25561.arrCounts(iBucket) = arrCounts(iBucket) + 162.Next iLoop63.64.'Generate offsets65.For iLoop = 1 To 25566.arrOffsets(iLoop) = arrOffsets(iLoop - 1) + arrCounts(iLoop - 1) + iLBound67.Next iLoop68.69.'Fill the buckets70.For iLoop = iLBound To iUBound71.iBucket = (lngSrc(iLoop) \ iDivisor) And 25572.lngDest(arrOffsets(iBucket)) = lngSrc(iLoop)73.arrOffsets(iBucket) = arrOffsets(iBucket) + 174.Next iLoop75.End Sub复制代码第十种 Shaker Sort1.Public Sub ShakerSort(ByRef lngArray() As Long)2.Dim iLower As Long3.Dim iUpper As Long4.Dim iInner As Long5.Dim iLBound As Long6.Dim iUBound As Long7.Dim iTemp As Long8.Dim iMax As Long9.Dim iMin As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)13.14.iLower = iLBound - 115.iUpper = iUBound + 116.17.Do While iLower < iUpper18.19.iLower = iLower + 120.iUpper = iUpper - 121.22.iMax = iLower23.iMin = iLower24.25.'Find the largest and smallest values in the subarray26.For iInner = iLower To iUpper27.If lngArray(iInner) > lngArray(iMax) Then28.iMax = iInner29.ElseIf lngArray(iInner) < lngArray(iMin) Then30.iMin = iInner31.End If32.Next iInner33.34.'Swap the largest with last slot of the subarray35.iTemp = lngArray(iMax)36.lngArray(iMax) = lngArray(iUpper)37.lngArray(iUpper) = iTemp38.39.'Swap the smallest with the first slot of the subarray40.iTemp = lngArray(iMin)41.lngArray(iMin) = lngArray(iLower)42.lngArray(iLower) = iTemp43.44.Loop45.End Sub复制代码。

(完整word版)VB冒泡排序专题

VB 冒泡排序专题班级姓名知识点回顾：1、冒泡排序的特征：从后往前两两比较数据，不符合大小关系的两数交换至达到要求。

2、关于冒泡需理解：※升序：将后数小于前数的两个数进行交换；降序：将后数大于前数的两数进行交换；※N 个数最多进行N-1遍排序；两数比较的次数最多为N*(N-1)/2；两数交换次数最多为：N*(N-1)/2； ※冒泡有很多改进算法，在练习中要加强理解和记录；3、冒泡经典代码：( 以降序为例 )冒泡经典算法默认数据从后往前冒，第一次比较的两个数一定是a(n)与a(n-1)，一定是先把最值放a(1)中；而事实上冒泡也可以从前往后冒，第一次比较的两个数一定是a(1)与a(2)，一定是先把最值放在a(n)中。

4、字符串的排序：可以排序，按照字符的ASCII 码。

从第一个字符开始比较，直到比出大小，即当字符串第一个字符一样时，按照第二个字母的ASCII 码排，以此类推。

例: “bcd ”大于“adb ”，“efad ”小于“efcd ”。

巩固练习：1、在运动会上，男生第一组6位选手的百米成绩（单位：秒）分别是“13.4、12.3、11.2、13.8、13.1、11.0”，若使用冒泡排序法将该组的成绩按第一名、第二名、第三名……的顺序排序，则第一遍排序后的顺序是（）；两遍排序后的顺序是（）;A. 11.0 11.2 13.8 13.4 12.3 13.1B.11.0 12.3 11.2 13.8 13.1 13.4C. 11.0 11.2 13.4 12.3 13.1 13.8D.11.0 13.4 12.3 11.2 13.8 13.12、有一组10个数据的无序序列，利用冒泡排序算法进行从小到大的排序，需要比较的次数和最多交换的次数，最多需要进行加工的遍数分别为（）A. 9，45，9B. 45，15，9C.45，45，9D.15，45，83、在NBA某赛季中，快船队5场比赛得分依次为97，89，111，70，90，若采用冒泡排序算法对其进行从小到大排序，在整个排序过程中，数据97被交换的次数是( )A．1次 B．2次 C．3次 D．4次4、对存储在stu ( 0 to n )中的n+1个元素用冒泡排序算法进行排序，元素交换次数的范围和元素比较次数的值分别为（）A、[0，n]，（n-1）*n/2B、[1，（n+1）*n/2]，（n-1）*n/2C、[0，（n+1）*n/2]，（n+1）*n/2D、[1，n-1]，（n+1）*n/25、下列关于排序的算法，不正确的是（）A．对 N 个数组元素进行排序，冒泡排序和选择排序排序的遍数一样B．对 N 个数组元素进行排序，冒泡排序和选择排序比较的次数一样C．对 N 个数组元素进行排序，冒泡排序和选择排序在排序过程中交换次数一样D．一般情况下，选择排序比冒泡排序效率更高6、有如下程序段:For i=7 to 5 step -1For j=7 to 9-i step -1If a(j)>a(j-1) thenk=a(j):a(j)=a(j-1):a(j-1)=kEnd ifNext jNext i数组元素a(1)到a(7)的数据依次为3，9，1，5，8，6，2 经过该程序段加工后，a(1)到a(3)排列为( ) A．1 2 3 B． 9 8 6 C． 3 9 1 D． 8 6 57、有如下VB程序段，已知数组a中有10个元素，保存的数据分别为：56、21、18、64、72、49、3、7、22、80，则程序运行后变量m的值为○1m=0:i=1Do while i<=10if m<a(i) then m=a(i)i=i+1Loop8、以下程序段的功能是找到a(0)．．．．．中最小值．．．并显示在label1上，请填空：．．．．到．a(99)m=a(0)For i=1 to 99if ○1 then m=a(i)next i○29、以下程序段的功能是找到a(1)到a(10)中最大值存储在a(10)．．．．．中并打印在界面上，请填空：for i=1 to ○1if a(i)>a(i+1) then t=a(i):a(i)=a(i+1):a(i+1)=tNext iprint ○210、数组a（1 to 10) 中保存的数据依次分别为：80、7、56、21、18、64、72、49、38、22，则程序运行后变量m 的值为○1 j 的值为○2 text1.text 中显示的内容为○3 。

vba排序方法

vba排序方法在VBA中，有多种排序方法。

其中一种是冒泡排序，还有选择排序、希尔排序、堆排序、桶排序、插入排序和快速排序等。

这些排序方法可以用于对数组或列表进行排序。

以下是一个使用冒泡排序的VBA代码示例：```vbaSub BubbleSort(MyArray() As Integer, ByVal nOrder As eOrderType) Dim Index As IntegerDim TEMP As IntegerDim NextElement As IntegerNextElement = 0Do While NextElement < UBound(MyArray)Index = UBound(MyArray)Do While Index > NextElementIf nOrder = ASCENDING_ORDER ThenIf MyArray(Index) < MyArray(Index - 1) Then TEMP = MyArray(Index)MyArray(Index) = MyArray(Index - 1)MyArray(Index - 1) = TEMPEnd IfElseIf nOrder = DESCENDING_ORDER ThenIf MyArray(Index) > MyArray(Index - 1) Then TEMP = MyArray(Index)MyArray(Index) = MyArray(Index - 1)MyArray(Index - 1) = TEMPEnd IfEnd IfIndex = Index - 1LoopNextElement = NextElement + 1LoopEnd Sub```以上代码实现了冒泡排序，可以根据需要选择升序或降序。

[整理]冒泡法排序的基本思想及VB程序实现

冒泡排序的基本思想
算法描述：
升序排列：从第一个元素开始，对数组中两两相邻的元素比较，将值较小的元素放在前面，值较大的元素放在后面，一轮比较完毕，一个最大的数沉底成为数组中的最后一个元素，一些较小的数如同气泡一样上浮一个位置。

n个数，经过n-1轮比较后完成排序。

假定有下标为0～n的n+1个数的序列，要求按升序排列，实现的步骤如下：
(1)从第0个元素开始与后一个比较，如果比后大两元素交换，依次比较到第n个元素，最终将最大的数换入第n个元素中，a(n)不动
(2)重复(1) ，依次比较到第n-1个元素，最终将最大的数换入第n-1个元素中，a(n-1)不动
(3)重复(1) ，依次比较到第n-2个元素，最终将最大的数换入第n-2个元素中，a(n-2)不动
………………………………………
(n)a(0)与a(1)比较，如果a(0)大，与a(1)交换，a(0)最小。

vb数组排序

算法：举例：随机产生20个100以内的正整数，按从小到大的顺序输出在窗体上，每行5个。

Private sub form_click()Dim x(1 to 20) as integerFor i=1 to 20X(i)=int(rnd*99)+1 ‘随机产生100以内的随机数Next iRem 冒泡排序For i=1 to 19For j=1 to 20-iIf x(j)>x(j+1) then t=x(j) : x(j)=x(j+1) : x(j+1)=tNext jNext iRem 按每行5个数输出Print x(i);If i mod 5=0 then print ‘如果每行输到5个数，则换行End sub二、比较交换法算法思路：假设第一个数最小，然后第一个数依次与后面的每一个数都进行比较，若比较时发现后面的数比第一个数小，则两数位置进行交换，全部都比较完算一轮，每一轮比较完后，第一个数是最小的数，如此进行即可完成比较排序。

For i=1 to n-1 ‘i表示比较轮数For j= i+1 t0 n ‘ J表示每轮比较次数If a(i)>a(j) then t=a(i) : a(i)=a(j) : a(j)=t ‘如果发现后面的数比前面的数小，则两数位置进行交换Next jNext i举例：有如图窗体，两个文本框、两个标签和一个命令按钮，编程实现：单击命令按钮后，随机产生10个两位正整数放在text1中，每行一个，并使用选择排序算法排序后显示在text2文本框中，也是每行一个。

三、选择排序Private Sub Command1_Click()Dim a(1 To 10) As IntegerFor i = 1 To 10 '产生10个两位正整数，并放到text1文本框中a(i) = Int(Rnd * 90) + 10Text1.Text = Text1.Text & a(i) & vbCrLfNext iRem 排序For i = 1 To 9For j = i + 1 To 10If a(i) > a(j) Then t = a(i): a(i) = a(j): a(j) = tNext jNext iRem 把排序好的数组放到text2文本框中For i = 1 To 10Text2.Text = Text2.Text & a(i) & vbCrLfNext iEnd Sub算法思路：假设第一个数最小，接着记下最小数所在的位置，然后将最小数依次与后面的每一个数都进行比较，若比较时发现后面的数比最小的数还小，则修改最小数所在位置，全部都比较完算一轮，每一轮比较完后，最小数所在的位置是否跟假设的是同一个位置，若不是，则最小数与第一个数进行交换位置，如此进行即可完成选择排序。

vb常用排序法

顺序交换法：(1) 从第一个元素开始，将它和其后的每个元素进行比较，若为逆序，就交换，比较完一轮，a(1)成为数组中的最小的元素。

(2) 对a(2)和a(n)的n-1个数进行同(1)的操作，次小的数放入a(2)中，完成第二轮排序。

(3) 进行n-1轮排序，所有的数排序完毕。

Dim a%(), i%, j%, n%For i = 1 To n - 1For j = i + 1 To nIf a(i) > a(j) Thent = a(i): a(i) = a(j): a(j) = tEnd IfNext jNext i冒泡法：(1) 从第一个元素开始，将相邻的数比较，若为逆序，就交换，比较完一轮，最大的数已沉底，成为数组中的最后一个元素a(n)(2) 对a(1)和a(n-1)的n-1个数进行同(1)的操作，次大的数放入a(n-1)中，完成第二轮排序。

(3) 进行n-1轮排序，所有的数排序完毕。

Dim a%(), i%, j%, n%For i = 1 To n - 1For j = 1 To n - iIf a(j) > a(j + 1) Thent = a(j): a(j) = a(j + 1): a(j + 1) = tEnd IfNext jNext iPrintFor i = 1 To nPrint a(i);Next i选择法(1) 从n个数的序列中选出最小的数，与第1个数交换位置；(2) 除第1个数外，其余n-1个数再按(1)的方法选出次小的数，与第2个数交换位置；(3) 重复(1)n-1遍，最后构成递增序列。

Dim a%(), i%, j%, n%For i = 1 To n – 1k=iFor j = i + 1 To nIf a(j) < a(k) Then k=jNext jif k<>i then t=a(i): a(i)=a(k): a(k)=tNext i插入法：1. 找到插入数在数组中的位置i2. 将从n到i的每个元素向后移动一个位置3. 插入数插入法1：将一个数插入到有序数列，使插入后数列仍然有序Dim a(1 To 10) As IntegerKey = Val(InputBox("输入一个数"))For i=1 to 9If a(i)>Key Then Exit Fornext iFor k = 9 To i Step -1a(k + 1) = a(k)Next ka(i) = Key插入法2：用上面的插入方法将一批数排序（从小到大），设数列中开始只有一个元素。

vb冒泡排序函数

vb冒泡排序函数（原创版）目录一、VB 冒泡排序函数的概念与原理二、VB 冒泡排序函数的实现方法三、VB 冒泡排序函数的应用实例四、VB 冒泡排序函数的优缺点分析正文一、VB 冒泡排序函数的概念与原理VB 冒泡排序函数是一种在 VB 编程语言中实现排序的函数。

它通过比较相邻的两个数，如果顺序错误就交换两个数的位置，直到所有数都排好序为止。

这个过程就像气泡在水中上升一样，因此称为冒泡排序。

二、VB 冒泡排序函数的实现方法1.定义一个内部函数，用于比较两个数并交换位置。

```vbPrivate Function CompareAndSwap(ByVal x As Integer, ByVal y As Integer) As BooleanIf x > y ThenCompareAndSwap = TrueSwap(x, y)ElseCompareAndSwap = FalseEnd IfEnd Function```2.定义冒泡排序函数，对输入的数组进行排序。

```vbPrivate Function BubbleSort(ByVal arr As Integer()) As Integer()Dim n As Integer = UBound(arr) - LBound(arr) + 1 Dim i As Integer, j As IntegerFor i = 1 To n - 1For j = 1 To n - iIf CompareAndSwap(arr(j), arr(j + 1)) Then BubbleSort = TrueEnd IfNext jNext iIf BubbleSort = False ThenReturn arrElseReturn SortArray(arr)End IfEnd Function```三、VB 冒泡排序函数的应用实例下面是一个使用 VB 冒泡排序函数对一组整数数组进行排序的示例：```vbImports SystemModule Module1Sub Main()Dim arr As Integer() = {5, 2, 3, 1, 4}Dim sortedArr As Integer() = BubbleSort(arr)Console.WriteLine("排序前的数组：")PrintArray(arr)Console.WriteLine("冒泡排序后的数组：")PrintArray(sortedArr)End SubSub PrintArray(ByVal arr As Integer())For i As Integer = 0 To UBound(arr)Console.Write(arr(i) & vbTab)NextConsole.WriteLine()End SubPrivate Function BubbleSort(ByVal arr As Integer()) As Integer()// 省略冒泡排序函数的实现End FunctionEnd Module```四、VB 冒泡排序函数的优缺点分析1.优点：（1）思路简单，易于理解；（2）稳定性高，不容易出错；（3）排序效果明显，直观易懂。

VBA排序的十种算法

在使用VBA进行写程序时，经常会做排序，下面将会给出一些常用的排序算法的实现，方便大家写程序参考，假设代码中出现了错误，欢送高手指正。

主要算法有：1、〔冒泡排序〕Bubble sort2、〔选择排序〕Selection sort3、〔插入排序〕Insertion sort4、〔快速排序〕Quick sort5、〔合并排序〕Merge sort6、〔堆排序〕Heap sort7、〔组合排序〕Comb Sort8、〔希尔排序〕Shell Sort9、〔基数排序〕Radix Sort10、Shaker Sort第一种〔冒泡排序〕Bubble sortPublic Sub BubbleSort(ByRef lngArray() As Long)Dim iOuter As LongDim iInner As LongDim iLBound As LongDim iUBound As LongDim iTemp As LongiLBound = LBound(lngArray)iUBound = UBound(lngArray)'冒泡排序For iOuter = iLBound To iUBound - 1For iInner = iLBound To iUBound - iOuter - 1'比较相邻项If lngArray(iInner) > lngArray(iInner + 1) Then'交换值iTemp = lngArray(iInner)lngArray(iInner) = lngArray(iInner + 1)lngArray(iInner + 1) = iTempEnd IfNext iInnerNext iOuterEnd Sub2、〔选择排序〕Selection sort1.Public Sub SelectionSort(ByRef lngArray() As Long)2.Dim iOuter As Long3.Dim iInner As Long4.Dim iLBound As Long5.Dim iUBound As Long6.Dim iTemp As Long7.Dim iMax As Long8.9.iLBound = LBound(lngArray)10.iUBound = UBound(lngArray)11.12.'选择排序13.For iOuter = iUBound To iLBound + 1 Step -114.15.iMax = 016.17.'得到最大值得索引18.For iInner = iLBound To iOuter19.If lngArray(iInner) > lngArray(iMax) Then iMax = iInner20.Next iInner21.22.'值交换23.iTemp = lngArray(iMax)24.lngArray(iMax) = lngArray(iOuter)25.lngArray(iOuter) = iTemp26.27.Next iOuter28.End Sub复制代码第三种〔插入排序〕Insertion sort1.Public Sub InsertionSort(ByRef lngArray() As Long)2.Dim iOuter As Long3.Dim iInner As Long4.Dim iLBound As Long5.Dim iUBound As Long6.Dim iTemp As Long7.8.iLBound = LBound(lngArray)9.iUBound = UBound(lngArray)10.11.For iOuter = iLBound + 1 To iUBound12.13.'取得插入值14.iTemp = lngArray(iOuter)15.16.'移动已经排序的值17.For iInner = iOuter - 1 To iLBound Step -118.If lngArray(iInner) <= iTemp Then Exit For19.lngArray(iInner + 1) = lngArray(iInner)20.Next iInner21.22.'插入值23.lngArray(iInner + 1) = iTemp24.Next iOuter25.End Sub复制代码第四种〔快速排序〕Quick sort1.Public Sub QuickSort(ByRef lngArray() As Long)2.Dim iLBound As Long3.Dim iUBound As Long4.Dim iTemp As Long5.Dim iOuter As Long6.Dim iMax As Long7.8.iLBound = LBound(lngArray)9.iUBound = UBound(lngArray)10.11.'假设只有一个值，不排序12.If (iUBound - iLBound) Then13.For iOuter = iLBound To iUBound14.If lngArray(iOuter) > lngArray(iMax) Then iMax = iOuter15.Next iOuter16.17.iTemp = lngArray(iMax)18.lngArray(iMax) = lngArray(iUBound)19.lngArray(iUBound) = iTemp20.21.'开始快速排序22.InnerQuickSort lngArray, iLBound, iUBound23.End If24.End Sub25.26.Private Sub InnerQuickSort(ByRef lngArray() As Long, ByVal iLeftEnd As Long, ByValiRightEnd As Long)27.Dim iLeftCur As Long28.Dim iRightCur As Long29.Dim iPivot As Long30.Dim iTemp As Long31.32.If iLeftEnd >= iRightEnd Then Exit Sub33.34.iLeftCur = iLeftEnd35.iRightCur = iRightEnd + 136.iPivot = lngArray(iLeftEnd)37.38.Do39.Do40.iLeftCur = iLeftCur + 141.Loop While lngArray(iLeftCur) < iPivot42.43.Do44.iRightCur = iRightCur - 145.Loop While lngArray(iRightCur) > iPivot46.47.If iLeftCur >= iRightCur Then Exit Do48.49.'交换值50.iTemp = lngArray(iLeftCur)51.lngArray(iLeftCur) = lngArray(iRightCur)52.lngArray(iRightCur) = iTemp53.Loop54.55.'递归快速排序56.lngArray(iLeftEnd) = lngArray(iRightCur)57.lngArray(iRightCur) = iPivot58.59.InnerQuickSort lngArray, iLeftEnd, iRightCur - 160.InnerQuickSort lngArray, iRightCur + 1, iRightEnd61.End Sub复制代码第五种〔合并排序〕Merge sort1.Public Sub MergeSort(ByRef lngArray() As Long)2.Dim arrTemp() As Long3.Dim iSegSize As Long4.Dim iLBound As Long5.Dim iUBound As Long6.7.iLBound = LBound(lngArray)8.iUBound = UBound(lngArray)9.10.ReDim arrTemp(iLBound To iUBound)11.12.iSegSize = 113.Do While iSegSize < iUBound - iLBound14.15.'合并A到B16.InnerMergePass lngArray, arrTemp, iLBound, iUBound, iSegSize17.iSegSize = iSegSize + iSegSize18.19.'合并B到A20.InnerMergePass arrTemp, lngArray, iLBound, iUBound, iSegSize21.iSegSize = iSegSize + iSegSize22.23.Loop24.End Sub25.26.Private Sub InnerMergePass(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByValiLBound As Long, iUBound As Long, ByVal iSegSize As Long)27.Dim iSegNext As Long28.29.iSegNext = iLBound30.31.Do While iSegNext <= iUBound - (2 * iSegSize)32.'合并33.InnerMerge lngSrc, lngDest, iSegNext, iSegNext + iSegSize - 1, iSegNext + iSegSize+ iSegSize - 134.35.iSegNext = iSegNext + iSegSize + iSegSize36.Loop37.38.If iSegNext + iSegSize <= iUBound Then39.InnerMerge lngSrc, lngDest, iSegNext, iSegNext + iSegSize - 1, iUBound40.Else41.For iSegNext = iSegNext To iUBound42.lngDest(iSegNext) = lngSrc(iSegNext)43.Next iSegNext44.End If45.46.End Sub47.48.Private Sub InnerMerge(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByValiStartFirst As Long, ByVal iEndFirst As Long, ByVal iEndSecond As Long)49.Dim iFirst As Long50.Dim iSecond As Long51.Dim iResult As Long52.Dim iOuter As Long53.54.iFirst = iStartFirst55.iSecond = iEndFirst + 156.iResult = iStartFirst57.58.Do While (iFirst <= iEndFirst) And (iSecond <= iEndSecond)59.60.If lngSrc(iFirst) <= lngSrc(iSecond) Then61.lngDest(iResult) = lngSrc(iFirst)62.iFirst = iFirst + 163.Else64.lngDest(iResult) = lngSrc(iSecond)65.iSecond = iSecond + 166.End If67.68.iResult = iResult + 169.Loop70.71.If iFirst > iEndFirst Then72.For iOuter = iSecond To iEndSecond73.lngDest(iResult) = lngSrc(iOuter)74.iResult = iResult + 175.Next iOuter76.Else77.For iOuter = iFirst To iEndFirst78.lngDest(iResult) = lngSrc(iOuter)79.iResult = iResult + 180.Next iOuter81.End If82.End Sub复制代码第六种〔堆排序〕Heap sort1.Public Sub HeapSort(ByRef lngArray() As Long)2.Dim iLBound As Long3.Dim iUBound As Long4.Dim iArrSize As Long5.Dim iRoot As Long6.Dim iChild As Long7.Dim iElement As Long8.Dim iCurrent As Long9.Dim arrOut() As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)13.iArrSize = iUBound - iLBound14.15.ReDim arrOut(iLBound To iUBound)16.17.'Initialise the heap18.'Move up the heap from the bottom19.For iRoot = iArrSize \ 2 To 0 Step -120.21.iElement = lngArray(iRoot + iLBound)22.iChild = iRoot + iRoot23.24.'Move down the heap from the current position25.Do While iChild < iArrSize26.27.If iChild < iArrSize Then28.If lngArray(iChild + iLBound) < lngArray(iChild + iLBound + 1) Then29.'Always want largest child30.iChild = iChild + 131.End If32.End If33.34.'Found a slot, stop looking35.If iElement >= lngArray(iChild + iLBound) Then Exit Do36.37.lngArray((iChild \ 2) + iLBound) = lngArray(iChild + iLBound)38.iChild = iChild + iChild39.Loop40.41.'Move the node42.lngArray((iChild \ 2) + iLBound) = iElement43.Next iRoot44.45.'Read of values one by one (store in array starting at the end)46.For iRoot = iUBound To iLBound Step -147.48.'Read the value49.arrOut(iRoot) = lngArray(iLBound)50.'Get the last element51.iElement = lngArray(iArrSize + iLBound)52.53.iArrSize = iArrSize - 154.iCurrent = 055.iChild = 156.57.'Find a place for the last element to go58.Do While iChild <= iArrSize59.60.If iChild < iArrSize Then61.If lngArray(iChild + iLBound) < lngArray(iChild + iLBound + 1) Then62.'Always want the larger child63.iChild = iChild + 164.End If65.End If66.67.'Found a position68.If iElement >= lngArray(iChild + iLBound) Then Exit Do69.70.lngArray(iCurrent + iLBound) = lngArray(iChild + iLBound)71.iCurrent = iChild72.iChild = iChild + iChild73.74.Loop75.76.'Move the node77.lngArray(iCurrent + iLBound) = iElement78.Next iRoot79.80.'Copy from temp array to real array81.For iRoot = iLBound To iUBound82.lngArray(iRoot) = arrOut(iRoot)83.Next iRoot84.End Sub复制代码第七种〔组合排序〕Comb Sort1.Public Sub CombSort(ByRef lngArray() As Long)2.Dim iSpacing As Long3.Dim iOuter As Long4.Dim iInner As Long5.Dim iTemp As Long6.Dim iLBound As Long7.Dim iUBound As Long8.Dim iArrSize As Long9.Dim iFinished As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)14.'Initialise comb width15.iSpacing = iUBound - iLBound16.17.Do18.If iSpacing > 1 Then19.iSpacing = Int(iSpacing / 1.3)20.21.If iSpacing = 0 Then22.iSpacing = 1 'Dont go lower than 123.ElseIf iSpacing > 8 And iSpacing < 11 Then24.iSpacing = 11 'This is a special number, goes faster than 9 and 1025.End If26.End If27.28.'Always go down to 1 before attempting to exit29.If iSpacing = 1 Then iFinished = 130.31.'Combing pass32.For iOuter = iLBound To iUBound - iSpacing33.iInner = iOuter + iSpacing34.35.If lngArray(iOuter) > lngArray(iInner) Then36.'Swap37.iTemp = lngArray(iOuter)38.lngArray(iOuter) = lngArray(iInner)39.lngArray(iInner) = iTemp40.41.'Not finished42.iFinished = 043.End If44.Next iOuter46.Loop Until iFinished47.End Sub复制代码第八种〔希尔排序〕Shell Sort1.Public Sub ShellSort(ByRef lngArray() As Long)2.Dim iSpacing As Long3.Dim iOuter As Long4.Dim iInner As Long5.Dim iTemp As Long6.Dim iLBound As Long7.Dim iUBound As Long8.Dim iArrSize As Long9.10.iLBound = LBound(lngArray)11.iUBound = UBound(lngArray)12.13.'Calculate initial sort spacing14.iArrSize = (iUBound - iLBound) + 115.iSpacing = 116.17.If iArrSize > 13 Then18.Do While iSpacing < iArrSize19.iSpacing = (3 * iSpacing) + 120.Loop21.22.iSpacing = iSpacing \ 923.End If24.25.'Start sorting26.Do While iSpacing28.For iOuter = iLBound + iSpacing To iUBound29.30.'Get the value to be inserted31.iTemp = lngArray(iOuter)32.33.'Move along the already sorted values shifting along34.For iInner = iOuter - iSpacing To iLBound Step -iSpacing35.'No more shifting needed, we found the right spot!36.If lngArray(iInner) <= iTemp Then Exit For37.38.lngArray(iInner + iSpacing) = lngArray(iInner)39.Next iInner40.41.'Insert value in the slot42.lngArray(iInner + iSpacing) = iTemp43.Next iOuter44.45.'Reduce the sort spacing46.iSpacing = iSpacing \ 347.Loop48.49.End Sub复制代码第九种〔基数排序〕Radix Sort1.Public Sub RadixSort(ByRef lngArray() As Long)2.Dim arrTemp() As Long3.Dim iLBound As Long4.Dim iUBound As Long5.Dim iMax As Long6.Dim iSorts As Long7.Dim iLoop As Long8.9.iLBound = LBound(lngArray)10.iUBound = UBound(lngArray)11.12.'Create swap array13.ReDim arrTemp(iLBound To iUBound)14.15.iMax = &H8000000016.'Find largest17.For iLoop = iLBound To iUBound18.If lngArray(iLoop) > iMax Then iMax = lngArray(iLoop)19.Next iLoop20.21.'Calculate how many sorts are needed22.Do While iMax23.iSorts = iSorts + 124.iMax = iMax \ 25625.Loop26.27.iMax = 128.29.'Do the sorts30.For iLoop = 1 To iSorts31.32.If iLoop And 1 Then33.'Odd sort -> src to dest34.InnerRadixSort lngArray, arrTemp, iLBound, iUBound, iMax35.Else36.'Even sort -> dest to src37.InnerRadixSort arrTemp, lngArray, iLBound, iUBound, iMax38.End If39.40.'Next sort factor41.iMax = iMax * 25642.Next iLoop43.44.'If odd number of sorts we need to swap the arrays45.If (iSorts And 1) Then46.For iLoop = iLBound To iUBound47.lngArray(iLoop) = arrTemp(iLoop)48.Next iLoop49.End If50.End Sub51.52.Private Sub InnerRadixSort(ByRef lngSrc() As Long, ByRef lngDest() As Long, ByValiLBound As Long, ByVal iUBound As Long, ByVal iDivisor As Long)53.Dim arrCounts(255) As Long54.Dim arrOffsets(255) As Long55.Dim iBucket As Long56.Dim iLoop As Long57.58.'Count the items for each bucket59.For iLoop = iLBound To iUBound60.iBucket = (lngSrc(iLoop) \ iDivisor) And 25561.arrCounts(iBucket) = arrCounts(iBucket) + 162.Next iLoop63.64.'Generate offsets65.For iLoop = 1 To 25566.arrOffsets(iLoop) = arrOffsets(iLoop - 1) + arrCounts(iLoop - 1) + iLBound67.Next iLoop68.69.'Fill the buckets70.For iLoop = iLBound To iUBound71.iBucket = (lngSrc(iLoop) \ iDivisor) And 25572.lngDest(arrOffsets(iBucket)) = lngSrc(iLoop)73.arrOffsets(iBucket) = arrOffsets(iBucket) + 174.Next iLoop75.End Sub复制代码第十种 Shaker Sort1.Public Sub ShakerSort(ByRef lngArray() As Long)2.Dim iLower As Long3.Dim iUpper As Long4.Dim iInner As Long5.Dim iLBound As Long6.Dim iUBound As Long7.Dim iTemp As Long8.Dim iMax As Long9.Dim iMin As Long10.11.iLBound = LBound(lngArray)12.iUBound = UBound(lngArray)13.14.iLower = iLBound - 115.iUpper = iUBound + 116.17.Do While iLower < iUpper18.19.iLower = iLower + 120.iUpper = iUpper - 121.22.iMax = iLower23.iMin = iLower24.25.'Find the largest and smallest values in the subarray26.For iInner = iLower To iUpper27.If lngArray(iInner) > lngArray(iMax) Then28.iMax = iInner29.ElseIf lngArray(iInner) < lngArray(iMin) Then30.iMin = iInner31.End If32.Next iInner33.34.'Swap the largest with last slot of the subarray35.iTemp = lngArray(iMax)36.lngArray(iMax) = lngArray(iUpper)37.lngArray(iUpper) = iTemp38.39.'Swap the smallest with the first slot of the subarray40.iTemp = lngArray(iMin)41.lngArray(iMin) = lngArray(iLower)42.lngArray(iLower) = iTemp43.44.Loop45.End Sub复制代码。

VB冒泡法排序原理

回到流程图
总
结
本次课主要内容： 1.冒泡法基本思想，通过n-1趟排序把n个待排序数大的元素象石头一样往下沉（放在最后），小的元素象气泡一样往上浮。 2.冒泡法的流程图 3.冒泡法程序 4.冒泡法中swap变量的作用 5.简述了选择法排序，要求回去预习选择法排序。
例1:用冒泡排序法对8个整数{6,8,5,4,6,9,3,2}进行从小到大排序.
看图示
冒泡法原理
第二:再对a[0]到a[N-2]的范围内再进行一趟冒泡,又将该范围内的最大值换到了a[N-2]中. 看图示二第三:依次进行下去,最多只要进行N-1趟冒泡,就可完成排序.
看图示三
第四:如果在某趟冒泡过程中没有交换相邻的值,则说明排序已完成,可以提前结束处理.
for(i=0;i<8;i++) printf("%d,",a[i]); printf("\n"); }
注：对n个元素冒泡排序第i趟排序的待排序元素是a[0]到a[n-i-1]。这里的i表示数组的下标.
上一页
回到第四点
流程图比较
冒泡法
swap 变量的作用
如果在某趟冒泡过程中没有交换相邻的值,则说明排序已完成,可以提前结束处理. 比如：为原始数列：8、15、27、96、32、65、78、79 这个序列用冒泡法排序，一趟之后就得到升序结果，而之后的六趟都可以不要进行。所以，swap变量就是用来标识如果某趟排序之后已经得到最终结果，则多余的次数就无须进行。
Swap变量作用
看流程
冒泡法排序
现假设有8个随机数已经在数组中，开始排序
初始状态：第一趟排序：第一趟最后结果：两两相邻比较： 6 数组a

VB常用的算法——排序

VB常考算法（八）排序：1、算法1）选择法排序算法说明：根据上例中求最小值的思路，我们可以使用如下方法进行从小到大排序：第一轮，以第一个元素逐个跟后面的所有元素比较，如果比后面的元素大就进行交换，经过一轮比较，第一个元素被确定为最小；同样的方法，下一轮以第二个元素跟剩下的所有元素进行比较确定下次小的元素；以此类推…下面我们以图形的形式体现对5个数进行选择排序的过程：第一轮：第二轮：第三轮：从上图可以发现对5个元素进行排序，总共经过了5-1=4轮，而每一轮中比较的次数也不相同，第一轮2、3、4、5号元素参与跟1号元素的比较，共4次，第二轮3、4、5号元素参与跟2号元素的比较，共3次，以次类推，比较次数逐步减少。

经过四轮的比较，利用逐步求最小值的方法将5个数从小到大排好序。

对于这样一个排序的过程，我们可以使用两个循环分别控制比较的轮数和每一轮的次数。

程序代码：Private Sub Command1_Click()Dim n As Integern = InputBox("请输入数组元素的个数：")Dim a() As Integer, i As Integer, j As IntegerPrint "排序前："ReDim a(n)For i = 1 To na(i) = Int(Rnd * (99 - 10 + 1) + 10)Print a(i);最小值次小值Next iFor i = 1 To n - 1For j = i To nIf a(i) > a(j) Thentemp = a(i) '交换元素a(i) = a(j)a(j) = tempEnd IfNext jNext iPrintPrint "排序后:"For i = 1 To nPrint a(i);Next iEnd Sub2）冒泡法排序算法说明：相邻的元素进行比较，如果前面的元素比后面的元素大，则将它们进行交换，具体思路：设在数组a 中存放n 个元素，第一轮，将a(1)和a(2)进行比较，若a(1)>a(2),则交换这两个元素的值，然后继续用a(2)和a(3)比较，若a(1)>a(2)，则交换这两个元素的值，以此类推，直到a(n-1)和a(n)进行比较处理后，a(n)中就存放了n 个数中最大的值；第二轮，用a(1)与a(2),a(2)与a(3),…,a(n-2)与a(n-1)进行比较，处理方法相同，这一轮下来，a(n-1)中存放n 个数中第二大的值；…；第n-1轮，a(1)与a(2)进行比较处理，确保最小值在a(1)中。

vba冒泡排序原理 -回复

vba冒泡排序原理-回复VBA冒泡排序原理在编程中，冒泡排序是一种非常基础的排序算法，用于将一组数据按照一定的顺序重新排列。

VBA（Visual Basic for Applications）是一种在微软Office套件中使用的编程语言，广泛应用于Excel、Access等软件。

冒泡排序是一种简单直观的排序算法，其基本思想是通过相邻元素的比较和交换，将较大（或较小）的元素逐渐“冒泡”到待排序序列的末尾。

这个过程类似于气泡在水中升起的过程，因此得名冒泡排序。

在VBA中实现冒泡排序需要以下几个步骤：1. 定义变量：首先需要定义几个变量，包括一个用于临时存储数值的变量，以及两个用于循环的变量。

例如，可以定义一个名为temp的变量来存储需要交换的数值，以及名为i和j的两个变量来控制循环。

2. 循环比较和交换：使用两层嵌套的循环，外层循环控制需要比较和交换的轮数，内层循环用于比较和交换相邻元素。

假设待排序的数组名为arr，数组长度为n，则需要进行n-1轮的循环。

3. 比较相邻元素：从数组的第一个元素开始，依次与其后的元素进行比较。

如果数组中前一个元素大于后一个元素（升序排序），则交换这两个元素的位置，否则继续比较下一对元素。

4. 交换元素位置：在比较后，如果需要交换元素，则将较大（或较小）的元素赋值给temp变量，再将较小（或较大）的元素赋值给较大（或较小）的位置，最后将temp的值赋值给较小（或较大）的位置，完成两个元素位置的交换。

5. 循环结束条件：每一轮的循环结束后，最大（或最小）的元素都会被冒泡到当前待排序序列的末尾，因此内层循环的结束条件需要逐步缩小待排序序列的范围。

6. 重复操作：重复执行上述步骤，直到所有元素都按照指定的顺序排列好。

下面是一个用VBA实现冒泡排序的示例代码：vbaSub BubbleSort(arr() As Integer)Dim i As Integer, j As IntegerDim temp As IntegerFor i = 0 To UBound(arr) - 1For j = 0 To UBound(arr) - i - 1If arr(j) > arr(j + 1) Thentemp = arr(j)arr(j) = arr(j + 1)arr(j + 1) = tempEnd IfNext jNext iEnd SubSub TestBubbleSort()Dim arr() As IntegerDim i As Integer' 初始化数组ReDim arr(1 To 10) As Integerarr(1) = 5: arr(2) = 3: arr(3) = 8arr(4) = 2: arr(5) = 1: arr(6) = 9arr(7) = 7: arr(8) = 4: arr(9) = 6arr(10) = 0' 调用冒泡排序函数BubbleSort arr' 输出排序后的数组For i = 1 To UBound(arr)Debug.Print arr(i)Next iEnd Sub通过上述示例代码，我们可以看到VBA中冒泡排序的具体实现过程。

vb 冒泡排序法

vb 冒泡排序法冒泡排序法是一种简单易懂的排序算法，它通过反复交换相邻的元素将序列中最大（或最小）的数逐渐“冒泡”到数列的一端。

下面就让我们来看一下如何用VB编写冒泡排序算法。

在VB中，我们可以使用嵌套循环来实现冒泡排序。

外层循环控制比较的轮次，内层循环用来进行相邻元素的比较和交换。

下面是冒泡排序算法的具体实现：```Sub BubbleSort(arr() As Integer)Dim i As IntegerDim j As IntegerDim n As IntegerDim temp As Integern = UBound(arr)For i = 0 To n - 1For j = 0 To n - i - 1If arr(j) > arr(j + 1) Thentemp = arr(j)arr(j) = arr(j + 1)arr(j + 1) = tempEnd IfNext jNext iEnd Sub```以上代码定义了一个名为`BubbleSort`的子程序（Subroutine），接受一个整数数组作为参数。

在子程序中，我们首先定义了几个局部变量，包括索引变量`i`和`j`、数组长度变量`n`，以及用来交换元素的临时变量`temp`。

接下来，我们使用两层嵌套循环来进行排序。

外层循环`i`控制比较的轮次，它从0开始，逐渐增加到`n-1`。

内层循环`j`用来进行相邻元素的比较和交换。

由于每一轮比较后，最大的元素已经“冒泡”到了数列的最后，所以内层循环只需要进行`n-i-1`次比较。

在每次比较中，我们判断当前元素是否大于其相邻元素，如果是，则交换这两个元素的位置。

通过不断进行比较和交换，最大（或最小）的数就会逐渐“冒泡”到数列的一端，从而实现排序。

最后，我们通过主程序调用`BubbleSort`子程序，并传入需要排序的数组。

下面是一个示例：```Sub Main()Dim arr() As Integer = {64, 34, 25, 12, 22, 11, 90}Dim i As IntegerBubbleSort(arr)For i = 0 To UBound(arr)Console.Write(arr(i) & " ")Next iConsole.ReadKey()End Sub```以上是使用VB编写的冒泡排序算法的一种实现方法。

vba冒泡排序原理

vba冒泡排序原理VBA 冒泡排序原理冒泡排序是一种简单但效率较低的排序算法，它通过重复地交换相邻的元素来将最大或最小的元素逐渐“冒泡”到数列的一端。

本文将介绍冒泡排序的原理和实现过程。

1. 原理概述冒泡排序的基本思想是从数列的第一个元素开始，比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。

通过一轮比较，可以确保最大的元素“冒泡”到数列的末尾。

然后，对剩余的元素重复相同的操作，直到整个数列有序。

2. 算法步骤冒泡排序的核心步骤包括以下几个：2.1 比较相邻元素从数列的第一个元素开始，依次比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。

2.2 一轮比较后的结果经过一轮比较后，最大的元素将“冒泡”到数列的末尾。

2.3 重复比较操作对剩余的元素重复相同的比较操作，直到整个数列有序。

3. VBA 实现以下是使用 VBA 实现冒泡排序的代码示例：```vbaSub BubbleSort(arr() As Variant)Dim i As LongDim j As LongDim temp As VariantFor i = LBound(arr) To UBound(arr) - 1For j = LBound(arr) To UBound(arr) - i - 1If arr(j) > arr(j + 1) Thentemp = arr(j)arr(j) = arr(j + 1)arr(j + 1) = tempEnd IfNext jNext iEnd Sub```4. 示例说明上述代码中，我们定义了一个名为 BubbleSort 的子过程，该过程接受一个变量 arr，即待排序的数列。

通过嵌套的两个 For 循环，实现了冒泡排序的算法。

在内层的循环中，我们比较相邻的元素，并根据大小关系进行交换。

通过外层的循环，我们可以确保每一轮比较后，最大的元素都会“冒泡”到数列的末尾。

绝对简单易学的VB教程——冒泡法排序

a(i) = Val(InputBox("输入一个数"))
Next i
For i=1 to 4
For j=1 To 5-i
if a(j)>a(j+1) Then
t=a(j): a(j)=a(j+1): a(j+1)=t
End if
Next j
Next i
For i = 1 To 5
冒泡排序
Print a(i);
第一轮的比较过程 For j=2 To 5
if(a(1)>a(j)) Then t=a(1) : a(1)=a(j) : a(j)=t
End if Next j
2、顺序交换法
现在重复上述算法：把a(2)到a(5)中的最小数放在 a(2)中，a(3)到a(5)中的最小数放在a(3)中，a(4) 与a(5)中的最小数放在a(4)中。这样一共经过4次选小就把a(1)到a(5)中的数进行由小到大排序。
就交换，比较完一轮，最大的数已沉底，成为数组中的最后一个元素a(n)
(2) 对a(1)和a(n-1)的n-1个数进行同(1)的操作，次大的数放入a(n-1)中，完成第二轮排序。
(3) 进行n-1轮排序，所有的数排序完毕。
1.冒泡法
n个数冒泡法递增排序程序清单：
Dim a%(), i%, j%, n% n = InputBox("请输入一个正整数") ReDim a(1 To n) For i = 1 To n a(i) = Int(Rnd * 100) : Print a(i); Next i For i = 1 To n - 1 For j = 1 To n - i If a(j) > a(j + 1) Then t = a(j): a(j) = a(j + 1): a(j + 1) = t End If Next j

冒泡排序法（VB）

冒泡排序法（VB）
冒泡排序法是简单的排序方法之一，它和气泡从水中往上冒的情况有
些类似。

其具体做法是（动画演示）：
（1）对于数组a中的1至n个数据，先将第n个和第n-1个数据进行比较，如果
a(n)<>< p=""><>
然后比较第n-1个和第n-2个数据；依次类推，直到第2个数据和第1个数据
进行比较交换，这称为一趟冒泡。

这一趟最明显的效果是：将最小的数据传到了
第1位。

由此还可推断出，对于n个数，一趟应该进行n-1 次比较操作。

算法流程如
下图所示：
（2）然后，对2至n个数据进行同样操作，则具有次小值的数据被安置在第2位
上。

（3）重复以上过程，每次的移动都向最终排序的目标前进，直至没有数据需要
交换为止。

这种排序的方法被形象地比喻成“冒泡”，在排序过程中，小的数就如气泡一
般逐层上冒，而大的数逐个下沉。

练习：随机产生10个整数，并用冒泡法排序（从小到大）。

参考：。