MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Visual Basic数组操作完全指南

2021-11-011.8k 阅读

Visual Basic 数组基础

在 Visual Basic 中，数组是一种非常重要的数据结构，它允许我们在一个变量名下存储多个相同类型的数据。数组的每个元素都有一个唯一的索引，通过这个索引可以访问和操作数组中的元素。

1. 数组的声明

声明数组与声明普通变量类似，但需要指定数组的维度和大小。

  • 一维数组声明：
Dim numbers(9) As Integer

上述代码声明了一个名为 numbers 的一维数组，它可以存储 10 个 Integer 类型的元素。数组的索引从 0 开始，所以有效的索引范围是 0 到 9。

  • 多维数组声明：
Dim matrix(2, 3) As Double

这声明了一个二维数组 matrix，第一维大小为 3（索引 0 到 2），第二维大小为 4（索引 0 到 3）。总共有 3 * 4 = 12 个元素，可用于存储 Double 类型的数据，常用于表示矩阵等数据结构。

2. 数组的初始化

  • 直接初始化：
Dim fruits() As String = {"Apple", "Banana", "Cherry"}

在这种方式下，我们声明并初始化了一个 String 类型的数组 fruits，数组的大小会根据初始化的值自动确定，这里大小为 3。

  • 分步初始化：
Dim numbers(2) As Integer
numbers(0) = 1
numbers(1) = 2
numbers(2) = 3

先声明数组，然后通过索引逐个为数组元素赋值。

数组的基本操作

1. 访问数组元素

通过数组名和索引来访问数组中的元素。

Dim numbers(2) As Integer
numbers(0) = 10
numbers(1) = 20
numbers(2) = 30

Dim value As Integer = numbers(1)
MsgBox("The value at index 1 is: " & value)

上述代码先为数组 numbers 赋值，然后通过索引 1 访问并获取对应的值，最后使用 MsgBox 显示该值。

2. 修改数组元素

同样通过索引来修改数组元素的值。

Dim fruits() As String = {"Apple", "Banana", "Cherry"}
fruits(1) = "Orange"
For Each fruit In fruits
    MsgBox(fruit)
Next

代码将数组 fruits 中索引为 1 的元素从 “Banana” 修改为 “Orange”，然后通过 For Each 循环遍历显示修改后的数组元素。

3. 遍历数组

  • For 循环遍历：
Dim numbers(4) As Integer
numbers(0) = 1
numbers(1) = 2
numbers(2) = 3
numbers(3) = 4
numbers(4) = 5

For i As Integer = 0 To numbers.Length - 1
    MsgBox("Element at index " & i & " is: " & numbers(i))
Next

For 循环通过索引从 0 到数组长度减 1 来遍历数组，访问每个元素并显示其值。

  • For Each 循环遍历：
Dim fruits() As String = {"Apple", "Banana", "Cherry"}
For Each fruit In fruits
    MsgBox(fruit)
Next

For Each 循环更简洁，不需要关注索引，直接对数组中的每个元素进行操作，这里是显示每个水果的名称。

动态数组

有时候我们在编写程序时，可能无法预先确定数组的大小，这时候就需要使用动态数组。

1. 动态数组的声明

Dim dynamicNumbers() As Integer

这里只声明了一个 Integer 类型的动态数组，没有指定大小。

2. 使用 ReDim 语句调整大小

Dim dynamicNumbers() As Integer
ReDim dynamicNumbers(4)
dynamicNumbers(0) = 1
dynamicNumbers(1) = 2
dynamicNumbers(2) = 3
dynamicNumbers(3) = 4
dynamicNumbers(4) = 5

ReDim Preserve dynamicNumbers(9)
dynamicNumbers(5) = 6
dynamicNumbers(6) = 7
dynamicNumbers(7) = 8
dynamicNumbers(8) = 9
dynamicNumbers(9) = 10

For Each number In dynamicNumbers
    MsgBox(number)
Next

首先使用 ReDim 语句为动态数组 dynamicNumbers 分配 5 个元素的空间，并赋值。然后再次使用 ReDim Preserve 语句调整数组大小为 10，同时保留原有的数据，最后通过 For Each 循环显示所有元素。

数组的排序

在实际应用中，经常需要对数组中的元素进行排序。Visual Basic 提供了多种排序算法的实现方式。

1. 冒泡排序

冒泡排序是一种简单的排序算法，它重复地比较相邻的元素并交换位置，将最大（或最小）的元素“冒泡”到数组的末尾。

Sub BubbleSort(ByRef numbers() As Integer)
    Dim n As Integer = numbers.Length
    Dim temp As Integer
    For i As Integer = 0 To n - 2
        For j As Integer = 0 To n - i - 2
            If numbers(j) > numbers(j + 1) Then
                temp = numbers(j)
                numbers(j) = numbers(j + 1)
                numbers(j + 1) = temp
            End If
        Next
    Next
End Sub

Dim numbers() As Integer = {5, 4, 3, 2, 1}
BubbleSort(numbers)
For Each number In numbers
    MsgBox(number)
Next

上述代码定义了一个 BubbleSort 子过程，接受一个 Integer 类型的数组并对其进行冒泡排序。然后声明并初始化一个数组，调用排序过程后，通过 For Each 循环显示排序后的数组。

2. 快速排序

快速排序是一种高效的排序算法，采用分治思想。

Sub QuickSort(ByRef numbers() As Integer, ByVal left As Integer, ByVal right As Integer)
    Dim i As Integer = left
    Dim j As Integer = right
    Dim pivot As Integer = numbers((left + right) \ 2)
    Do
        While numbers(i) < pivot
            i = i + 1
        End While
        While numbers(j) > pivot
            j = j - 1
        End While
        If i <= j Then
            Dim temp As Integer = numbers(i)
            numbers(i) = numbers(j)
            numbers(j) = temp
            i = i + 1
            j = j - 1
        End If
    Loop While i <= j
    If left < j Then
        QuickSort(numbers, left, j)
    End If
    If i < right Then
        QuickSort(numbers, i, right)
    End If
End Sub

Dim numbers() As Integer = {3, 6, 8, 10, 1, 2, 1}
QuickSort(numbers, 0, numbers.Length - 1)
For Each number In numbers
    MsgBox(number)
Next

QuickSort 子过程通过递归的方式对数组进行快速排序。先选取一个基准元素 pivot，然后将数组分为两部分，使得左边部分的元素小于等于基准元素，右边部分的元素大于等于基准元素，最后对左右两部分分别递归排序。

数组的搜索

在数组中查找特定元素是常见的操作。

1. 线性搜索

线性搜索是最简单的搜索算法，它从数组的第一个元素开始，逐个比较每个元素，直到找到目标元素或遍历完整个数组。

Function LinearSearch(ByVal numbers() As Integer, ByVal target As Integer) As Integer
    For i As Integer = 0 To numbers.Length - 1
        If numbers(i) = target Then
            Return i
        End If
    Next
    Return -1
End Function

Dim numbers() As Integer = {10, 20, 30, 40, 50}
Dim target As Integer = 30
Dim index As Integer = LinearSearch(numbers, target)
If index <> -1 Then
    MsgBox("Element found at index " & index)
Else
    MsgBox("Element not found")
End If

LinearSearch 函数接受一个数组和目标元素，返回目标元素在数组中的索引，如果未找到则返回 -1。

2. 二分搜索

二分搜索适用于已排序的数组，它通过不断将数组分成两部分并比较中间元素与目标元素来缩小搜索范围。

Function BinarySearch(ByVal numbers() As Integer, ByVal target As Integer) As Integer
    Dim left As Integer = 0
    Dim right As Integer = numbers.Length - 1
    While left <= right
        Dim mid As Integer = (left + right) \ 2
        If numbers(mid) = target Then
            Return mid
        ElseIf numbers(mid) < target Then
            left = mid + 1
        Else
            right = mid - 1
        End If
    End While
    Return -1
End Function

Dim numbers() As Integer = {10, 20, 30, 40, 50}
Array.Sort(numbers)
Dim target As Integer = 30
Dim index As Integer = BinarySearch(numbers, target)
If index <> -1 Then
    MsgBox("Element found at index " & index)
Else
    MsgBox("Element not found")
End If

BinarySearch 函数首先设置左右边界，然后在循环中计算中间索引，根据中间元素与目标元素的比较结果调整搜索范围，直到找到目标元素或确定目标元素不存在。

数组与函数

1. 传递数组给函数

可以将数组作为参数传递给函数，以便在函数中对数组进行操作。

Function SumArray(ByVal numbers() As Integer) As Integer
    Dim sum As Integer = 0
    For Each number In numbers
        sum = sum + number
    Next
    Return sum
End Function

Dim numbers() As Integer = {1, 2, 3, 4, 5}
Dim total As Integer = SumArray(numbers)
MsgBox("The sum of the array is: " & total)

SumArray 函数接受一个 Integer 类型的数组，并计算数组元素的总和，然后返回结果。

2. 函数返回数组

函数也可以返回一个数组。

Function GenerateArray(ByVal size As Integer) As Integer()
    Dim result(size - 1) As Integer
    For i As Integer = 0 To size - 1
        result(i) = i * 2
    Next
    Return result
End Function

Dim newArray() As Integer = GenerateArray(5)
For Each number In newArray
    MsgBox(number)
Next

GenerateArray 函数接受一个整数参数 size，生成一个包含 size 个元素的数组，每个元素是其索引的两倍，然后返回这个数组。

特殊数组类型

1. 锯齿数组

锯齿数组是数组的数组，即每个数组元素又是一个数组，且这些子数组的大小可以不同。

Dim jaggedArray()() As Integer = { _
    New Integer() {1, 2}, _
    New Integer() {3, 4, 5}, _
    New Integer() {6} _
}

For i As Integer = 0 To jaggedArray.Length - 1
    For j As Integer = 0 To jaggedArray(i).Length - 1
        MsgBox("Element at [" & i & "][" & j & "] is: " & jaggedArray(i)(j))
    Next
Next

上述代码声明并初始化了一个锯齿数组 jaggedArray，然后通过两层循环遍历并显示所有元素。

2. 变体数组

变体数组可以存储不同类型的数据。

Dim variantArray() As Variant
ReDim variantArray(2)
variantArray(0) = 10
variantArray(1) = "Hello"
variantArray(2) = 3.14

For Each element In variantArray
    MsgBox(element)
Next

这里声明了一个变体数组，通过 ReDim 分配空间后，分别存储了 Integer、String 和 Double 类型的数据，最后通过 For Each 循环显示所有元素。

数组在实际应用中的场景

1. 数据统计

在处理大量数据时，数组可用于统计各类数据的出现次数等。

Dim scores() As Integer = {85, 90, 78, 85, 95}
Dim scoreCount(100) As Integer
For Each score In scores
    scoreCount(score) = scoreCount(score) + 1
Next

For i As Integer = 0 To 100
    If scoreCount(i) > 0 Then
        MsgBox("Score " & i & " appears " & scoreCount(i) & " times")
    End If
Next

这段代码统计了分数数组 scores 中每个分数出现的次数，并显示结果。

2. 矩阵运算

二维数组常用于表示矩阵，进行矩阵的加法、乘法等运算。

Dim matrixA(1, 1) As Integer
matrixA(0, 0) = 1
matrixA(0, 1) = 2
matrixA(1, 0) = 3
matrixA(1, 1) = 4

Dim matrixB(1, 1) As Integer
matrixB(0, 0) = 5
matrixB(0, 1) = 6
matrixB(1, 0) = 7
matrixB(1, 1) = 8

Dim resultMatrix(1, 1) As Integer
For i As Integer = 0 To 1
    For j As Integer = 0 To 1
        resultMatrix(i, j) = matrixA(i, j) + matrixB(i, j)
    Next
Next

For i As Integer = 0 To 1
    For j As Integer = 0 To 1
        MsgBox("Element at [" & i & "][" & j & "] of result matrix is: " & resultMatrix(i, j))
    Next
Next

上述代码实现了两个 2x2 矩阵的加法，并显示结果矩阵的元素。

通过以上对 Visual Basic 数组操作的全面介绍，从基础声明、操作、动态数组，到排序、搜索、特殊数组类型以及实际应用场景，希望能帮助开发者全面掌握数组在 Visual Basic 中的使用，编写出更高效、灵活的程序。