vb 排序程序1
vb顺序结构程序实例
vb顺序结构程序实例一、题目：编写一个vb顺序结构程序，实现计算器功能，能够进行简单的四则运算。
二、程序设计思路：1.首先，我们需要用户输入两个操作数和一个运算符。
2.接下来，根据输入的运算符，选择相应的运算进行计算。
3.最后，将结果输出给用户。
三、程序设计实现：Option ExplicitSub Main'1.声明并初始化变量Dim num1 As DoubleDim num2 As DoubleDim operator As StringDim result As Double'2.提示用户输入操作数和运算符Console.WriteLine("请输入第一个操作数：")num1 = Console.ReadLineConsole.WriteLine("请输入第二个操作数：")num2 = Console.ReadLineConsole.WriteLine("请输入运算符（+、-、*、/）：") operator = Console.ReadLine'3.根据输入的运算符，选择相应的运算进行计算Select Case operatorCase "+"result = num1 + num2Case "-"result = num1 - num2Case "*"result = num1 * num2Case "/"If num2 = 0 ThenConsole.WriteLine("除数不能为0！")Exit SubElseresult = num1 / num2End IfCase ElseConsole.WriteLine("请输入正确的运算符！")Exit SubEnd Select'4.将结果输出给用户Console.WriteLine("计算结果为：" & result)End Sub四、测试案例：1. 输入：num1 = 5, num2 = 3, operator = "+"输出：计算结果为：82. 输入：num1 = 5, num2 = 3, operator = "-"输出：计算结果为：23. 输入：num1 = 5, num2 = 3, operator = "*"输出：计算结果为：154. 输入：num1 = 6, num2 = 0, operator = "/"输出：除数不能为0！5. 输入：num1 = 6, num2 = 3, operator = "^"输出：请输入正确的运算符！五、总结：以上是一个简单的vb顺序结构程序示例，通过该程序我们可以输入两个操作数和一个运算符，然后根据运算符进行相应的运算并输出结果。
VB常用算法介绍
VB常用算法介绍在VB程序开发中，常常需要使用各种算法来处理数据和解决问题。
下面将介绍几种常用的VB算法，包括排序算法、算法和图算法等。
1.排序算法排序算法用来将一组数据按照一定的规则进行排列。
常见的排序算法包括冒泡排序、选择排序、插入排序、归并排序和快速排序等。
冒泡排序（Bubble Sort）是一种交换排序算法，通过不断地相邻元素比较和交换，将较大的元素逐渐交换到末尾，从而实现排序。
冒泡排序的时间复杂度为O(n^2)。
选择排序（Selection Sort）是一种排序算法，每次从待排序的数据元素中选择最小（或最大）的一个元素，放到已排序的序列的末尾。
选择排序的时间复杂度为O(n^2)。
插入排序（Insertion Sort）是一种排序算法，将数组元素分为已排序和未排序两部分，每次从未排序的部分中取出一个元素，插入到已排序的部分的适当位置。
插入排序的时间复杂度为O(n^2)。
归并排序（Merge Sort）是一种分治排序算法，将待排序的数据分为两个子序列，然后递归地对子序列进行排序，并将两个已排序的子序列合并成一个有序序列。
归并排序的时间复杂度为O(nlogn)。
快速排序（Quick Sort）是一种分治排序算法，通过一次划分将待排数据分成左右两个子序列，然后递归地对子序列进行排序。
快速排序的时间复杂度为O(nlogn)。
2.算法算法用来在一个数据集合中查找一些元素或满足特定条件的元素。
常见的算法包括线性、二分和深度优先。
线性（Linear Search）是一种简单的算法，从数据集合的第一个元素开始逐个比较，直到找到目标元素或遍历完整个集合。
线性的时间复杂度为O(n)。
二分（Binary Search）是一种在有序数据集合中查找目标元素的算法，通过每次将范围缩小一半来快速定位目标元素。
二分的时间复杂度为O(logn)。
深度优先（Depth-First Search，DFS）是一种用来在图或树结构中遍历所有节点的算法，从一个起始节点开始，先遍历一个邻接节点，然后再递归地遍历该邻接节点的邻接节点。
VB数组快速排序算法（转）
VB数组快速排序算法（转）VB数组快速排序算法VB数组排序模块，使用的是快速排序法，支持 Variant、Double、Long、String……等多种数据类型数组排序。
Option ExplicitPrivate Sub QuicksortInt(list() As Integer, ByVal min As Integer, ByVal max As Integer)Dim med_value As IntegerDim hi As IntegerDim lo As IntegerDim i As Integer' If the list has no more than CutOff elements,' finish it off with SelectionSort.If max <= min Then Exit Sub' Pick the dividing value.i = Int((max - min + 1) * Rnd + min)med_value = list(i)' Swap it to the front.list(i) = list(min)lo = minhi = maxDo' Look down from hi for a value < med_value.Do While list(hi) >= med_valuehi = hi - 1If hi <= lo Then Exit DoLoopIf hi <= lo Thenlist(lo) = med_valueExit DoEnd If' Swap the lo and hi values.list(lo) = list(hi)' Look up from lo for a value >= med_value.lo = lo + 1Do While list(lo) < med_valuelo = lo + 1If lo >= hi Then Exit DoLoopIf lo >= hi Thenlo = hilist(hi) = med_valueExit DoEnd If' Swap the lo and hi values.list(hi) = list(lo)Loop' Sort the two sublists.QuicksortInt list(), min, lo - 1QuicksortInt list(), lo + 1, maxEnd SubPrivate Sub QuicksortSingle(list() As Single, ByVal min As Integer, ByVal max As Integer)Dim med_value As SingleDim hi As IntegerDim lo As IntegerDim i As Integer' If the list has no more than CutOff elements, ' finish it off with SelectionSort.If max <= min Then Exit Sub' Pick the dividing value.i = Int((max - min + 1) * Rnd + min)med_value = list(i)' Swap it to the front.list(i) = list(min)lo = minhi = maxDo' Look down from hi for a value < med_value. Do While list(hi) >= med_valuehi = hi - 1If hi <= lo Then Exit DoLoopIf hi <= lo Thenlist(lo) = med_valueExit DoEnd If' Swap the lo and hi values.list(lo) = list(hi)' Look up from lo for a value >= med_value. lo = lo + 1Do While list(lo) < med_valuelo = lo + 1If lo >= hi Then Exit DoLoopIf lo >= hi Thenlo = hilist(hi) = med_valueExit DoEnd If' Swap the lo and hi values.list(hi) = list(lo)Loop' Sort the two sublists.QuicksortSingle list(), min, lo - 1QuicksortSingle list(), lo + 1, maxEnd SubPrivate Sub QuicksortDouble(list() As Double, ByVal min As Integer, ByVal max As Integer)Dim med_value As DoubleDim hi As IntegerDim lo As IntegerDim i As Integer' If the list has no more than CutOff elements,' finish it off with SelectionSort.If max <= min Then Exit Sub' Pick the dividing value.i = Int((max - min + 1) * Rnd + min)med_value = list(i)' Swap it to the front.list(i) = list(min)lo = minhi = maxDo' Look down from hi for a value < med_value. Do While list(hi) >= med_valuehi = hi - 1If hi <= lo Then Exit DoLoopIf hi <= lo Thenlist(lo) = med_valueExit DoEnd If' Swap the lo and hi values.list(lo) = list(hi)' Look up from lo for a value >= med_value. lo = lo + 1Do While list(lo) < med_valuelo = lo + 1If lo >= hi Then Exit DoLoopIf lo >= hi Thenlo = hilist(hi) = med_valueExit DoEnd If' Swap the lo and hi values.list(hi) = list(lo)Loop' Sort the two sublists.QuicksortDouble list(), min, lo - 1QuicksortDouble list(), lo + 1, maxEnd SubPrivate Sub QuicksortString(list() As String, ByVal min As Integer, ByVal max As Integer)Dim med_value As StringDim hi As IntegerDim lo As IntegerDim i As Integer' If the list has no more than CutOff elements,' finish it off with SelectionSort.If max <= min Then Exit Sub' Pick the dividing value.i = Int((max - min + 1) * Rnd + min)med_value = list(i)' Swap it to the front.list(i) = list(min)lo = minhi = maxDo' Look down from hi for a value < med_value.Do While list(hi) >= med_valuehi = hi - 1If hi <= lo Then Exit DoLoopIf hi <= lo Thenlist(lo) = med_valueExit DoEnd If' Swap the lo and hi values.list(lo) = list(hi)' Look up from lo for a value >= med_value.lo = lo + 1Do While list(lo) < med_valuelo = lo + 1If lo >= hi Then Exit DoLoopIf lo >= hi Thenlo = hilist(hi) = med_valueExit DoEnd If' Swap the lo and hi values.list(hi) = list(lo)Loop' Sort the two sublists.QuicksortString list(), min, lo - 1QuicksortString list(), lo + 1, maxEnd SubPrivate Sub QuicksortVariant(list() As Variant, ByVal min As Integer, ByVal max As Integer)Dim med_value As VariantDim hi As IntegerDim lo As IntegerDim i As Integer' If the list has no more than CutOff elements, ' finish it off with SelectionSort.If max <= min Then Exit Sub' Pick the dividing value.i = Int((max - min + 1) * Rnd + min)med_value = list(i)' Swap it to the front.list(i) = list(min)lo = minhi = maxDo' Look down from hi for a value < med_value. Do While list(hi) >= med_valuehi = hi - 1If hi <= lo Then Exit DoLoopIf hi <= lo Thenlist(lo) = med_valueExit DoEnd If' Swap the lo and hi values.list(lo) = list(hi)' Look up from lo for a value >= med_value. lo = lo + 1Do While list(lo) < med_valuelo = lo + 1If lo >= hi Then Exit DoLoopIf lo >= hi Thenlo = hilist(hi) = med_valueExit DoEnd If' Swap the lo and hi values.list(hi) = list(lo)Loop' Sort the two sublists.QuicksortVariant list(), min, lo - 1QuicksortVariant list(), lo + 1, maxEnd SubPrivate Sub QuicksortLong(list() As Long, ByVal min As Integer, ByVal max As Integer)Dim med_value As LongDim hi As IntegerDim lo As IntegerDim i As Integer' If the list has no more than CutOff elements,' finish it off with SelectionSort.If max <= min Then Exit Sub' Pick the dividing value.i = Int((max - min + 1) * Rnd + min)med_value = list(i)' Swap it to the front.list(i) = list(min)lo = minhi = maxDo' Look down from hi for a value < med_value. Do While list(hi) >= med_valuehi = hi - 1If hi <= lo Then Exit DoLoopIf hi <= lo Thenlist(lo) = med_valueExit DoEnd If' Swap the lo and hi values.list(lo) = list(hi)' Look up from lo for a value >= med_value. lo = lo + 1Do While list(lo) < med_valuelo = lo + 1If lo >= hi Then Exit DoLoopIf lo >= hi Thenlo = hilist(hi) = med_valueExit DoEnd If' Swap the lo and hi values.list(hi) = list(lo)Loop' Sort the two sublists.QuicksortLong list(), min, lo - 1QuicksortLong list(), lo + 1, maxEnd Sub' Sort an array of integers.Public Sub SortIntArray(list() As Integer) QuicksortInt list, LBound(list), UBound(list) End Sub' Sort an array of longs.Public Sub SortLongArray(list() As Long) QuicksortLong list, LBound(list), UBound(list) End Sub' Sort an array of singles.Public Sub SortSingleArray(list() As Single) QuicksortSingle list, LBound(list), UBound(list) End Sub' Sort an array of doubles.Public Sub SortDoubleArray(list() As Double) QuicksortDouble list, LBound(list), UBound(list) End Sub' Sort an array of strings.Public Sub SortStringArray(list() As String) QuicksortString list, LBound(list), UBound(list) End Sub' Sort an array of variants.Public Sub SortVariantArray(list() As Variant) QuicksortVariant list, LBound(list), UBound(list) End Sub。
VB排序
If hi <= lo Then Exit Do
Loop
If <= lo Then
list(lo) = med_value
Exit Do
Dim med_value As Single
Dim hi As Integer
Dim lo As Integer
Dim i As Integer
' If the list has no more than CutOff elements,
' finish it off with SelectionSort.
list(hi) = med_value
Exit Do
End If
' Swap the lo and hi values.
list(hi) = list(lo)
Loop
End If
' Swap the lo and hi values.
list(lo) = list(hi)
' Look up from lo for a value >= med_value.
lo = lo + 1
If max <= min Then Exit Sub
' Pick the dividing value.
i = Int((max - min + 1) * Rnd + min)
med_value = list(i)
' Swap it to the front.
hi = hi - 1
If hi <= lo Then Exit Do
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教程03.查找和排序
03
VB实现查找和排序
使用VB实现线性查找
线性查找是一种简单的查找算法，它从列表的第一个元素开始，逐个比较每个元素，直到找到目标元 素或遍历完整个列表。
在VB中，可以使用For循环结构来实现线性查找。通过比较目标元素与列表中的元素，如果找到目标元 素，则返回其索引；如果未找到，则返回一个错误值或特定值。
冒泡排序的时间复杂度为O(n^2)，其中n为列表的长度。
04
查找和排序的应用场景
数据检索
数据检索是查找和排序算法最直接的应用场景，通过查找和排序，可以快 速地定位到所需的数据项，提高数据检索的效率和准确性。
在数据库、文件系统、数据仓库等存储结构中，查找和排序算法被广泛应 用于数据的快速定位和检索。
适用场景
当数据结构中元素数量较大，且元素顺序重要时使用。
哈希查找
时间复杂度
O(1)，在最理想的情况下。但在哈希冲突 严重的情况下，时间复杂度可能会增加到 O(n)。
VS
适用场景
当数据结构中元素数量较大，且元素顺序 不重要时使用。哈希查找适用于处理大量 数据，并且对数据结构中的元素进行频繁 的插入和删除操作。
线性查找的时间复杂度为O(n)，其中n为列表的长度。
使用VB实现二分查找
二分查找是一种高效的查找算法，适 用于已排序的列表。它通过将列表分 成两半，比较目标元素与中间元素， 然后根据比较结果在左半部分或右半 部分继续查找，直到找到目标元素或 确定目标元素不存在于列表中。
在VB中，可以使用For循环结构来实 现二分查找。通过比较目标元素与中 间元素，如果找到目标元素，则返回 其索引；如果未找到，则返回一个错 误值或特定值。
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数组排序函数
vb数组排序函数VB数组排序函数是一个重要的数组函数，可以帮助我们对数组元素进行排序，让其按照一定的顺序排列。
本文将介绍VB数组排序函数，并阐述其具体用法和注意事项。
VB数组排序函数的语法：Sort(array, [comparator])其中，array为所要排序的数组；comparator为可选参数，表示比较函数，其返回值为如下三种：1. 正数：表示第一个参数大于第二个参数；2. 0：表示两个参数相等；在使用VB数组排序函数时，我们需要注意以下几点：1. 所要排序的数组必须是支持排序的类型之一，即元素必须是字符串、数值等可比较类型。
2. 在没有指定比较函数时，将使用默认的比较函数进行排序。
默认情况下将使用升序排序。
3. 在指定比较函数时，应该确保传入的函数具有正确的返回值，并且能够对所要排序的元素进行比较。
下面就通过几个实例来演示VB数组排序函数的用法。
实例一：对数组元素进行升序排序Sub SortDemo()Dim MyArr(1 To 5) As IntegerMyArr(1) = 34MyArr(2) = 56MyArr(3) = 11MyArr(4) = 27MyArr(5) = 89Sort MyArrFor i = 1 To UBound(MyArr)MsgBox MyArr(i)Next iEnd Sub运行结果：1127345689在此例中，我们定义了一个整数类型的数组MyArr，并将其初始化为5个随机数。
然后，我们调用Sort函数对其进行排序。
由于未指定comparator参数，所以默认进行升序排序。
最后，我们通过循环打印出排好序的数组元素。
在此例中，我们同样定义了一个整数类型的数组MyArr，并将其初始化为5个随机数。
然后，我们调用Sort函数对其进行排序，并指定了比较函数DescendingSort。
这个比较函数接收两个参数a和b，并根据它们的值来返回一个负数、零或正数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Option ExplicitDim Sums(9999) As Long, Sumb(9999) As Long '生成数据数量可自己设置Private blnSort As Boolean '排序方向Private Declare Function SendMessageFind Lib "User32" Alias "SendMessageA" (ByVal hWnd As Long, ByVal wmsg As Long, ByVal wparam As Integer, ByVal lparam As String) As LongPrivate Declare Function timeGetTime Lib "winmm.dll" () As LongDim T As LongPrivate Sub Command1_Click()Dim i As Long, z As Long, j As LongList1.ClearDoEventsList1.Visible = FalseFor i = 0 To UBound(Sums)nn:Randomizez = 99999 * Rnd + 9j = SendMessageFind(List1.hWnd, &H18F, 0, z)If j > -1 ThenGoTo nnElseSums(i) = zSumb(i) = zList1.AddItem Sums(i)End IfNextList1.Visible = TrueMe.Caption = "共产生数据:" & UBound(Sums) + 1 & " 项"End SubPrivate Sub Command2_Click()Dim ti As Integer, i As LongList2.ClearDoEventsFor i = 0 To UBound(Sumb)Sums(i) = Sumb(i)NextblnSort = Option1(0).ValueT = timeGetTimeIf Option2(0).Value = True ThenCall mpsort(Sums) '冒泡排序ti = 0End IfIf Option2(1).Value = True ThenCall insort(Sums) '插入排序ti = 1End IfIf Option2(2).Value = True ThenCall QuickSort(LBound(Sums), UBound(Sums)) '快速排序ti = 2End IfIf Option2(3).Value = True ThenCall selctsort(Sums) '选择排序ti = 3End IfIf Option2(4).Value = True ThenCall hirsort(Sums) '希尔排序ti = 4End IfIf Option2(5).Value = True ThenCall duisort(Sums) '堆排序ti = 5End IfIf Option2(6).Value = True ThenCall nsort(Sums) '打乱次序ti = 6End IfLabel1(ti).Caption = timeGetTime - TList2.Visible = FalseDoEventsFor i = 0 To UBound(Sums)List2.AddItem Sums(i)NextList2.Visible = TrueMe.Caption = "成功对：" & UBound(Sums) + 1 & " 项数据进行了排序,用时: " &Label1(ti).Caption & " 毫秒"Exit SubEnd SubPrivate Sub Command3_Click()List1.ClearList2.ClearMe.Caption = "六种排序"End SubPrivate Sub nsort(ByRef arrtosort() As Long)Dim i As Long, j As Long, tmp As LongFor i = LBound(arrtosort) To UBound(arrtosort)j = (UBound(arrtosort) - i) * Rnd + iIf i <> j Thentmp = arrtosort(i)arrtosort(i) = arrtosort(j)arrtosort(j) = tmpEnd IfNext iEnd SubPrivate Sub mpsort(ByRef arrtosort() As Long) '冒泡排序'经过n-1趟子排序完成的,它的时间复杂度为O（n^2）'优点：1.“编程复杂度”很低，很容易写出代码；2.具有稳定性Dim i As Long, j As Long, M As Long, tmp As LongM = UBound(arrtosort) 'm等于数组上标Do While M '至m等于数组下标j = M - 1M = 0If blnSort ThenFor i = 0 To jIf arrtosort(i) > arrtosort(i + 1) Then '找到后者大于前者地数tmp = arrtosort(i) '两者互换arrtosort(i) = arrtosort(i + 1)arrtosort(i + 1) = tmpM = i '从该位置开始继续查找End IfElseFor i = 0 To jIf arrtosort(i) < arrtosort(i + 1) Thentmp = arrtosort(i)arrtosort(i) = arrtosort(i + 1)arrtosort(i + 1) = tmpM = iEnd IfNext iEnd IfLoopEnd SubPrivate Sub insort(ByRef arrtosort() As Long) '插入排序'插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据'算法适用于少量数据的排序，时间复杂度为O(n^2)。
是稳定的排序方法。
Dim i As Long, j As Long, k As Long, M As Long, tmp As LongM = UBound(arrtosort)For i = 0 To M '从数组下标到数组上标If blnSort ThenFor j = i + 1 To M '从数组的后一位开始If arrtosort(j) < arrtosort(i) Then '后者大于前者tmp = arrtosort(j)For k = j To i + 1 Step -1 '往后移动数组arrtosort(k) = arrtosort(k - 1)Next karrtosort(i) = tmp '插入该数End IfNext jElseFor j = i + 1 To MIf arrtosort(j) > arrtosort(i) Thentmp = arrtosort(j)For k = j To i + 1 Step -1arrtosort(k) = arrtosort(k - 1)Next karrtosort(i) = tmpNext jEnd IfNext iEnd SubPrivate Sub QuickSort(lngL As Long, lngR As Long) '快速排序,lngL,lngR 需排序数组的下标,上标'快速排序（Quicksort）是对冒泡排序的一种改进。
由C. A. R. Hoare在1962年提出。
'它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小'然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
Dim i As Long, j As Long, M As Long, tmp As Longi = lngLj = lngRM = Sums((i + j) \ 2)tmp = tCenter(Sums(i), M, Sums(j)) '取轴枢，既作为比较的那个数While i < jIf blnSort ThenWhile i < lngR And Sums(i) < tmp '求lngI使N(i)小于轴枢i = i + 1WendWhile j > lngL And Sums(j) > tmp '求lngJ使N(j)大于轴枢j = j - 1WendElseWhile i < lngR And Sums(i) > tmpi = i + 1WendWhile j > lngL And Sums(j) < tmpj = j - 1WendEnd IfIf i <= j Then '不出错，交换N(i)和N(j) M = Sums(i)Sums(i) = Sums(j)Sums(j) = Mi = i + 1j = j - 1End IfWendIf lngL < j Then: Call QuickSort(lngL, j) '改变位置，递归调用If i < lngR Then: Call QuickSort(i, lngR)End SubPrivate Function tCenter(a As Long, b As Long, C As Long) As Long '取三者中的中间项If a > b Then 'a>bIf b > C Then 'a>b>ctCenter = b 'bElse 'a>b c>=bIf a > C Then 'a>b c>=b a>c tCenter = C 'cElse 'a>b c>=b c>a tCenter = a 'aEnd IfEnd IfElse 'b>=aIf a > C Then 'b>=a a>c tCenter = a 'aElse 'b>=a c>=a If b > C Then 'b>=a c>=a b>c tCenter = C 'cElse 'b>=a c>=a c>=b tCenter = b 'bEnd IfEnd IfEnd IfEnd FunctionPrivate Sub selctsort(ByRef arrtosort() As Long) '选择排序'每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，'直到全部待排序的数据元素排完。