VBA中几种常用的排序方法

合集下载

VBA在Excel中实现表格排序的方法总结

VBA在Excel中实现表格排序的方法总结Excel是一款功能强大的数据处理工具，而VBA（Visual Basic for Applications）是其自带的编程语言，提供了许多功能强大的数据处理和自动化操作的方法。

其中之一就是通过VBA在Excel中实现表格排序。

本文将总结VBA中几种常用的表格排序方法，供读者参考和学习。

一、VBA中的Range对象在VBA中，Range对象用于表示Excel中的单元格或一系列单元格。

通过指定Range对象的属性和方法，我们可以在VBA中对表格进行排序。

下面是一个实例，展示如何使用Range对象进行排序：```Sub SortRange()Dim ws As WorksheetDim rng As Range' 指定要排序的工作表和范围Set ws = ThisWorkbook.Worksheets("Sheet1")Set rng = ws.Range("A1:C10")' 对范围内的数据进行排序rng.Sort Key1:=rng.Columns(1), Order1:=xlAscending,Header:=xlYesEnd Sub```上述代码首先使用`Set`语句指定了要排序的工作表和范围。

接着，通过调用`Sort`方法对范围内的数据进行排序。

在这个例子中，我们通过`Key1`参数指定了基于第一列进行排序，`Order1`参数指定了升序排序，`Header`参数指定了有表头。

根据需求，可以根据实际情况进行调整。

二、VBA中的ListObject对象除了使用Range对象，我们还可以使用ListObject对象来实现表格排序。

ListObject对象是Excel中用于处理数据表的对象，它提供了更多的排序选项和灵活性。

下面是一个使用ListObject对象进行排序的示例：```Sub SortListObject()Dim ws As WorksheetDim tbl As ListObject' 指定要排序的工作表和表格Set ws = ThisWorkbook.Worksheets("Sheet1")Set tbl = ws.ListObjects("Table1")' 对表格进行排序tbl.Sort.SortFields.Cleartbl.Sort.SortFields.Add Key:=tbl.Range.Columns(1), _SortOn:=xlSortOnValues, _Order:=xlAscending, _DataOption:=xlSortNormalWith tbl.Sort.SetRange tbl.Range.Header = xlYes.MatchCase = False.ApplyEnd WithEnd Sub```上述代码首先使用`Set`语句指定要排序的工作表和表格。

VBA中的数据筛选与排序方法

VBA中的数据筛选与排序方法在VBA中，数据处理是一个非常常见的任务。

其中，数据筛选和排序是经常使用的两种方法，能帮助我们更好地处理和分析数据。

本文将介绍如何在VBA中使用数据筛选与排序方法，帮助您更高效地处理和管理数据。

一、数据筛选数据筛选是根据指定的条件从数据集中筛选出符合要求的数据。

VBA提供了多种方法来实现数据筛选，包括使用AutoFilter方法和使用AdvancedFilter方法。

1. 使用AutoFilter方法AutoFilter方法是VBA中常用的筛选方法之一。

它可以根据指定的条件对数据进行筛选，并将符合条件的数据显示出来。

以下是使用AutoFilter方法的示例代码：```Sub AutoFilterExample()Dim ws As WorksheetSet ws = ThisWorkbook.Sheets("Sheet1")ws.Range("A1:D10").AutoFilter Field:=1, Criteria1:=">100"End Sub```在上述代码中，我们首先定义了一个代表工作表的变量ws，并将其设置为当前工作簿中的“Sheet1”工作表。

然后，我们使用AutoFilter 方法对“A1:D10”范围的第一列进行筛选，筛选条件为大于100的值。

执行该代码后，符合条件的数据将会显示出来。

2. 使用AdvancedFilter方法AdvancedFilter方法是VBA中更高级的筛选方法，它可以根据指定的条件将筛选结果复制到指定的位置。

以下是使用AdvancedFilter方法的示例代码：```Sub AdvancedFilterExample()Dim ws As WorksheetSet ws = ThisWorkbook.Sheets("Sheet1")ws.Range("A1:D10").AdvancedFilter Action:=xlFilterCopy, CriteriaRange:=ws.Range("F1:F2"), CopyToRange:=ws.Range("H1:L1"), Unique:=FalseEnd Sub```在上述代码中，我们同样先定义了一个代表工作表的变量ws，并将其设置为当前工作簿中的“Sheet1”工作表。

vba排序方法 -回复

vba排序方法-回复VBA排序方法在许多编程语言中，排序是一项常见而重要的任务。

在VBA中，也有许多方法可以用来对数据进行排序。

本文将详细介绍VBA中的排序方法，并逐步解释每一步的实施。

VBA是Visual Basic for Applications的缩写，它是一种用于编写宏和自定义功能的编程语言。

VBA广泛应用于Excel、Access和其他微软Office 应用程序中。

通过使用VBA，用户可以通过编写代码来自动执行一些重复的任务，提高工作效率。

在VBA中，数据排序是一项常见的任务。

根据特定的条件对数据进行排序可以使其更易于查看和分析。

VBA提供了多种排序方法，包括冒泡排序、选择排序、插入排序、快速排序等。

下面将介绍其中两种常用的排序方法：冒泡排序和快速排序。

首先，我们来看一下冒泡排序。

冒泡排序是一种简单直观的排序算法。

它的基本思想是通过相邻元素之间的比较和交换，逐步将较大的元素移到右侧，较小的元素移到左侧。

具体的实现代码如下：vbaSub BubbleSort(arr() As Variant)Dim i As Long, 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在代码中，我们使用了一个嵌套的循环结构。

外层循环控制比较的轮数，内层循环控制每一轮比较中相邻元素的交换。

通过不断交换相邻元素的位置，较大的元素会逐渐“冒泡”到数组的右侧。

使用冒泡排序进行排序的代码示例如下：vbaSub TestBubbleSort()Dim arr() As VariantDim i As Long' 初始化数组arr = Array(4, 2, 1, 3, 5)' 调用冒泡排序函数BubbleSort arr' 打印排序结果For i = LBound(arr) To UBound(arr)Debug.Print arr(i)Next iEnd Sub在示例代码中，我们首先定义了一个数组，并初始化了一些随机的整数。

VBA 中的自定义排序与数组排序方法

VBA 中的自定义排序与数组排序方法VBA（Visual Basic for Applications）是一种宏编程语言，常用于Microsoft Office套件中的自动化操作。

在VBA中，排序是一项常见的任务，它可以帮助我们对数据进行整理和分析。

本文将介绍VBA中的自定义排序与数组排序方法，让您掌握这些技巧，提高VBA编程的效率。

1. 自定义排序在VBA中，我们可以根据特定的规则对数据进行自定义排序。

自定义排序是根据我们自己定义的排序条件对数据进行排序，而不是按照默认的字母或数字顺序排序。

以下是一个示例，演示如何使用VBA 进行自定义排序：```Sub CustomSort()Dim rng As RangeSet rng = Range("A1:A10") '需要排序的区域With rng.Sort Key1:=Range("B1"), Order1:=xlAscending, Header:=xlYes, _OrderCustom:=Array("High", "Medium", "Low"), MatchCase:=False, _Orientation:=xlTopToBottom '自定义排序的规则和顺序End WithEnd Sub```上述代码中，我们通过定义一个数组来设置自定义排序的规则。

根据这个规则，VBA会按照"High"、"Medium"、"Low"的顺序对区域进行排序。

2. 数组排序方法VBA中的数组排序方法可以帮助我们对数组中的数据进行排序。

以下是一个示例，演示了如何使用数组排序方法进行升序或降序排序：```Sub ArraySort()Dim data() As Variantdata = Array(5, 2, 8, 1, 3) '需要排序的数组'使用冒泡排序进行升序排序Dim i As Long, j As LongFor i = LBound(data) To UBound(data) - 1For j = i + 1 To UBound(data)If data(i) > data(j) ThenDim temp As Varianttemp = data(i)data(i) = data(j)data(j) = tempEnd IfNext jNext i'输出排序结果For i = LBound(data) To UBound(data)Debug.Print data(i)Next iEnd Sub```上述代码中，我们使用冒泡排序算法对一个数组进行了升序排序。

VB_常用算法总结

VB_常用算法总结VB是一种使用广泛的编程语言，它有很多常用的算法可以应用到各种实际的问题中。

下面是一些常用的VB算法的总结。

1.排序算法：-冒泡排序：比较相邻的两个元素，如果顺序错误则交换位置，重复该过程直到排序完成。

-插入排序：将一个元素插入到已经排好序的数组中的正确位置。

-选择排序：每次选择数组中最小的元素，放到已排序部分的末尾。

-快速排序：选择一个元素作为基准，将小于它的元素放在它的左边，大于它的元素放在右边，分别对左右两部分进行递归排序。

2.查找算法：-二分查找：将有序数组从中间切分，判断目标元素与中间元素的大小关系，递归查找目标元素所在的半边数组。

-线性查找：逐个比较数组中的元素，直到找到目标元素或遍历完整个数组。

3.图算法：-深度优先（DFS）：从起始节点开始，递归地探索图中的每个节点，直到遍历到最深的节点为止。

-广度优先（BFS）：从起始节点开始，逐层地探索图中的节点，直到找到目标节点。

- 最短路径（Dijkstra算法）：计算从起始节点到所有其他节点的最短路径。

4.动态规划：-背包问题：给定一组物品和一个背包的容量，选择一些物品放入背包中，使得物品的总价值最大。

-最长公共子序列（LCS）：两个序列中的最长公共子序列，可以用动态规划的方法求解。

5.图像处理：-图像平滑：使用滤波器（如均值滤波器、高斯滤波器）对图像进行平滑处理，去除图像中的噪声。

- 边缘检测：使用边缘检测算法（如Canny算法、Sobel算法）从图像中检测出物体的边缘。

6.数据压缩：-霍夫曼编码：根据字符出现的频率，构建霍夫曼树，并生成每个字符的编码，实现数据的无损压缩。

- Run-length编码：对连续出现的相同字符进行计数，并将计数值和字符编码压缩存储。

7.数学计算：-求解方程：使用牛顿迭代法、二分法等方法，寻找方程的根。

-矩阵操作：实现矩阵的相加、相乘、转置等操作。

以上只是VB中的一部分常用算法，还有很多其他的算法可以应用到实际问题中。

VB各种排序方法

冒泡排序举例：
对整数序列 8 5 2 4 3 按升序排序
每
小
58 5 2 2 2
趟沉
的
582 2 4 3 3
下
逐渐
284 4 3 4 4
一个
上
483 3 5 5 5
最
升
38 8 8 8 8
初第第第第
大的
始一二三四
状趟趟趟趟
程序
态结结结结果果果果
冒泡法排序一
Option Explicit
For I = 1 To N – 1 For J = I + 1 To N
2.进行每一轮的比较
If A(I) < A(J) then
3.在每一轮比较中，比较两
T = A( I )
个数的大小，根据比较结
A( I ) = A( J )
果决定是否交换两个数
A( J ) = T
End If
Next J Text1 = Text1 & Str(A(I)) Next I
Dim A(10) As Integer, Temp As Integer Dim I As Integer, J As Integer Dim Pointer As Integer Randomize For I = 1 To 10
A(I) = Int(Rnd * (100 - 1)) + 1
Text1 = Text1 & Str(A(I)) Next I For I = 1 To 9
Text1 = Text1 & Str(A(N))
筛选法排序
返回
Dim I As Integer, J As Integer

vb各种排序算法

vb各种排序算法'此文飞本人原创具体出处未知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 Long Private 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 IfNext iElseFor 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)。

VBA中的数据筛选和排序方法

VBA中的数据筛选和排序方法数据处理在许多项目中都是至关重要的一部分。

通过使用Visual Basic for Applications (VBA)，可以在Excel中自动化执行数据筛选和排序的任务。

VBA是一种编程语言，可用于Excel和其他Microsoft Office应用程序。

它提供了一系列功能和方法，可以轻松处理并操作大量数据。

在VBA中，数据筛选和排序方法可以帮助我们提取所需的数据并以特定的方式进行排序。

这些方法包括自动筛选、高级筛选和排序功能。

下面将详细介绍这些方法的用法和实例。

1. 自动筛选：自动筛选是一种简单而快速的筛选数据的方法。

它可以根据用户输入的条件筛选数据，并显示满足条件的结果。

以下是一个简单的示例，演示如何使用自动筛选。

```vbaSub AutoFilterExample()Range("A1:D10").AutoFilter Field:=1, Criteria1:="Apple"End Sub```以上示例中，我们选择了一个范围为A1:D10的区域，并使用AutoFilter方法根据第一列的条件筛选出包含"Apple"的数据。

2. 高级筛选：高级筛选是一种更复杂和灵活的筛选数据的方法。

它通过设置多个条件和操作符来筛选数据，并提供更多的筛选选项。

以下是一个使用高级筛选的示例。

```vbaSub AdvancedFilterExample()Range("A1:D10").AdvancedFilter Action:=xlFilterCopy, CriteriaRange:=Range("F1:F2"), CopyToRange:=Range("H1:J1"), Unique:=FalseEnd Sub```在上述示例中，我们选择了一个范围为A1:D10的区域，并使用AdvancedFilter方法根据F1:F2区域的条件筛选数据。

vba 排列降序语法

vba排列降序语法VBA（Visual Basic for Applications）是一种用于编写宏和自动化任务的编程语言，广泛应用于Microsoft Office套件中的各种应用程序，如Excel、Word和PowerPoint等。

在VBA中，排列降序是一种常见的操作，可以帮助我们对数据进行排序，使其按照从大到小的顺序排列。

本文将介绍VBA中排列降序的语法和使用方法。

在VBA中，我们可以使用Sort方法对数据进行排序。

Sort方法有两个参数，分别是Key1和Order1。

Key1表示排序的列或范围，可以是单个单元格、一列或一行的范围，也可以是整个表格的范围。

Order1表示排序的顺序，可以是升序（xlAscending）或降序（xlDescending）。

下面是一个简单的示例，演示了如何使用VBA对Excel表格中的数据进行降序排列：```vbaSub SortDescending()Dim rng As RangeSet rng = Range("A1:A10") '假设要排序的数据在A1到A10单元格中rng.Sort Key1:=rng, Order1:=xlDescending, Header:=xlNo '按照降序排列，不包含表头MsgBox "数据已按降序排列。

"End Sub```在上面的示例中，我们首先声明了一个Range对象rng，用于表示要排序的数据范围。

然后，我们使用Sort方法对rng进行排序，Key1参数设置为rng，表示按照rng的值进行排序，Order1参数设置为xlDescending，表示按照降序排列。

最后，我们使用MsgBox函数显示一个消息框，提示排序完成。

除了单个列或范围外，我们还可以对多个列进行排序。

在这种情况下，我们需要使用SortFields属性来指定排序的列和顺序。

下面是一个示例：```vbaSub SortMultipleColumns()Dim rng As RangeSet rng = Range("A1:C10") '假设要排序的数据在A1到C10单元格中With rng.Sort.SortFields.Clear '清除之前的排序设置.SortFields.Add Key:=rng.Columns(1), Order:=xlDescending '按照第一列降序排列.SortFields.Add Key:=rng.Columns(2), Order:=xlAscending '按照第二列升序排列.SortFields.Add Key:=rng.Columns(3), Order:=xlDescending '按照第三列降序排列.SetRange rng '设置排序范围.Header = xlNo '不包含表头.Apply '应用排序End WithMsgBox "数据已按指定顺序排列。

vba-一维数组排序-详解

vba 一维数组排序详解VBA（Visual Basic for Applications）是一种高级宏语言，它主要用于在Microsoft Office软件中编写自定义的宏和自动化任务。

其中一个常见的任务是对一维数组进行排序。

在本文中，我们将详细介绍VBA中一维数组排序的方法，并提供示例代码和指导意义。

一维数组是由相同数据类型的多个元素组成的线性数据结构。

在VBA中，我们可以使用一维数组来存储和操作大量相似的数据。

但是，有时我们需要对数组中的元素进行排序，以便更方便地查找和处理数据。

下面是VBA中一维数组排序的几种常见方法：1. 冒泡排序（Bubble Sort）：冒泡排序是一种简单而常见的排序算法。

它通过不断比较相邻的元素，并交换位置，将较大（或较小）的元素逐渐“冒泡”到数组的一端。

具体步骤如下：- 从数组的第一个元素开始，依次比较相邻的元素。

- 如果当前元素大于（或小于）后一个元素，则交换它们的位置。

- 重复上述步骤，直到没有交换操作发生。

示例代码：```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) - 1 - i If arr(j) > arr(j + 1) Thentemp = arr(j)arr(j) = arr(j + 1)arr(j + 1) = tempEnd IfNext jNext iEnd Sub```2. 快速排序（Quick Sort）：快速排序是一种高效的排序算法，它通过分割和递归的方法，将数组逐步划分为较小和较大的部分，然后对各个部分进行排序。

具体步骤如下：- 选择一个基准元素（通常选择第一个或最后一个元素）。

绝对简单易学的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

VBA 中的数据排序和查找技巧

VBA 中的数据排序和查找技巧在 VBA 中，数据排序和查找是操作数据的常见需求之一。

通过数据排序，可以对数据进行升序或降序排列，使数据更具有可读性和可分析性。

而数据查找则是在大量数据中快速定位目标值，提高数据处理的效率。

本文将介绍VBA 中的数据排序和查找技巧，帮助读者更好地处理和分析数据。

一、数据排序技巧数据排序是指根据指定的一列或多列数据，按照升序或降序的方式进行排列。

VBA 提供了 Sort 方法和 SortFields属性来实现数据排序。

1. Sort 方法Sort 方法是最常用的进行数据排序的方式。

它可以直接对指定的数据进行排序，可以按单个列或多个列进行排序，并且可以设置升序或降序。

以下是一个示例代码，演示了如何使用 Sort 方法对某一列数据进行升序排序：```vbaSub SortAscending()Dim ws As WorksheetSet ws = ThisWorkbook.Worksheets("Sheet1")ws.Range("A1:B10").Sort Key1:=ws.Range("A1"),Order1:=xlAscending, Header:=xlYesEnd Sub```2. SortFields 属性如果需要对多个列进行排序，可以使用SortFields 属性。

SortFields 属性可以设置多个列的排序规则，并通过 Add方法添加到 Sort 对象中。

以下是一个示例代码，演示了如何使用 SortFields 属性对两列数据进行排序：```vbaSub SortMultipleColumns()Dim ws As WorksheetSet ws = ThisWorkbook.Worksheets("Sheet1") Dim sortRange As RangeSet sortRange = ws.Range("A1:C10")Dim sortTable As RangeSet sortTable = ws.Range("A1:B10")With ws.Sort.SortFields.Clear.SortFields.Add Key:=sortTable.Columns(1), SortOn:=xlSortOnValues, Order:=xlAscending .SortFields.Add Key:=sortTable.Columns(2), SortOn:=xlSortOnValues, Order:=xlAscending .SetRange sortRange.Header = xlYes.ApplyEnd WithEnd Sub```二、数据查找技巧数据查找是指在大量数据中根据指定条件快速定位目标值。

Excel VBA排序典型算法

1.冒泡排序Public 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、选择排序1.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 Sub3.插入排序1.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复制代码4. 快速排序1.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 Sub5. 合并排序1.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复制代码。

VBA中的数据排序与过滤方法指南

VBA中的数据排序与过滤方法指南在Excel的VBA编程中，数据排序和过滤是常见的操作，可以帮助我们更好地整理和分析大量的数据。

本文将为您介绍一些常用的VBA 数据排序与过滤方法，帮助您在编写VBA代码时更高效地处理数据。

一、数据排序方法1. Range.Sort 方法Range.Sort方法是最常用的数据排序方法之一。

它可以根据指定的排序键将数据按升序或降序排列。

以下是排序方法的一个示例：```vbaSub SortData()Dim rng As RangeSet rng = Range("A1:D10")rng.Sort Key1:=rng.Columns(2), Order1:=xlAscending, _Header:=xlYes, OrderCustom:=1, _MatchCase:=False, Orientation:=xlTopToBottomEnd Sub```在上面的示例中，我们使用了Range对象的Sort方法对A1:D10范围内的数据进行排序。

Key1参数指定了排序的键列，这里我们选择了第二列；Order1参数指定了排序的顺序，这里使用了xlAscending表示升序；Header参数指定了是否包含标题行，这里设为xlYes表示包含；其他参数指定了排序的其他属性。

2. Range.AutoSort 方法Range.AutoSort方法是另一种常用的数据排序方法。

与Range.Sort方法相比，AutoSort方法更灵活，可以根据多个排序键进行排序。

以下是AutoSort方法的一个示例：```vbaSub AutoSortData()Dim rng As RangeSet rng = Range("A1:D10")With rng.AutoSort Key1:=.Columns(2), Order1:=xlAscending, _Header:=xlYes, OrderCustom:=1, _MatchCase:=False, Orientation:=xlTopToBottomEnd WithEnd Sub```在上面的示例中，我们使用了Range对象的AutoSort方法对A1:D10范围内的数据进行排序。

ExcelVBA排序算法

ExcelVBA排序算法Excel VBA排序算法不记得从哪里下载的了，和大家分享一下啊。

如有重复，请斑竹给予删除。

Excel VBA排序算法排序算法常用的有七种，分别是冒泡排序，选择排序，希尔排序，堆排序，桶排序，插入排序和快速排序。

以下是所有七种排序算法的源码，具体用法可参见源程序。

Option ExplicitPublic Const ZERO = 0Enum eOrderTypeASCENDING_ORDER = 0DESCENDING_ORDER = 1End Enum'用于指明重复次数的全局变量Public gIterations========================================================================== '冒泡排序Sub BubbleSort(MyArray(), ByVal nOrder As eOrderType)Dim IndexDim TEMPDim NextElement'先将已处理的元素个数置为0NextElement = ZERO'遍历每一个元素Do While (NextElement < UBound(MyArray))'读取当前最大下标Index = UBound(MyArray)'与前面的每一个元素比较Do While (Index > NextElement)'根据是升序或降序进行分别处理If nOrder = ASCENDING_ORDER Then'升序:如果当前值小于上一个值,则互换If MyArray(Index) < MyArray(Index - 1) Then TEMP = MyArray(Index)MyArray(Index) = MyArray(Index - 1) MyArray(Index - 1) = TEMPEnd IfElseIf nOrder = DESCENDING_ORDER Then '降序:如果当前值大于上一个值,则互换If MyArray(Index) > MyArray(Index - 1) Then TEMP = MyArray(Index)MyArray(Index) = MyArray(Index - 1) MyArray(Index - 1) = TEMPEnd IfEnd If'将当前下标移到上一个值Index = Index - 1'用于指明重复次数的全局变量gIterations = gIterations + 1Loop'将已处理的元素个数加1NextElement = NextElement + 1'用于指明重复次数的全局变量gIterations = gIterations + 1LoopEnd Sub====================================== ==================================== '桶排序Sub Bucket(MyArray(), ByVal nOrder As eOrderType)Dim IndexDim NextElementDim TheBucket'先将已处理的元素个数为最小下标加1NextElement = LBound(MyArray) + 1'遍历每一个元素While (NextElement <= UBound(MyArray))'读取当前元素TheBucket = MyArray(NextElement)'读取当前下标Index = NextElementDo'如果当前下标大于最小下标,则处理If Index > LBound(MyArray) Then'根据是升序或降序进行分别处理If nOrder = ASCENDING_ORDER Then'升序:如果当前值小于上一个值'则将下一个值放到当前值(当前值在TheBucket中不动)If TheBucket < MyArray(Index - 1) ThenMyArray(Index) = MyArray(Index - 1)Index = Index - 1ElseExit DoEnd IfElseIf nOrder = DESCENDING_ORDER Then'降序:如果当前值大于上一个值'则将下一个值放到当前值(当前值在TheBucket中不动)If TheBucket > MyArray(Index - 1) ThenMyArray(Index) = MyArray(Index - 1)Index = Index - 1ElseExit DoEnd IfEnd IfElseExit DoEnd If'用于指明重复次数的全局变量gIterations = gIterations + 1LoopMyArray(Index) = TheBucketNextElement = NextElement + 1'用于指明重复次数的全局变量gIterations = gIterations + 1WendEnd Sub====================================== ==================================== '堆排序Sub Heap(MyArray())Dim IndexDim SizeDim TEMP'读取最大下标Size = UBound(MyArray)'将当前要处理的置为1Index = 1'处理每一个元素While (Index <= Size)'向上筛选Call HeapSiftup(MyArray(), Index) Index = Index + 1'用于指明重复次数的全局变量gIterations = gIterations + 1WendIndex = SizeWhile (Index > 0)'当前值与第一个值互换TEMP = MyArray(0)MyArray(0) = MyArray(Index) MyArray(Index) = TEMP'向下筛选Call HeapSiftdown(MyArray(), Index - 1) Index = Index - 1'用于指明重复次数的全局变量gIterations = gIterations + 1WendEnd Sub'堆排序的向下筛选子程序Sub HeapSiftdown(MyArray(), M)Dim IndexDim ParentDim TEMPIndex = 0'Parent位置定位于2 * IndexParent = 2 * IndexDo While (Parent <= M)'如果当前Parent位的值后面的值要大,向后移Parent位If (Parent < M And MyArray(Parent) < MyArray(Parent + 1)) ThenParent = Parent + 1End If'如果当前值大于Parent位的值,结束筛选If MyArray(Index) >= MyArray(Parent) ThenExit DoEnd If'否则交换两个值TEMP = MyArray(Index)MyArray(Index) = MyArray(Parent)MyArray(Parent) = TEMP'当前位置移到ParentIndex = ParentParent = 2 * Index'用于指明重复次数的全局变量gIterations = gIterations + 1LoopEnd Sub'堆排序的向上筛选子程序Sub HeapSiftup(MyArray(), M)Dim IndexDim ParentDim TEMPIndex = MDo While (Index > 0)'只要Index / 2位置的值大于当前值就结束筛选Parent = Int(Index / 2)If MyArray(Parent) >= MyArray(Index) ThenExit DoEnd If'否则交换两值TEMP = MyArray(Index)MyArray(Index) = MyArray(Parent)MyArray(Parent) = TEMP'将当前点移到Index / 2Index = Parent'用于指明重复次数的全局变量gIterations = gIterations + 1LoopEnd Sub====================================== ==================================== '插入排序Sub Insertion(MyArray(), ByVal nOrder As eOrderType)Dim IndexDim TEMPDim NextElement'先将已处理的元素个数为最小下标加1NextElement = LBound(MyArray) + 1'遍历每一个元素While (NextElement <= UBound(MyArray))'读取当前下标Index = NextElementDo'如果当前下标大于最小下标,则处理If Index > LBound(MyArray) Then'根据是升序或降序进行分别处理If nOrder = ASCENDING_ORDER Then'升序:如果当前值小于上一个值,则互换If MyArray(Index) < MyArray(Index - 1) Then TEMP = MyArray(Index)MyArray(Index) = MyArray(Index - 1) MyArray(Index - 1) = TEMPIndex = Index - 1ElseExit DoEnd IfElseIf nOrder = DESCENDING_ORDER Then '降序:如果当前值大于上一个值,则互换If MyArray(Index) > MyArray(Index - 1) Then TEMP = MyArray(Index)MyArray(Index) = MyArray(Index - 1) MyArray(Index - 1) = TEMPIndex = Index - 1ElseExit DoEnd IfEnd IfElseExit DoEnd If'用于指明重复次数的全局变量gIterations = gIterations + 1LoopNextElement = NextElement + 1'用于指明重复次数的全局变量gIterations = gIterations + 1WendEnd Sub====================================== ==================================== '快速排序Sub QuickSort(MyArray(), L, R)Dim i, j, X, Yi = Lj = R'找出数组的中点X = MyArray((L + R) / 2)While (i <= j)'找出比中点大的数While (MyArray(i) < X And i < R)i = i + 1Wend'找出比中点小的数While (X < MyArray(j) And j > L)j = j - 1Wend'互换这两个数If (i <= j) ThenY = MyArray(i)MyArray(i) = MyArray(j)MyArray(j) = Yi = i + 1j = j - 1End If'用于指明重复次数的全局变量gIterations = gIterations + 1Wend'未完成时递归调用If (L < j) Then Call QuickSort(MyArray(), L, j)If (i < R) Then Call QuickSort(MyArray(), i, R)End Sub====================================== ==================================== '选择排序Sub Selection(MyArray(), ByVal nOrder As eOrderType)Dim IndexDim MinDim NextElementDim TEMP '已处理的元素的个数置为0 NextElement = 0 '遍历所有元素While (NextElement < UBound(MyArray))'读取最大下标,作为当前最小值下标Min = UBound(MyArray)'取倒数第二个下标Index = Min - 1'与所有元素比较While (Index >= NextElement)'根据是升序或降序进行分别处理If nOrder = ASCENDING_ORDER Then'根据比较结果重置最小下标If MyArray(Index) < MyArray(Min) ThenMin = IndexEnd IfElseIf nOrder = DESCENDING_ORDER Then'根据比较结果重置最小下标If MyArray(Index) > MyArray(Min) ThenMin = IndexEnd IfEnd IfIndex = Index - 1'用于指明重复次数的全局变量gIterations = gIterations + 1Wend'根据最小下,与当前值互换TEMP = MyArray(Min)MyArray(Min) = MyArray(NextElement)MyArray(NextElement) = TEMPNextElement = NextElement + 1'用于指明重复次数的全局变量gIterations = gIterations - 1WendEnd Sub====================================== ==================================== '希尔排序Sub ShellSort(MyArray(), ByVal nOrder As eOrderType)Dim DistanceDim SizeDim IndexDim NextElementDim TEMP'读取元素的数量Size = UBound(MyArray) - LBound(MyArray) + 1'定义当前跨度Distance = 1'将跨度定义为小于元素的数量的2的最大幂While (Distance <= Size)Distance = 2 * DistanceWend'再找出跨度的中点Distance = (Distance / 2) - 1While (Distance > 0)'读取中点的下标NextElement = LBound(MyArray) + Distance'移排序并移动中点(不大于最大下标)While (NextElement <= UBound(MyArray))'将中点作为当前下标Index = NextElementDo'中点在跨度后面则要处理If Index >= (LBound(MyArray) + Distance) Then'根据是升序或降序进行分别处理If nOrder = ASCENDING_ORDER Then'升序:如果当前值小于上一个值,则互换If MyArray(Index) < MyArray(Index - Distance) Then TEMP = MyArray(Index)MyArray(Index) = MyArray(Index - Distance) MyArray(Index - Distance) = TEMPIndex = Index - Distance'用于指明重复次数的全局变量gIterations = gIterations + 1ElseExit DoEnd IfElseIf nOrder = DESCENDING_ORDER Then'降序:如果当前值大于上一个值,则互换If MyArray(Index) > MyArray(Index - Distance) Then TEMP = MyArray(Index)MyArray(Index) = MyArray(Index - Distance) MyArray(Index - Distance) = TEMPIndex = Index - Distance'用于指明重复次数的全局变量gIterations = gIterations + 1ElseExit DoEnd IfEnd IfElseExit DoEnd IfLoopNextElement = NextElement + 1'用于指明重复次数的全局变量gIterations = gIterations + 1WendDistance = (Distance - 1) / 2'用于指明重复次数的全局变量gIterations = gIterations + 1WendEnd Sub。

[ExcelVBA]自定义排序的三种方法

[ExcelVBA]⾃定义排序的三种⽅法诸君好，前前期我们聊了VBA编程和数据的常规排序……VBA常⽤⼩代码105：Rang对象的排序操作……今天我们再聊下⾃定义排序……何谓⾃定义排序，就是按指定的顺序对数据源进⾏排序呗……今⼀共分享了三种⽅法。

第1种⽅法是系统⾃带的OrderCustom，优点是代码简洁，缺点是⾃定义序列有字符长度限制（255个）。

第2种⽅法是字典+数组设置序列号，再使⽤了辅助列进⾏排序。

优点是不会破坏单元格的形式和结构，⽐如单元格中存在的公式、背景等。

第3种⽅法是只使⽤字典+数组，借助简单桶排序的技巧，直接对数据在数组中进⾏排序。

优点是效率较⾼，缺点是会破坏单元格的结构，⽐如消除公式等。

（第1种建议掌握，第2种建议了解，第3种……能懂就懂，不懂先放着吧~）举个例⼦。

如下图所⽰，A:C列是数据源。

现需要根据E列所指定的部门先后顺序，对数据源进⾏重新排序，如果部门不在指定序列内，则排放在数据源末尾。

排序结果如下图。

第1种⽅法代码如下：Sub FreeSort()'eh技术论坛 VBA编程学习与实践看见星光Dim n&, rng As RangeSet rng = Range("e2:e" & Cells(Rows.Count, "e").End(xlUp).Row)Application.AddCustomList (rng)'增加⼀个⾃定义序列,该参数除了⽀持单元格对象，也⽀持数组。

n = Application.CustomListCount'⾃定义序列的数⽬Range("a:c").Sort key1:=[a1], order1:=xlAscending, Header:=xlYes, ordercustom:=n + 1'使⽤⾃定义排序，ordercustom指定使⽤哪个⾃定义序列排序。

ExcelVBA中使用工作表排序的方法

ExcelVBA中使用工作表排序的方法工作表内单元格数据的排序，使用Range.Sort 命令。

但是后面的参数较多，新人一般采用录制宏时出来一大堆，也不知道该如何编辑。

因此，我开这一个帖子，给新人普及一下：Range("待排序数据区域").Sort(Key1, Order1, Key2, Type, Order2, Key3, Order3,Header, OrderCustom, MatchCase, Orientation, SortMethod, DataOption1, DataOption2, DataOption3)其中各类型参数的意义如下：① key1、key2、key3这些key是排序的关键列（或行）的单元格地址，如 Range("A1") 实际只要选对列标题即可，对行数要求不敏感。

【行数要求不敏感】即数据区域中任意行数都可以：Range("A1")、或Range("A2")、或Range("A1000")都可以。

【注意】1. 一次Sort只能调用至多3个参数，没有key4可以使用。

2. 至少使用1个参数即可，即key2、key3可以省去不用。

【引用方法】1. 带参数名引用，如： key1:=Range("G3")带参数名引用时2. 参数位置引用，即按照上述Sort命令的参数顺序直接应用，如：Range("A1:I19").Sort key1:=Range("G3") 即第1位置参数即为key1② Order1、Order2、Order3这些Order是排序的顺序模式指定参数。

即：A-Z升序、或Z-A 降序参数的模式名称为：A-Z升序= xlAscending 或直接=1Z-A降序= xlDescending 或直接=2带参数名引用时：Order1:=xlAscending 或 Order1:= 1参数位置引用时，紧跟key后面。

VBA中的数组排序

VBA中的数组排序在Excel中没有提供直接的⽅法或函数⽤于数组排序，因此若要使⽤VBA进⾏数组排序，则需要采⽤我们在数据结构与算法课程中学到的排序算法。

这⾥转载了中给出的使⽤VBA进⾏数组排序的两种⽅法，分别采⽤的排序算法为：选择排序和冒泡排序。

Method 1: Selection SortFunction SelectionSort(TempArray As Variant)Dim MaxVal As VariantDim MaxIndex As IntegerDim i, j As Integer' Step through the elements in the array starting with the' last element in the array.For i = UBound(TempArray) To 1 Step -1' Set MaxVal to the element in the array and save the' index of this element as MaxIndex.MaxVal = TempArray(i)MaxIndex = i' Loop through the remaining elements to see if any is' larger than MaxVal. If it is then set this element' to be the new MaxVal.For j = 1 To iIf TempArray(j) > MaxVal ThenMaxVal = TempArray(j)MaxIndex = jEnd IfNext j' If the index of the largest element is not i, then' exchange this element with element i.If MaxIndex < i ThenTempArray(MaxIndex) = TempArray(i)TempArray(i) = MaxValEnd IfNext iEnd FunctionSub SelectionSortMyArray()Dim TheArray As Variant' Create the array.TheArray = Array("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten")' Sort the Array and display the values in order.SelectionSort TheArrayFor i = 1 To UBound(TheArray)MsgBox TheArray(i)Next iEnd SubMethod 2: Bubble SortFunction BubbleSort(TempArray As Variant)Dim Temp As VariantDim i As IntegerDim NoExchanges As Integer' Loop until no more "exchanges" are made.DoNoExchanges = True' Loop through each element in the array.For i = 1 To UBound(TempArray) - 1' If the element is greater than the element' following it, exchange the two elements.If TempArray(i) > TempArray(i + 1) ThenNoExchanges = FalseTemp = TempArray(i)TempArray(i) = TempArray(i + 1)TempArray(i + 1) = TempEnd IfNext iLoop While Not (NoExchanges)End FunctionSub BubbleSortMyArray()Dim TheArray As Variant' Create the array.TheArray = Array(15, 8, 11, 7, 33, 4, 46, 19, 20, 27, 43, 25, 36) ' Sort the Array and display the values in order.BubbleSort TheArrayFor i = 1 To UBound(TheArray)MsgBox TheArray(i)Next iEnd Sub。