1

Lesson 4 — Decisions, Looping, Arrays, and Searching

Microsoft Visual Basic .NET, Introduction to Programming

2

Objectives

Plan the solution to a programming problem. Understand and apply the rules of logic to complex

True/False expressions. Write advanced lf-Then-Else End If statements. Write Do-While and Do-Until statements. Create program loops that depend on logical

expressions. Declare and use arrays. Use built‑in functions for a variety of tasks.

3

Vocabulary

Algorithm Array Binary search Concatenation Counting statement Data structure Debugging line Declarations Element

Error trapping statements

Flag Index Items collection Lifetime Linear search Member Mod

4

Vocabulary

Private variable Running total Sentinel Stepwise refinement

Subroutine Subscript User interface Visibility

5

Approaching a Problem

Collect information. Create the user interface. Develop the algorithm. Subdivide the problem. Choose data structures. Write the code.

6

Collect Information

Start by getting all the information you can about the problem. Talk to the users who will run the program. Find out what they want. Do not assume that you know more about their problems than they do. Gather as much information as you can, but expect to revise your solution later to meet unexpected or newly discovered needs.

7

Create the User Interface

The user interface is how the user will interact with the program. It is what the user keys and clicks. It is what the user sees as output. You can create a Visual Basic program that is "all show." Design the forms used to enter data. Design the forms that display the information. Once these samples are created, return to the user. Find out if your mock solution is what the user expects.

8

Develop the Algorithm

Solve the problem completely on paper. If you cannot solve a problem with paper, a pencil, and a calculator, you probably will not be able to program the computer to solve the problem. The step-by‑step solution to a problem is called an algorithm. The word algebra comes from the same root.

9

Subdivide the Problem

Subdivide each section into smaller and smaller tasks. Once you’ve divided the problem, each part can be approached individually. Usually these smaller problems are easy to solve. Even if they are not, you have at least modularized the problem, and you can tackle the tough parts later in the process. This process is called stepwise refinement.

10

Event Procedure

An event procedure is a subroutine connected with an action performed on an object like the Click event of a text box or button. When a button or menu item is clicked, the code associated with that event is executed. The Click event is one of many events that an object may respond to.

11

Choose Data Structures

A data structure is a way to organize data. The simplest way to represent data is to use variables.

Another important data structure is the array. An array is a list of values referred to by a single variable name. Values in an array may be numbers or strings, or they may represent complex data types that include many pieces of information.

Other data structures organize data according to relationships between the individual data items.

12

Write the Code

Writing the code may be the very last thing you do. Or it may not be. Be flexible. It may be wise to develop an algorithm and write the code to solve a particular piece of the problem before the user interface is designed or before a data structure is chosen. You may need to experiment with different solutions or different data structures to find the one that fits best.

13

Important!!

Don't be afraid to start over. The things you learn in your first attempt will make your second attempt better.

14

ListBox and ComboBox

The ListBox control is a display tool that lets you display lists of values. It also allows the user to select items from the list for further processing.

The ComboBox control is closely related to the ListBox control. When you select an item from the Class Name box in the Code window, you are using a combo box. A combo box is like a text box, but it supplies the user with a list of suggested entries.

15

Items Collection

The entries displayed in a list box or combo box are called items. All the items together form the Items collection. A collection is itself an object that contains other related objects. In this case, the objects of the collections are the entries in the list box or combo box.

16

Note

In many fonts, a lowercase L is nearly indistinguishable from the numeral 1 or an uppercase I (eye). The context should tell you which to use. The three-letter prefix for the name of a list box is lst, except each character is lowercase.

17

‘ Initialize the ComboBoxescboCapacity.Items.Add("30 gallon")

cboCapacity.Items.Add("40 gallon") cboCapacity.Items.Add("50 gallon") cboPower.Items.Add("Natural Gas") cboPower.Items.Add("Electric") cboPower.Items.Add("LP Gas") cboWarranty.Items.Add("1 year") cboWarranty.Items.Add("5 years") cboWarranty.Items.Add("8 years") cboWarranty.Items.Add("10 years")

18

Note

The single quote ‘ character starts a comment. Comments are normally displayed in a green font.

19

Final Appearance of frmWaterHeater

20

Note

To enter repetitive code, select the part of the code that repeats. Select Edit|Copy from the menu bar, or press Ctrl+C to copy the selected code. Move the cursor to the beginning of the next line and paste the code by selecting Edit|Paste or by pressing Ctrl+V. Once the code is copied a sufficient number of times, go back and edit each line.

21

lstQualifying.Items.Clear()

lstQualifying.Items.Add(cboCapacity.Selecteditem)

lstQualifying.Items.Add(cboPower.SelectedItem)

lstQualifying.Items.Add(cboWarranty.Text)

22

Program Decisions

The simplest version of the If statement takes only a single line:

If condition Then statement

NOTE:

The one-line If statement is the original version. Many early versions of BASIC were limited to this kind of If.

23

Boolean or Logical Expression

An expression that, when evaluated, results in a True or False answer.

If the condition tested is True, the statement or statements following Then are executed. If the condition tested is False, the statement(s) after Then are skipped. In either case, the statements following the If statement are executed.

24

Other Versions of the If Statement

If condition Then

Statement (s)

End If

25

Other Versions of the If Statement

If condition Then

Statement(s) of the True branch

Else

Statement(s) of the False branch

End If

26

Nesting If Statements

If Age < 2 ThenPerson = "Infant"

ElseIf Age <= 5 Then

Person = "Toddler" Else

Person = "Older Child"End If

End If

27

ElseIf

If Age < 2 Then

Person = "Infant"

ElseIf Age <= 5 Then

Person = "Toddler"

Else

Person = "Older Child"

End If

28

Three Ifs

If Age < 2 Then Person = "Infant"

If 2 <= Age And Age <= 5 Then Person = "Toddler"

If Age > 5 Then Person = "Older Child"

29

Select Case Statement

Select Case textexpressionCase expressionlist

Case expressionlist

Statement(s)

Statement(s)

Case Else

Statement(s)

End Select

30

Simple Example

Select Case ChoiceCase 1

txtShowOne.Visible = True

Case 2

MessageBox.Show "Show Two"

Case Else

MessageBox.Show "Not one or two."

End Select

31

Ranges

Select Case AgeCase Is < 2

Person = "Infant"Case 2 To 5

Person = "Toddler"Case 6 To 12

Person = "Preteen"Case 13 To 19

Person = "Teenager"Case 20,21,22

Person = "Young adult"Case Is > 22

Person = "Older adult"End Select

32

Adding Items to the Items Collection

Dim Index As Integer = lstCardList.SelectedIndexMessagebox.Show("Selected index:" & Index.ToString, "Index")Select Case Index Case 0 'Discover card Messagebox.Show("$1500", "Credit Limit:") Case 1 'MasterCard Messagebox.show("$2000", "Credit Limit:") Case 2 'VISA Messagebox.Show("$3000", "Credit Limit:")

Case 3 'VISA Gold Messagebox.Show("$3500", "Credit Limit:") Case 4 'Platinum Messagebox.Show("$5000", "Credit Limit:") Case Else Messagebox.Show("Illegal Entry")End Select

34

Debugging Line

A debugging line is a line of code included in the program to let the user know what is going on as the code is executed. In the final version of the application, there is no need to display the value of Index. Open the Code window, locate the Messagebox.Show statement that displays the value of Index, and put a single quote at the beginning of the line. This is called commenting out a line of code because the single quote character turns the whole line into a comment. Commenting out a debugging line is better than deleting it because, when the program is modified, the line may once again be needed.

35

Programming Skills

Characters or strings can also be used to select different cases, as shown below:

Select Case FirstName Case "Groucho"

Statements(s) Case "Harpo"

Statements(s) Case "Chicko"

Statement(s) Case Else

Statements(s)End Select

36

A Lesson in Repetition

For loops are called definite loops because the starting point, the upper limit, and the increment are all known before the loop begins. But it is not always possible to know the number of repetitions necessary for a loop before the loop begins. You may need to process records from a database until you run out of data. Or you may need to process data from the keyboard until a special ending value, called a sentinel value, is entered. For these situations, use an indefinite loop.

37

Do While

Do While condition

Body

Loop

38

Do While Example

In the loop below, the value of x is initialized to 1 before the loop starts. The condition x < 100 is evaluated before the body of the loop is executed. Since the condition is True, the statement in the body of the loop is executed. The value of x is reassigned to 2 * 1 + 1, or 3. The Loop statement at the end sends the program flow back to the top of the loop. At the top of the loop, the condition is tested again to see if it is True. Since it is still True, the loop repeats.

x = 1Do While x < 100

x = 2 * x + 1Loop

39

Do-While Testing at the End

Do

Body

Loop While condition

40

An Example

Dim PopBottles As Integer

Do

PopBottles = CInt(InputBox("Enter the number of broken bottles:"))

Loop While PopBottles > 0

41

Do-Until

Do Until condition

Body

Loop

Example:

X = 1

Do Until x > 100

x = 2 * x + 1

Loop

42

Do-Until

X = 1

Do

Body

Loop Until x > 100

43

Divisibility

To test divisibility, you use the Mod operator. The Mod operator divides one whole number by another and returns the remainder of the division. Five mod three is two since three goes into five one time with a remainder of two. If two numbers are divided and the remainder is 0, the first number is divisible by the second. Fifteen Mod five is 0 because five goes into fifteen evenly, leaving a remainder of 0.

To test to see if a number is even, divide it by two. If the number is divisible by two, then number Mod two will equal 0. If the number is odd, the remainder is one.

44

The Goldbach Conjecture

Take any positive whole number. If the number is even, divide it by two. If the number is odd, multiply it by three and add one. Goldbach claimed that the series of numbers generated by applying these two rules always ends with a one.

For example, if you start with the number 7, since it is odd, multiply by 3 and add 1. The result is 22. Since 22 is even, divide by 2. The result is 11. The sequence generated is 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, and 1.

45

lstDisplay.Items.Clear()

46

Dim x As Integer Do x = CInt(InputBox("Enter a positive whole number:", "Goldbach", "7")) Loop Until x > 0 lstDisplay.Items.Add(x.ToString) Do While x <> 1

If x Mod 2 = 0 Then x = x / 2 Else x = 3 * x + 1 End If lstDisplay.Items.Add(x.ToString)

Loop

47

Dim x As Integer, y As Integer, Largest As Integer

x = 1

Do

x = x + 1

Largest = x

y = x

lstDisplay.Items.Clear()

lstDisplay.Items.Add(y)

48

Do While y <> 1 If y Mod 2 = 0 Then y = y \ 2 Else y = 3 * y + 1 End If lstDisplay.Items.Add(y) If y > Largest Then Largest = y End If

Loop

Loop Until Largest > 1000

49

Programming Skills

The section of the code shown below:If y > Largest Then

Largest = yEnd If

These lines compare the current value of y with a value stored in Largest. If the value of y exceeds the value of Largest, the value of y is saved in Largest. This allows the programmer to find the largest (or smallest) item in a list and save that value for later processing.

50

The Counting Statement, x = x + 1.

Algebraically, this is not a valid equation, but it works fine in a program. It is not an equation at all, but it is an assignment statement. Evaluation starts on the right side of the equal sign. The value of x is found, one is added, and the result is assigned back to the variable x. This is a common statement that may occur several times in the same program.

51

Running Total: Total = Total + x

Evaluation starts on the right side of the equal sign. The value of Total is fetched from memory. The value of x is added to the Total and the result is assigned back to the variable, Total. What normally happens in a checkbook is that a total is written at the top of the page, then check amounts are entered on each line and subtracted from the running total. Running totals are common in programs.

52

Arrays

An array is a list of values referred to by a single name. Arrays make it easy to access a list of related values. Arrays store lists of names, values, or objects. An array is an appropriate data structure anytime you want to hold a list of values in memory for further processing or display.

You declare an array in a Dim statement by following a variable name with a number enclosed in parentheses.Dim ClassList(45) As StringDim Scores(10) As Integer

53

Putting Values into an Array

Dim ClassList(10) As String

Dim Index As Integer

For Index = 0 To 9 'Valid indices from 0 to 9.

ClassList(Index) = InputBox("Enter name[" &

Index.toString & "]:")

Next

54

The Out-of-Range Error Message

55

Linear Search

Dim Target As String Target = InputBox("Enter the target:") For Index = 0 To 9

If Target = ClassList(Index) Then Exit For End If

Next MessageBox.Show(Index.ToString)

56

Scope of a Variable

The scope of a variable is its visibility and its lifetime. The lifetime of a variable is when it does and does not hold valid values. Most variables have a limited life. They come into existence at the beginning of an event procedure and disappear when the procedure ends. They reappear when the procedure is again executed.

The visibility of a variable is the point at which the value of the variable is available to use or change. A variable declared with a Dim statement in one event procedure is normally not available (visible) in another event procedure. Such a variable is a private variable.

57

Final Placement of Controls on the Form

58

Dim FirstName(5) As String Dim Current As Integer

Current is used to keep track of the next empty space in the array. Visual Basic automatically initializes its value to 0. It is also used when names are added to the array. When the value of Current exceeds the last valid array subscript, the program refuses to accept further input. Current is declared in Declarations along with the array because its lifetime must equal the lifetime of the form.

59

If Current < 5 Then FirstName(Current) = InputBox("Enter a first name:")

lstDisplay.Items.AddFirstName(Current)

Current = Current + 1

Else

MessageBox.Show("Array capacity exceeded!")

End If

60

lstDisplay.Items.Clear

Dim Index As Integer

For Index = 0 To 4

FirstName(Index) = " "

Next

Current = 0

btnEnter.Focus

61

Dim Target As String, Index As Integer Dim Found As Boolean Do Target = InputBox("Enter the name for which to search:") Loop Until Target <> "" Found = False 'Initialize the Boolean variable. For Index = 0 To Current - 1 If Target = FirstName(Index) Then Found = True Exit For End If Next

62

If Found Then

MessageBox.Show(Target.ToString & " found at " & Index.ToString)

Else

MessageBox.Show(Target.ToString & ": not in list.")

End If

63

Binary Search

The binary search is a powerful algorithm to find a target in an ordered list. If you use a linear search to find a target in an unordered list of 100, you will have, on average, 50 comparisons before you find the target. Each time the If statement compares the target to an item in the list, it is a comparison. The number of comparisons is proportional to the number of items in the list. If there are n items in the list, it takes an average of n/2 comparisons to find the target in an unordered list.

The binary search can find an item in an ordered list of 100 with no more than seven comparisons. It can search a list of 1000 items with no more than 10 comparisons. The linear search would average 500 comparisons with a list of 1000.

64

Binary Search

The reason the binary search is so efficient is that, with every comparison, the list is cut in half. The search starts by comparing the target with the middle of the list. If the target is equal to the item examined, the search is over. If the target is alphabetically less than the middle, the bottom half of the list is thrown out. The list is redefined to include just the items in the top half of the list and the process is repeated. With every comparison, the list of the remaining items is cut in half. Every time the size of the list doubles, only one additional comparison is needed to complete the search.

65

Binary Search, Setup

Dim Target As String

Dim High, Low, Md, Position As Integer

'Assume lstDisplay is filled with names and Sorted = True

Position = 0

Low = 0

High = lstDisplay.Items.Count - 1

66

Binary Search, Loop

Do While Low <= High Md = (Low + High) \ 2 If Target = lstDisplay.Items(Md) Then Position = Md Exit Do ElseIf Target < lstDisplay.Items(Md).ToString Then High = Md - 1 Else Low = Md + 1 End If Loop

67

Binary Search, Finish

If Low <= High Then

MessageBox.Show("Found " & Target & “

at position:" & Position)

else

MessageBox.Show("The Target has not

been found.")

End If

68

Festival of Strings

69

Summary

The planning and execution of a programming application can be broken down into the following steps:

Collect information from the user about the intended use of the application.

Create the user interface and show the result to the user. Alter the design in accordance with the user's needs.

Develop the algorithm used to solve the problem. Work the problem out with paper, pencil, and a calculator before trying to solve it on the computer.

Subdivide the problem by breaking it into smaller and smaller pieces. Plan the interaction of all pieces.

Choose data structures to represent the data processed in the program. This choice may be determined by the algorithm and must be carefully made to optimize both run time and storage space.

Write the code needed to solve each small problem. If the planning is careful and complete, the code will fit together like a puzzle.

70

Summary

A combo box lets the user choose an item from a list. It is most like the text box control.

There are several versions of the If statement. Logical expressions used to build the conditions

tested in If statements can be combined using And, Or, and Not.

The Select Case statement replaces a series of If- Then statements.

The Do-While and Do-Until statements build indefinite loops. These loops are controlled by conditions within the loop itself.

71

Summary

Arrays are lists of values referred to by the same name. The elements or members of the array are uniquely selected by specifying an index or subscript value.

A linear search is used to search for a target value in an array. It works by sequentially searching every item in the list. The average number of comparisons made by the linear search while searching for a target among n elements of the list is about n/2.

A binary search can search an ordered list with a handful of comparisons. The maximum number of comparisons is the value of x in the equation 2x = n, where n is the number of items in the list.

72

Summary

If the Sorted property of a list box is set to True, the elements of the list box are always displayed in alphabetical order.

Visual Basic uses a large number of functions to handle special jobs involving mathematics and string manipulation.