Declaring variables and arrays

//Declare a variable with identifier ‘Counter’ of Type Integer

Declare counter as Integer

//Declare a Variable with Identifier ‘Name’ of type string

Declare Name as String

//declare a 1D array of m integer elements with identifier names

Declare Names: Array[1:m] of integer

//note that we can also start an array from 0, thus for m elements starting from 0:

Declare Names: Array[0:m-1] of Integer

//Declare a 2D array of m rows and n columns with identifier ‘Values’ of type Real(Start indexes at 1)

Declare Values: Array[1:m, 1:n] //m rows, n columns always read in that order like a matrix

Other data types that are often used:

• Char(single characters)
• Boolean(True or False)
• Real(Decimal numbers such as 69.5)
• Date(stores a date value in the format #mm/dd/yyyy#)

Linear search

Linear search is a basic way of searching for a value in an array

It works by simply comparing each element of the array with the search value

Assume a 1D array nums of m elements is already initialized, search for the index where the number
x is found in the array and output a suitable message if it is not found:

Declare found as Boolean  False

Declare count as Integer  1

For count = 1 to m

If nums[i] = x Then

Found = True

Output(“Found at index: “, count)

End If

Next count
Bubble sort

Bubble sort is one of the most basic ways to sort an array, there are two possible implementations
the standard way and the efficient way

Bubble sort works by comparing each adjacent elements and swapping them if they are out of order.

It works in two steps, a first pass, for m array elements, the first pass will iterate m times

And a second pass, for m array elements, the second pass iterates m – 1 times

Suppose we have a 1D array with identifier ‘nums’ of m integer elements that is already initialized
and we want to sort it in ascending order(note that we are using indexes 1 to m here)

Standard Bubble sort

Declare temp as Integer

Declare i,j as Integer

i  1, j  1

for i = 1 to m

for j = 1 to m – i //after each pass the last element is already sorted, no need to sort it again

if nums[j] > nums[j+1] Then

temp  nums[j]

nums[j]  nums[j+1]

nums[j+1]  temp

End If

Next j

Next i

VB.Net implementation:

Dim temp As Integer

Dim i, j As Integer
i = 1 : j = 1
For i = 1 To m
For j = 1 To m - i
If nums(j) > nums(j + 1) Then
temp = nums(j)
 nums(j) = nums(j + 1)
nums(j + 1) = temp
End If
Next
Next

Efficient bubble sort

Declare temp as Integer

Declare Sorted as Boolean = False

Declare i,j as Integer

i  1, j  1

while sorted = False

Sorted = True

For i = 1 to m – j

If nums[i] > nums[i + 1] Then

Sorted  False

Temp  nums[i]

Nums[i]  nums[i + 1]

Nums[i + 1]  temp

End If

Next i

jj+1

End While

VB.Net implementation:
 Dim temp As Integer
Dim sorted As Boolean = False
Dim i, j As Integer
i = 1 : j = 1
While sorted = False
sorted = True
For i = 1 To m - j
If nums(i) > nums(i + 1) Then
sorted = False
temp = nums(i)
nums(i) = nums(i + 1)
nums(i + 1) = temp
End If
Next
j = j + 1
End While

Note that a 2D array can also be sorted, the VB.Net implementation for sorting an array with 5 rows
and 2 columns is given below (Note we are sorting row-wise here):

Dim temp1, temp2 As Integer

Dim Sorted As Boolean = False
Dim i, j As Integer
i = 1 : j = 1
While Sorted = False
Sorted = True
For i = 1 To 5 - j
If arr(i, 1) > arr(i + 1, 1) Then
Sorted = False
temp1 = arr(i, 1)
temp2 = arr(i, 2)
arr(i, 1) = arr(i + 1, 1)
arr(i, 2) = arr(i + 1, 2)
arr(i + 1, 1) = temp1
arr(i + 1, 2) = temp2
End If
Next
j += 1
End While
Record structure

This is a user-defined data type, it is often used to store data about one object consisting of multiple
elements

For example consider a classroom with 20 students, and we want to store their names and grade in
an array of records

Type ClassRoom

Declare Name as String

Declare Grade as Integer

End Type

Declare Students: Array[1:20] of ClassRoom

//suppose we want to add the data about a student named Rushil at the 10 th position in the array,
his grade is 69

Students[10].Name  “Rushil”

Students[10].Grade  69

Note: An array of records can be sorted just like a 1D array using bubble sort the only difference is
that we compare on the numerical value, here it is grade and the variable temp is declared as type
ClassRoom, try to write pseudocode to sort the array of records yourself.
Procedures

Procedures are an easy way to break down a program into modules

Procedures can take parameters ByValue or ByReference

ByValue: A copy of the variable is passed from the calling program to the procedure, hence the value
cannot change in the calling program

ByReference: The address of the variable being passed from the calling program is given to the
procedure hence, the variable can be modified by the procedure

Note: Functions also take parameters byValue and ByReference exactly the same

Note: Arrays passed to the procedure and to a function always get passed ByReference no matter
what

Syntax for procedures:

Suppose we have a procedure that takes a number and Outputs the factorial of that number

Procedure Factorial(ByValue num as Integer)

If num = 0 Then

Output(1)

Else

Declare result as Integer = 1

While num > 0

result  result * num

num  num - 1

End While

Output(result)

End If

End Procedure

Start

Declare number as Integer

Output(“Input number”)

Input(number)

Call Factorial(number)

End
VB.Net implementation:

Sub Factorial(ByVal num As Integer)

If num = 0 Then
Console.WriteLine(1)
Else
Dim result As Integer = 1
While num > 0
result = result * num
num = num - 1
End While
Console.WriteLine(result)
End If
End Sub
Sub Main(args As String())
Console.WriteLine("Input number: ")
Dim number As Integer = Console.ReadLine()
Call Factorial(number)
Console.ReadKey()
End Sub

Functions

Functions work the same as procedures, except functions always have to return a value

For example, suppose we have a function that performs a linear search on an array, it will take the
array(n elements, starting from 1) as a parameter as well as a search value ByValue and will then
return the index where the value is found or returns 0 if not found

Function LinearSearch(ByValue arr() as Integer, ByValue search as Integer) Returns Integer

//Notice that I passed the arr by value, but the function will take it byRef anyways

Declare index as Integer  1

For index = 1 to n

If arr(index) = search Then

Return index //Index of value returned and execution of calling program resumes

End If

Next index

Return(0) //Only reaches this statement if loop completed and hence value not found

End Function
Start

//Assume arr is already initialized

Declare search as Integer //value to be searched for

Input(search)

If LinearSearch(arr,search) = 0 Then

Output(“Not Found”)

Else

Output(“Found at Index LinearSearch(arr,search))

End If

End

Note: Once the ‘return’ statement is executed, the function stops and we go back to main program

File handling

Often, data needs to be stored permanently, that is when a file is used

Suppose we have a file students.txt containing the names of all the students in a school and we want
to output all the names:

Declare Line as String

OpenFile “Students.txt” for read

While Not EOF(“Students.txt”) //While not end of file

ReadFile “Students.txt”, line

Output(line)

End While

CloseFile “Students.txt”

Now suppose we have a blank file Names.Txt and we want to allow the user to input 10 names into
the file:
OpenFile “Names.txt” For write

Declare name as String

Declare counter as integer  1

For counter = 1 to 10

Input(name)

WriteFile “Names.txt” , name

Next counter

CloseFile “Names.txt”

Note that the opening the file for write will completely clear the file and add the new data if we want
to add on to an existing file we open it in append mode

OpenFile <Name of file> For Append

WriteFile <Name of file> , <line>

CloseFile <Name of file>

Note, if we try to open a file for read but it does not exist, this will generate a run-time error but if
we try to open a file for write or append but it does not exist, the file gets created first