VB NET实现选择排序与冒泡排序
vb冒泡排序法
冒泡排序法
冒泡排序法是简单的排序方法之一,它和气泡从水中往上冒的情况有些类似(动画演示):这里我给大家讲一下从小到大排序〈升序排列〉。
升序排列:对数组
中两两相邻的元素比较将植较小的元告放在前面,值权‘的元素放在后面,比较完毕后,一个最大“数沉底成为数组中的最后一个元素,一些较小的数如同气泡一样上浮一个位置。
其具体做法是有很多种,下面我给大家常见的两种:
方法1 (从前往后大的数向后下沉)
从第1个元素开始与后一个比较,如果比后一个大则两元素交换,依次比较到第n个元素,最终将最大的数换入第n个元素中,a(n)不动。
2)重复(1),依次比较到第n-1个元素,最终将最大的数换入第n-1个元素中,a(n-1)不动。
⑶重复⑴,依次比较到第0-2个元素,最终将最大的数换入第n-2个元素中,a(n-2)不动。
进行比较
(n-1)a⑴与a⑵比较,如果a(1〉大,与a⑵交换。
反之,排序完成。
方法1的核心代码
方法2 (从后往前小的数向前上升)
从第0个元素开始与前一个比较,如果比前一个小两元素交换,依次比较到第1个元素,最终将最小的数换入第1个元素中,a(1)不动
⑵重复(1),依次比较到第2个元素,最终将最小的数换入第2个元素中,a(2〕
不动
⑶重复(1),依次比较到第3个元素,最终将最小的数换入第3个元素中,a(3〕
不动
进行比较
(n-1)a(n)与a(n-1)比较,如果a(n)小,与a(n-1)交换,反之,排序完成。
方法2的核心代码。
VB常用算法总结大全
VB常用算法总结大全VB(Visual Basic)是一种对初学者友好的编程语言,因其简单易学的特点而受到很多人的喜爱。
在VB中,算法是编程过程中非常重要的一部分,它们用来解决各种问题,从简单的数学计算到复杂的数据处理。
本文将总结一些常用的算法,帮助VB程序员更好地应用于实际项目中。
一、排序算法1.冒泡排序冒泡排序是一种简单的排序算法,它通过不断地交换相邻的元素来对数据进行排序。
它的基本思想是从列表的第一个元素开始,依次比较相邻的两个元素,如果顺序不正确,则交换它们的位置。
重复这个过程,直到整个列表都已经排序。
2.快速排序快速排序是一种高效的排序算法,它通过选择一个基准元素,将列表分为两部分,一部分小于基准元素,一部分大于基准元素。
然后对这两部分分别进行快速排序,最后将它们合并在一起。
3.插入排序插入排序是一种简单直观的排序算法,它将列表分为已排序和未排序两部分,每次选择未排序部分的第一个元素,并插入到已排序部分的适当位置。
重复这个过程,直到整个列表都已经排序。
二、查找算法1.顺序查找顺序查找是一种简单的查找算法,它从列表的第一个元素开始,依次比较每个元素,直到找到目标元素或者遍历完整个列表。
2.二分查找二分查找是一种高效的查找算法,它要求列表已经排序。
它通过比较目标元素与列表中间元素的大小关系来确定要的部分,并缩小范围。
重复这个过程,直到找到目标元素或者确定列表中没有目标元素。
三、图算法1.深度优先(DFS)深度优先是一种用于图遍历的算法,它从一个起始点开始,沿着一个路径尽可能深地访问节点,直到遇到一个没有未访问过的相邻节点为止。
然后回溯到前一个节点,寻找其他路径。
2.广度优先(BFS)广度优先也是一种用于图遍历的算法,它从一个起始点开始,依次访问所有与起始点相邻的节点,然后再依次访问这些节点的相邻节点,直到遍历完图中的所有节点。
四、动态规划动态规划是一种解决多阶段决策问题的方法,它将问题分解为若干个阶段,并定义状态和决策。
vbnet数组排序方法
(原创实用版5篇)编制人员:_______________审核人员:_______________审批人员:_______________编制单位:_______________编制时间:____年___月___日序言下面是本店铺为大家精心编写的5篇《vbnet数组排序方法》,供大家借鉴与参考。
下载后,可根据实际需要进行调整和使用,希望能够帮助到大家,谢射!(5篇)《vbnet数组排序方法》篇1在 中,可以使用内置的 `Array.Sort` 方法对数组进行排序。
该方法可以对任何类型的数组进行排序,包括整数、浮点数、字符串等。
下面是一个示例代码,演示如何使用 `Array.Sort` 方法对整数数组进行排序:```Dim numbers As Integer() = {5, 2, 8, 1, 9}Array.Sort(numbers)```在上面的代码中,我们首先定义了一个整数数组 `numbers`,其中包含了一些整数。
然后,我们使用 `Array.Sort` 方法对这个数组进行排序。
最后,我们打印出排序后的数组,以验证排序是否正确。
需要注意的是,`Array.Sort` 方法会直接修改原始数组,而不是创建一个新的排序后的数组。
如果不想修改原始数组,可以使用 `Array.Sort` 方法的重载版本,该版本会返回一个新数组,而不是修改原始数组。
《vbnet数组排序方法》篇2在 中,可以使用内置的 `Array.Sort` 方法对数组进行排序。
以下是一个示例代码:```Dim numbers As Integer() = {5, 2, 8, 1, 9}Array.Sort(numbers)```在上面的代码中,我们首先定义了一个整数类型的数组 `numbers`,然后使用 `Array.Sort` 方法对其进行排序。
该方法将按照升序对数组进行排序。
如果需要按照降序排序,可以使用 `Array.Sort` 方法的另一个重载版本,如下所示:```Array.Sort(numbers, pareMethod.Descending)```在上面的代码中,我们传递了一个 `pareMethod.Descending` 参数,该参数指定了降序排序。
VB实验 线性表基本操作 冒泡排序法
实验二线性表的基本操作一.实验目的使用数组模拟一个线性表,并完成简单的操作。
二.实验条件和环境Visual Basic6.0集成开发环境三.实验任务和要求参照主教材《大学计算机基础》中例6-2,使用数组定义一个数组型的线性表,将0-20中的奇数依次插入到线性表中,并打印该表,输出13在线性表中的位置(以0为起始位置计算),随后删除13,并再次打印该表。
四.实验步骤和操作指导(一)实验步骤(1)运行Visual Basic6.0,新建一个工程应用程序。
(2)参照主教材《大学计算机基础》中的例6-2编写程序,包括定义线性表、主过程、线性表的插入过程、删除过程、打印过程、定位过程。
(二)操作指导(1)线性表表使用如下方式定义。
(放在模块中)Type listtypedata() As Integern As IntegerEnd Type(2)程序大致如下(放在窗体中,教材中的程序)Private Sub Form_Click()Const MAX As Integer = 1000Dim list As listtypeDim i As IntegerReDim list.data(MAX)Call initiate(list)For i = 0 To 9Call insert(list, i, i + 1)Next iCall print1(list)Call insert(list, 5, 99)Call print1(list)Call delete(list, 8)Call print1(list)End Sub(实验要求程序)Private Sub Form_Click()Const MAX As Integer = 20Dim list As listtypeDim i As IntegerDim loc As IntegerReDim list.data(MAX)Call initiate(list)For i = 0 To 9Call insert(list, i, 2 * i + 1)Next iCall print1(list)loc = locate(list, 13)Form1.Print "13在线性表的位置是:"; locCall delete(list, loc)Call print1(list)End Sub(放在模块中)Sub initiate(ByRef l As listtype)l.n = 0End SubFunction getlength(ByRef l As listtype) As Integergetlenth = l.nEnd FunctionFunction getdata(ByRef l As listtype) As IntegerIf i >= 0 And i < l.n Thengetdata = l.data(i)Exit FunctionElseForm1.Print "要求的元素不存在,程序终止"EndEnd IfEnd FunctionFunction priordata(ByRef l As listtype, ByVal i As Integer) As Integer If i >= 1 And i < l.n Thenpriordata = l.data(i - 1)Exit FunctionElseForm1.Print "要求的元素不存在,程序终止"EndEnd IfEnd FunctionFunction nextdata(ByRef l As listtype, ByVal i As Integer) As Integer If i >= 0 And i < l.n - 1 Thennextdata = l.data(i + 1)Exit FunctionForm1.Print "要求的元素不存在,程序终止"EndEnd IfEnd FunctionFunction locate(ByRef l As listtype, ByVal x As Integer) As Integer Dim i As Integeri = 0Do While i < l.nIf x = l.data(i) Thenlocate = iExit FunctionEnd Ifi = i + 1Looplocate = -1End FunctionSub insert(ByRef l As listtype, ByVal i As Integer, ByVal x As Integer) Dim j As Integerj = l.nIf i >= 0 And i <= l.n ThenDo While j > il.data(j) = l.data(j - 1)j = j - 1Loopl.data(i) = xl.n = l.n + 1ElseForm1.Print "插入位置不正确!,程序终止"EndEnd IfEnd SubSub delete(ByRef l As listtype, ByVal i As Integer)If i >= 0 And i < l.n ThenDo While i < l.nl.data(i) = l.data(i + 1)i = i + 1Loopl.n = l.n - 1ElseForm1.Print "删除位置不正确,程序终止"EndEnd SubSub print1(ByRef l As listtype)Dim i As IntegerFor i = 0 To l.n - 1Form1.Print l.data(i)Next iForm1.Print "表长为:"; l.nEnd Sub实验三VB冒泡排序法一.实验目的熟悉VB集成开发环境,掌握一种排序算法,即冒泡排序法二.实验条件和环境Visual Basic6.0集成开发环境三.实验任务和要求1.将一组数据(12.5, 34, 45, 21, 67, 4, 12, 45, 47, 56)从小到大排序,要用冒泡排序法四.实验内容1.实验步骤(1)运行Visual Basic6.0,新建一个工程应用程序。
用VB实现的冒泡排序算法的分析与优化
者在上. 重者 在下 为止 。
() F r 5 o j=1T on—i
() 6
Ⅱa ) ( +1 T e 0 >ai ) h n
() 7
() 8
t 0: 0 =a =a)8 ) ( )ai ) j+1:(+1 =t
E dⅡ n
() N x j 9 et ( et 1 N xi 0
7 0
福
建 电
脑
2 1 年 第 3期 01
用V B实现 的冒泡排序 法的分析与优 化 算
刘 模 群
(常 州工 学院计 算机信 息工程 学 院 江 苏 常 州 2 3 0 10 2) 【 摘 要 】 通过 对 冒泡排 序 算法的 分析 , 出了其 效 率不 高的缺 陷 , 出了三种优 化的 方法 , : 指 给 它们 能有
() Dm nA tgrt s nee 2 i s nee, t r I AI g () n=U o n() 3 B u da
()F ri 1T 4 o = on一1 Biblioteka 21 法描述 和步骤 .算
算法 描 述 : 待排 序 的 数据 放 在数 组 a1 1 , 将 ( …n中 n 个 元 素依次垂 直排 列 , 每个元 素看 作 是重 量为其 值 ai f 1 的气 泡 根 据轻气 泡不 能在 重气 泡之下 的原则 . 从上 往 下扫 描数 组 a 凡 扫描 到 违反 本 原则 的重 气 泡 , : 就使 其 向下沉 如此反 复进行 , 到最后 任何 两个气 泡都是 轻 、 直
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)中。
vb选择排序和冒泡排序的代码
vb选择排序和冒泡排序的代码在计算机科学和程序设计语言中,选择排序和冒泡排序是两个最基本、最常用的排序算法。
虽然它们不一定是最有效率的排序算法,但它们非常简单易懂,适合初学者使用和理解。
下面我们将分步骤介绍VB选择排序和冒泡排序的代码。
VB选择排序:步骤1:定义一个数组,用于存放需要排序的元素。
Dim arr(10) As Integer步骤2:输入数据。
For i = 1 To 10arr(i) = Val(InputBox("Please enter a number"))Next步骤3:定义一个选择排序的函数。
Sub selectionSort(ByVal arr As Variant)Dim i As IntegerDim j As IntegerDim minIndex As IntegerDim temp As IntegerFor i = 1 To UBound(arr) - 1minIndex = iFor j = i + 1 To UBound(arr)If arr(j) < arr(minIndex) ThenminIndex = jEnd IfNexttemp = arr(i)arr(i) = arr(minIndex)arr(minIndex) = tempNextEnd Sub步骤4:调用选择排序函数。
selectionSort arr步骤5:输出排序后的数据。
For i = 1 To 10Print arr(i)NextVB冒泡排序:步骤1:定义一个数组,用于存放需要排序的元素。
Dim arr(10) As Integer步骤2:输入数据。
For i = 1 To 10arr(i) = Val(InputBox("Please enter a number")) Next步骤3:定义一个冒泡排序的函数。
Sub bubbleSort(ByVal arr As Variant)Dim i As IntegerDim j As IntegerDim temp As IntegerFor i = UBound(arr) To 2 Step -1For j = 1 To i - 1If arr(j) > arr(j + 1) Thentemp = arr(j)arr(j) = arr(j + 1)arr(j + 1) = tempEnd IfNextNextEnd Sub步骤4:调用冒泡排序函数。
冒泡法排序的基本思想及VB程序实现
算法描述:
升序排列:从第一个元素开始,对数组中两两相邻的元素比较,将值较小的元素放在前面,值较大的元素放在后面,一轮比较完毕,一个最大的数沉底成为数组中的最后一个元素,一些较小的数如同气泡一样上浮一个位置。n个数,经过n-1轮比较后完成排序。
假定有下标为0~n的n+1个数的序列,要求按升序排列,实现的步骤如下:
………………………………………
(n)a(0)与a(1)比较,如果a(0)大,与a(1)交换,a(0)最小
算法剖析:
(1)从第0个元素开始与后一个比较,如果比后大两元素交换,依次比较到第n个元素,最终将最大的数换入第n个元素中,a(n)不动
(2)重复(1),依次比较到第n-1ห้องสมุดไป่ตู้元素,最终将最大的数换入第n-1个元素中,a(n-1)不动
(3)重复(1),依次比较到第n-2个元素,最终将最大的数换入第n-2个元素中,a(n-2)不动
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个整数,并用冒泡法排序(从小到大)。
参考:。
VB常用算法6排序
VB常用算法----排序1、选择法排序(1) 利用循环从n个数中选出最小数的下标,结束循环后,将最小数与第一个数交换位置;(2) 除第一个数外,在剩下的n-1个数中再按方法(1)选出次小的数,与第二个数交换位置;(3) 以此类推,最后构成递增序列。
譬如:8 6 9 3 2 7第一轮交换后 2 6 9 3 8 7第二轮交换后 2 3 9 6 8 7第三轮交换后 2 3 6 9 8 7第四轮交换后 2 3 6 7 8 9第五轮无交换 2 3 6 7 8 9程序代码如下:Private Sub xzPaiXu(a() As Double, sheng As Boolean)'a为需要排序的数组,sheng为True则为升序排列,为False,则为降序排列。
Dim i As Integer, j As IntegerDim temp As DoubleDim m As IntegerFor i = LBound(a) To UBound(a) - 1 '进行数组大小-1轮比较m = i '在第i轮比较时,假定第'i个元素为最值元素For j = i + 1 To UBound(a) '在剩下的元素中找出最'值元素的下标并记录在m中If sheng Then '若为升序,则m记录最小元素'下标,否则记录最大元素下标If a(j) < a(m) Then m = jElseIf a(j) > a(m) Then m = jEnd IfNext j '将最值元素与第i个元素交换temp = a(i)a(i) = a(m)a(m) = tempNext iEnd Sub调用该过程示例:Option Base 1Private Sub Command1_Click()Dim b(6) As Doubleb(1) = 8b(2) = 6b(3) = 9b(4) = 3b(5) = 2b(6) = 7Call xzPaiXu(b, True)For i% = 1 To 6Print b(i)NextEnd Sub2、冒泡法排序选择排序法在每一轮排序时寻找最值元素的下标,出了内循环(一轮排序结束时,确定最值下标),再交换最小数的位置;而冒泡法在每一轮排序时将相邻的数比较,当次序不对时就立即..交换..位置,出了内循环,最值数已经冒出。
vb冒号排序法 -回复
vb冒号排序法-回复VB冒号排序法是一种简单而有效的排序算法,它通过不断交换数组中相邻的元素的位置来将数组按照递增的顺序排列。
本文将一步一步地介绍VB 冒号排序法的工作原理和实现方式。
一、什么是冒号排序法?冒号排序法,也称为冒泡排序法,是一种基于比较的排序算法。
它通过比较相邻元素的大小,并根据比较结果交换元素的位置,从而使较大的元素逐渐“冒泡”到数组的末尾。
该算法的核心思想是重复地进行比较交换,直到数组中的所有元素都按照递增的顺序排列为止。
二、VB冒号排序法的工作原理VB冒号排序法的工作原理可以简单概括为以下几个步骤:1. 遍历数组,比较相邻元素的大小;2. 如果前一元素大于后一元素,则交换它们的位置;3. 重复执行上述步骤,直到没有需要交换的元素为止。
三、实现VB冒号排序法的步骤下面是具体实现VB冒号排序法的步骤:1. 初始化一个需要排序的数组arr;2. 创建一个外部循环,从数组的第一个元素开始遍历到倒数第二个元素;3. 在外部循环中,再创建一个内部循环,从数组的第一个元素开始遍历到当前外部循环的索引;4. 在内部循环中,比较当前元素和相邻元素的大小;5. 如果当前元素大于相邻元素,则交换它们的位置;6. 重复执行上述步骤,直到内部循环结束;7. 外部循环继续执行,直到遍历完所有元素;8. 返回排序后的数组arr。
这样,通过多次比较交换操作,最终得到的数组就是按照递增顺序排列的。
四、VB冒号排序法的效率和优化VB冒号排序法的时间复杂度为O(n^2),其中n是数组的长度。
它的性能随着数组的大小增加而下降,因为它需要不断进行比较和交换操作。
为了提高VB冒号排序法的效率,可以采取一些优化措施,例如:1. 设置一个标志位来表示当前轮次是否有元素交换,如果没有任何元素交换,则说明数组已经有序,可以提前结束排序;2. 在内部循环中,记录当前轮次最后一次交换的位置,作为下一轮次的截止位置,减少无用的比较操作;3. 在外部循环中,将当前轮次的最大值“冒泡”到倒数第i个位置,下一轮次只需要比较到倒数第i-1个位置即可。
冒泡排序与选择排序的比较
第二趟:从3个元素中选出最大者,将其 换入a1中
过程为:令max表示最大元素的序号初值max=1,a1到a3逐一 比较,找出最大元素的位置,a1与其互换,使最大值位于a1.
a0
a1
a2
a3
第一次比较
4
2
3
1
max=2
第二次比较 max=2
4
2
3
1
第二趟选择结果
4
3
2
1
第二趟选择,大数换到a1中,只交换一次
冒泡排序
n个数排序,需要进行n-1趟冒泡
a0、a1、 a2、 a3分别两两比较并交换,
使小数沉底到a3
a0
a1
a2
a3
第一次比较
1
2
3
4
第二次比较
2
1
3
4
第三次比较
2
3
1
4
第一趟冒泡结果
2
3
4
1
第一趟冒泡,小数沉底到a3
a0
a1
比较前:
1
2
第一趟冒泡结果
2
3
a2
a3
3
4
4
1
fori=0;i++;i<3 实现一趟冒泡的代码为: ifai<ai+1
第二次比较 max=2
1
2
3
4
第三次比较
1
2
3
4
max=3
第一趟选择结果
4
2
3
1
第一趟选择,大数换到a0中,只交换一次
a0
a1
a2
a3
比较前:
1
2
VBA排序之(冒泡排序、选择排序、插入排序、快速排序、希尔排序)
VBA排序之(冒泡排序、选择排序、插⼊排序、快速排序、希尔排序)主程序:Sub mymain()Dim MainArr, tApplication.ScreenUpdating = Falset = timerWith ThisWorkbook.Worksheets("排序")MainArr = .Range("a2: a" & Cells(Rows.Count, "a").End(xlUp).Row)InsertionSort arr:=MainArr.Range("c2").Resize(UBound(MainArr), 1) = MainArrEnd WithMsgBox Format(timer - t, "0.00s")Application.ScreenUpdating = TrueEnd Sub'1、冒泡排序运作⽅式:1.1、⽐较相邻的两个元素,按所需顺序决定是否交换。
1.2、对每⼀对相邻元素进⾏同样的⼯作,从第⼀对⾄最后⼀对。
结束后,最后⼀个元素应该是所需顺序的最值(如所需顺序为由⼩⾄⼤,则为最⼤值)。
1.3、对所有元素重复上述步骤,除了最后⼀个。
1.4、重复前述步骤,称前部分需要对⽐的为⽆序区,后部分不需要对⽐的为有序区,直到⽆序区仅剩⼀个元素。
Sub BubbleSort(ByRef arr)Dim i&, j&, vSwapFor i = UBound(arr) To2Step -1For j = 1To i - 1If arr(j, 1) > arr(j + 1, 1) ThenvSwap = arr(j, 1)arr(j, 1) = arr(j + 1, 1)arr(j + 1, 1) = vSwapEnd IfNextNextEnd Sub2、选择排序运作⽅式:2.1、对(⽆序区)全部元素由前⾄后扫描,找出最值。
冒泡法排序vb
方法2的核心代码 方法 的核心代码
For j = 2 To 10 For i = 10 To j Step -1 If a(i) < a(i - 1) Then t = a(i) a(i) = a(i - 1) a(i - 1) = t End If Next i Next j
实验二 VB冒泡排序法
实验二 VB冒泡排序法一.实验目的熟悉VB集成开发环境,掌握一种排序算法,即冒泡排序法二.实验条件和环境Visual Basic6.0集成开发环境三.实验任务和要求将一组数据(12.5, 34, 45, 21, 67, 4, 12, 45, 47, 56)从小到大排序,要用冒泡排序法四.实验内容1.实验步骤(1)运行Visual Basic6.0,新建一个工程应用程序(2)参照相关资料编写程序,包括定义数组、数组赋值,排序算法。
(3) 新建工程,选择“标准EXE”(4) 设计界面,用工具箱在窗体上分别绘制二个命令按纽command1,command2, 然后调整控件大小,调整控件的位置。
(5) 设计属性(6)编写代码2.操作指导Option Base 1 ' 设数组下标从1开始Private Sub Command1_Click()Dim i, n, m, k As IntegerDim sun(), temp As Single '数组,变量定义n = 10ReDim sun(n) '重新定义数组Print "排序前"sun = Array(12.5, 34, 45, 21, 67, 4, 12, 45, 47, 56) '输入的数据For i = 1 To n'sun(n) = Val(InputBox("随机输入10个数,准备排序:第" + Str(n) + "个", "输入10个数")) Print sun(i); '打印输入的10个数Next i'下面为排序代码,n个数需要n-1次比较For m = 1 To 9 '因为只需要比较n-1次,所以1到9即可For k = 1 To 10 - m '每趟比较大数都沉底,下次只需要比较余下的数大小If (sun(k) > sun(k + 1)) Thentemp = sun(k)sun(k) = sun(k + 1)sun(k + 1) = tempEnd IfNext kNext mPrint: Print '输出空行,与前面输出分开Print "排序后"For i = 1 To 10Print sun(i);Next iEnd SubPrivate Sub Command2_Click()EndEnd Sub。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Public Class Form1
Dim arr(5) As Integer
Dim a(5, 5) As TextBox
Private Sub delaytime()
Dim i, j As Long
For i = 1 To 20000
For j = 1 To 20000
i = i + 1
i = i - 1
Next j
Next i
End Sub
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Label1.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 Integer
Dim leftlen, toplen As Integer
leftlen = 120 : toplen = 32
Randomize()
For i = 0 To 5
For j = 0 To 5
a(i, j) = New TextBox
a(i, j).Width = 30 : a(i, j).Height = 30
a(i, j).Left = leftlen + j * 40 : a(i, j).Top = toplen + i * 32
a(i, j).Parent = Me : a(i, j).Visible = True
Next j
Next i
End Sub
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim i, j As Integer
For i = 0 To 5
arr(i) = Int(10 + 89 * Rnd()) + 1
a(0, i).Text = arr(i)
Next i
End Sub
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
Dim i, j As Integer
Dim min, min_i As Integer
Dim t As Integer
For i = 0 To 5 - 1
min = arr(i) : min_i = i
For j = i + 1 To 5
If min > arr(j) Then
min = arr(j) : min_i = j
End If
Next j
a(i, min_i).BackColor = System.Drawing.Color.Yellow
a(i, i).BackColor = System.Drawing.Color.LightCyan
Me.Refresh()
If min_i <> i Then
t = arr(min_i) : arr(min_i) = arr(i) : arr(i) = t
End If
For j = 0 To 5
a(i + 1, j).Text = arr(j)
Next j
Call delaytime()
Me.Refresh()
Next i
End Sub
Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
Dim i, j, k, t As Integer
For i = 1 To 5
For k = 0 To 5
a(i, k).Text = arr(k)
Next k
Me.Refresh()
Call delaytime()
For j = 0 To 5 - i
a(i, j).BackColor = System.Drawing.Color.LightCyan
a(i, j + 1).BackColor = System.Drawing.Color.LightC yan
Me.Refresh()
Call delaytime()
If arr(j) > arr(j + 1) Then
t = arr(j) : arr(j) = arr(j + 1) : arr(j + 1) = t
a(i, j).Text = arr(j) : a(i, j + 1).Text = arr(j + 1)
End If
Me.Refresh()
Call delaytime()
a(i, j).BackColor = System.Drawing.Color.WhiteSmoke
a(i, j + 1).BackColor = System.Drawing.Color.WhiteSmoke
Next j
Next i
End Sub
Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.Click
Dim i, j As Integer
For i = 0 To 5
For j = 0 To 5
a(i, j).Text = ""
a(i, j).BackColor = System.Drawing.Color.WhiteSmoke
Next j
Next i
End Sub
Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button5.Click
End
End Sub
End Class。