Lesson 4 Decisions, Looping, Arrays, and Searching

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 youve 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 ComboBoxes
• cboCapacity.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 EditCopy from the menu
  bar, or press CtrlC to copy the selected code.
  Move the cursor to the beginning of the next line
  and paste the code by selecting EditPaste or by
  pressing CtrlV. 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 lt 2 Then
• Person "Infant"
• Else
• If Age lt 5 Then
• Person "Toddler"
• Else
• Person "Older Child"
• End If
• End If

27
ElseIf

• If Age lt 2 Then
• Person "Infant"
• ElseIf Age lt 5 Then
• Person "Toddler"
• Else
• Person "Older Child"
• End If

28
Three Ifs

• If Age lt 2 Then Person "Infant"
• If 2 lt Age And Age lt 5 Then Person "Toddler"
• If Age gt 5 Then Person "Older Child"

29
Select Case Statement

• Select Case textexpression
• Case expressionlist
• Case expressionlist
• Statement(s)
• Statement(s)
• Case Else
• Statement(s)
• End Select

30
Simple Example

• Select Case Choice
• Case 1
• txtShowOne.Visible True
• Case 2
• MessageBox.Show "Show Two"
• Case Else
• MessageBox.Show "Not one or two."
• End Select

31
Ranges

• Select Case Age
• Case Is lt 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 gt 22
• Person "Older adult"
• End Select

32
Adding Items to the Items Collection
33

• Dim Index As Integer lstCardList.SelectedIndex
• Messagebox.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 lt
  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 1
• Do While x lt 100
• x 2 x 1
• Loop

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 gt 0

41
Do-Until

• Do Until condition
• Body
• Loop
• Example
• X 1
• Do Until x gt 100
• x 2 x 1
• Loop

42
Do-Until

• X 1
• Do
• Body
• Loop Until x gt 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 gt 0
• lstDisplay.Items.Add(x.ToString)
• Do While x ltgt 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 ltgt 1
• If y Mod 2 0 Then
• y y \ 2
• Else
• y 3 y 1
• End If
• lstDisplay.Items.Add(y)
• If y gt Largest Then
• Largest y
• End If
• Loop
• Loop Until Largest gt 1000

49
Programming Skills

• The section of the code shown below
• If y gt Largest Then
• Largest y
• End 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 String
• Dim 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 lt 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 ltgt ""
• 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 lt High
• Md (Low High) \ 2
• If Target lstDisplay.Items(Md) Then
• Position Md
• Exit Do
• ElseIf Target lt lstDisplay.Items(Md).ToStrin
  g Then
• High Md - 1
• Else
• Low Md 1
• End If
• Loop

67
Binary Search, Finish

• If Low lt 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.