Sorting is a core concept in programming because it helps organize data in a meaningful way. When data is sorted, searching becomes faster, reports become clearer, and many algorithms work more efficiently. Among the different sorting techniques, Merge Sort is one of the most reliable and widely used algorithms. It is known for its predictable performance and its ability to handle large amounts of data smoothly.
with hands-on learning.
get the skills and confidence to land your next move.
Merge Sort follows a simple idea called “divide and conquer.” Instead of sorting the whole list at once, it breaks the list into smaller parts, sorts those parts, and then merges them back together in the correct order. In VB .NET, learning Merge Sort is very helpful for beginners because it introduces recursion, array manipulation, and logical thinking in a clean and structured way. Even though it looks advanced at first, the concept becomes easy once you see it step by step.
Program 1: Basic Merge Sort Using Recursion
This program demonstrates the classic recursive approach to Merge Sort. It divides the array into halves and then merges them in sorted order.
Module Module1
Sub MergeSort(arr() As Integer, left As Integer, right As Integer)
If left < right Then
Dim mid As Integer = (left + right) \ 2
MergeSort(arr, left, mid)
MergeSort(arr, mid + 1, right)
Merge(arr, left, mid, right)
End If
End Sub
Sub Merge(arr() As Integer, left As Integer, mid As Integer, right As Integer)
Dim n1 As Integer = mid - left + 1
Dim n2 As Integer = right - mid
Dim L(n1 - 1) As Integer
Dim R(n2 - 1) As Integer
Array.Copy(arr, left, L, 0, n1)
Array.Copy(arr, mid + 1, R, 0, n2)
Dim i As Integer = 0, j As Integer = 0, k As Integer = left
While i < n1 AndAlso j < n2
If L(i) <= R(j) Then
arr(k) = L(i)
i += 1
Else
arr(k) = R(j)
j += 1
End If
k += 1
End While
While i < n1
arr(k) = L(i)
i += 1
k += 1
End While
While j < n2
arr(k) = R(j)
j += 1
k += 1
End While
End Sub
Sub Main()
Dim numbers() As Integer = {38, 27, 43, 3, 9, 82, 10}
Dim num As Integer
MergeSort(numbers, 0, numbers.Length - 1)
Console.WriteLine("Sorted array:")
For Each num In numbers
Console.Write(num & " ")
Next
Console.ReadLine()
End Sub
End ModuleThis program works by repeatedly dividing the array until single elements remain. These elements are then merged back together in sorted order. Beginners can understand this by focusing on how smaller sorted arrays are combined to form a bigger sorted array.
Program 2: Merge Sort with Display of Original and Sorted Array
This version prints the array before and after sorting to make the process clearer.
Module Module1
Sub MergeSort(arr() As Integer, left As Integer, right As Integer)
If left < right Then
Dim mid As Integer = (left + right) \ 2
MergeSort(arr, left, mid)
MergeSort(arr, mid + 1, right)
Merge(arr, left, mid, right)
End If
End Sub
Sub Merge(arr() As Integer, left As Integer, mid As Integer, right As Integer)
Dim temp(right - left) As Integer
Dim i As Integer = left, j As Integer = mid + 1, k As Integer = 0
While i <= mid AndAlso j <= right
If arr(i) <= arr(j) Then
temp(k) = arr(i)
i += 1
Else
temp(k) = arr(j)
j += 1
End If
k += 1
End While
While i <= mid
temp(k) = arr(i)
i += 1
k += 1
End While
While j <= right
temp(k) = arr(j)
j += 1
k += 1
End While
Array.Copy(temp, 0, arr, left, temp.Length)
End Sub
Sub Main()
Dim numbers() As Integer = {20, 5, 15, 10, 30}
Dim num As Integer
Console.WriteLine("Original array:")
For Each num In numbers
Console.Write(num & " ")
Next
Console.WriteLine()
MergeSort(numbers, 0, numbers.Length - 1)
Console.WriteLine("Sorted array:")
For Each num In numbers
Console.Write(num & " ")
Next
Console.ReadLine()
End Sub
End ModuleSeeing the original and sorted arrays side by side helps beginners clearly understand what Merge Sort achieves. It also makes debugging and learning more comfortable.
Program 3: Merge Sort in Descending Order
This program modifies the comparison to sort the array in descending order.
Module Module1
Sub MergeSort(arr() As Integer, left As Integer, right As Integer)
If left < right Then
Dim mid As Integer = (left + right) \ 2
MergeSort(arr, left, mid)
MergeSort(arr, mid + 1, right)
Merge(arr, left, mid, right)
End If
End Sub
Sub Merge(arr() As Integer, left As Integer, mid As Integer, right As Integer)
Dim temp(right - left) As Integer
Dim i As Integer = left, j As Integer = mid + 1, k As Integer = 0
While i <= mid AndAlso j <= right
If arr(i) >= arr(j) Then
temp(k) = arr(i)
i += 1
Else
temp(k) = arr(j)
j += 1
End If
k += 1
End While
While i <= mid
temp(k) = arr(i)
i += 1
k += 1
End While
While j <= right
temp(k) = arr(j)
j += 1
k += 1
End While
Array.Copy(temp, 0, arr, left, temp.Length)
End Sub
Sub Main()
Dim numbers() As Integer = {4, 7, 1, 9, 2}
Dim num As Integer
MergeSort(numbers, 0, numbers.Length - 1)
Console.WriteLine("Sorted array in descending order:")
For Each num In numbers
Console.Write(num & " ")
Next
Console.ReadLine()
End Sub
End ModuleThis example shows how flexible Merge Sort is. Beginners learn that changing a single comparison can completely change the sorting order.
Program 4: Merge Sort Using a Separate Sort Procedure
This program wraps Merge Sort inside a reusable procedure.
Module Module1
Sub SortArray(arr() As Integer)
MergeSort(arr, 0, arr.Length - 1)
End Sub
Sub MergeSort(arr() As Integer, left As Integer, right As Integer)
If left < right Then
Dim mid As Integer = (left + right) \ 2
MergeSort(arr, left, mid)
MergeSort(arr, mid + 1, right)
Merge(arr, left, mid, right)
End If
End Sub
Sub Merge(arr() As Integer, left As Integer, mid As Integer, right As Integer)
Dim temp(right - left) As Integer
Dim i As Integer = left, j As Integer = mid + 1, k As Integer = 0
While i <= mid AndAlso j <= right
If arr(i) <= arr(j) Then
temp(k) = arr(i)
i += 1
Else
temp(k) = arr(j)
j += 1
End If
k += 1
End While
While i <= mid
temp(k) = arr(i)
i += 1
k += 1
End While
While j <= right
temp(k) = arr(j)
j += 1
k += 1
End While
Array.Copy(temp, 0, arr, left, temp.Length)
End Sub
Sub Main()
Dim numbers() As Integer = {14, 6, 23, 1, 8}
Dim num As Integer
SortArray(numbers)
Console.WriteLine("Sorted array:")
For Each num In numbers
Console.Write(num & " ")
Next
Console.ReadLine()
End Sub
End ModuleThis approach teaches beginners how to organize code better. It also shows how sorting logic can be reused in different programs.
Program 5: Merge Sort with Negative Numbers
This program confirms that Merge Sort works with both positive and negative values.
Module Module1
Sub MergeSort(arr() As Integer, left As Integer, right As Integer)
If left < right Then
Dim mid As Integer = (left + right) \ 2
MergeSort(arr, left, mid)
MergeSort(arr, mid + 1, right)
Merge(arr, left, mid, right)
End If
End Sub
Sub Merge(arr() As Integer, left As Integer, mid As Integer, right As Integer)
Dim temp(right - left) As Integer
Dim i As Integer = left, j As Integer = mid + 1, k As Integer = 0
While i <= mid AndAlso j <= right
If arr(i) <= arr(j) Then
temp(k) = arr(i)
i += 1
Else
temp(k) = arr(j)
j += 1
End If
k += 1
End While
While i <= mid
temp(k) = arr(i)
i += 1
k += 1
End While
While j <= right
temp(k) = arr(j)
j += 1
k += 1
End While
Array.Copy(temp, 0, arr, left, temp.Length)
End Sub
Sub Main()
Dim numbers() As Integer = {3, -2, 5, -1, 0}
Dim num As Integer
MergeSort(numbers, 0, numbers.Length - 1)
Console.WriteLine("Sorted array with negative numbers:")
For Each num In numbers
Console.Write(num & " ")
Next
Console.ReadLine()
End Sub
End ModuleThis example reassures beginners that Merge Sort is reliable and handles different kinds of numeric data correctly.
Frequently Asked Questions (FAQ)
This section answers common beginner questions about Merge Sort in VB .NET.
Q1. Is Merge Sort faster than Bubble Sort?
Yes, Merge Sort is much faster for large datasets because it has better time complexity.
Q2. Does Merge Sort use extra memory?
Yes, Merge Sort requires additional memory to store temporary arrays during merging.
Q3. Can Merge Sort handle negative numbers?
Yes, it works perfectly with both negative and positive numbers.
Q4. Is Merge Sort stable?
Yes, Merge Sort is a stable sorting algorithm, meaning equal elements keep their order.
Q5. Why should beginners learn Merge Sort?
It teaches recursion, problem decomposition, and efficient sorting logic.
Conclusion
Merge Sort is a powerful and dependable sorting algorithm that every beginner should learn. In VB .NET, it helps build a strong understanding of recursion, arrays, and structured problem solving. Although it may look complex at first, breaking it into smaller steps makes it much easier to understand.
By practicing these VB .NET Merge Sort programs, beginners can gain confidence and improve their programming skills. With time and practice, Merge Sort becomes a valuable tool that prepares learners for more advanced algorithms and real-world applications.
