Algorithms and Data Types in C++

• (11)² + (11)² + (11)² = (1001)²
• Writing a program task in simple English is known as an algorithm.
• Pseudocode is midway between algorithm and program.
• C++ is an object-oriented language.

Algorithm

• An algorithm is a logical sequence of steps to solve a problem
• It is a tool written in simple natural language outlining job steps
• It isn't a programming language, but guides the programmer
• e.g., an Algorithm to exchange variable values:
  • Given variables A and B
  • Store A's value in X
  • Transfer B's value to A
  • Transfer X to B

Data Types in C++

• Variables use a data type during the declaration to restrict the type of data to be stored
• Data types tell variables what kind of data they can store
• In C++, when declaring a variable, the compiler allocates memory based on its data type
• Every data type requires a different amount of memory
• C++ supports a variety of data types, allowing programmers to choose types appropriate for the needs of their application
• Data types specify the size and type of values stored
• Storage representation and machine instructions vary but C++ instructions do not

Variable Declaration in C++

• Declaration involves the variable's name and data type
• Variables can be declared anywhere before they are used
• Syntax: data-type var1, var2,... (e.g., int varname;)
• Variables can be optionally initialized upon declaration (e.g., float varname = 0;)
• Multiple variables of the same type are declared in a comma-delimited list (e.g., char var1, var2;)
• Valid variable names consist of alphabet letters, digits, and underscores, but cannot start with a number
• C++ treats uppercase and lowercase variables as different

Radix

• Radix indicates the base of a number system
• Represents the total symbols and weight or power of each digit
• The radix for the decimal system is 10 (symbols 0-9 with each digit in power of 10)

BCD 8421 Code

• BCD codes represent decimal numbers to avoid long binary chains for larger numbers
• 8421 BCD is commonly used in computer arithmetic
• Each decimal number is represented by a 4-bit code
  • E.g.:
    • 3 = 0011
    • 5 = 0101
    • 9 = 1001

1's Complement

• Method can perform subtraction with addition and generate signed numbers.
• After subtraction, ones can easily verify the difference with the sign
• 1’s complement is obtained by replacing every 0 with 1, and every 1 with 0
• e.g., 1's complement of 101011 is 010100

Flowcharts

• After preparing an algorithm, for a given task it can be presented briefly as a pictorial form
• Flowcharts use standard symbols to represent an algorithm in pictorial form
• Flowcharts aid in formulating and understanding algorithms and illustrate different loops, logical decisions, along with input and output data
• Advantages:
  • Better programming steps
  • Systematic analysis resulting in effective testing, universal logical solutions of minimum length
  • Minimization of errors
  • Easy coding

Structure of a Simple C++ Program

• Include Header: #include <iostream.h> includes the iostream header file (Input Output stream) that is a preprocessor directive to support input/output functions

• Main function: void main(), is where programme starts writing

  • Every C++ program has one main function

• Program Body:

  {
    cout << "Hello and Welcome to world of C++\n";
  }
  

  contains the program's instructions

  • The cout statement displays the text on the screen

Constants in C++

• Constants are fixed-value variables that can't be changed during program execution
• Stored as read-only tokens in the code segment of memory
• Can be any available data type like int, char, string, etc.

Types of Constants

• Integer Constants : Integer with a fixed, non-fractional value (e.g., const signed int limit = 20;)
• Floating or Real Constants: Represents real numbers, including fractional values (e.g., const long float pi = 3.14159;)
• Character Constants: Characters, digits, or special symbols within single quotes. (e.g., '+', 'A', 'd'.)
  • Each has an associated ASCII value
• String Constants: Array of characters enclosed in double quotes (e.g., "DataFlair", "Hello world!")
• Enumeration Constants: User-defined data types with fixed value used to assign names to integral constants
  • e.g., enum rainbow = { Violet, Indigo, Blue, Green, Yellow, Orange, Red }

Algorithm to Determine if a Number is Prime

• Input number n
• If n < 1, number is not prime and stop
• If n = 2, it is prime and stop
• Let I = 2
• Repeat:
  • Divide n by I: if remainder is 0, then n isn't prime and stop
  • Increment I by 1 until I <= N - 1
• Stop

Compiler Tokens

• A program is broken into tokens
• A token is recognizable by the compiler
• Five categories:
  • Keywords
  • Literals
  • Identifiers
  • Operators
  • White space

Variables: Declaration vs. Initialization

• Declaration associates a name and data type with a variable.
• Initialization assigns it a value.

Structured Programming

• Developed in a hierarchy of modules
• Modules are subprograms in the main program
• A top-to-bottom approach:
  • A simple sequence
  • Selection by decision
  • A repetition

Modular Programming

• A main module is prepared by writing instructions of control
• Submodules are prepared by writing required programs in the main program
• Each subprogram may be called as "Functions" or "Procedurcs"
• Each function performs a routine, which may be required many times in the main program.

Comments in C++

• Used to make programs readable
• Compiler ignores comments, which don't impact file size or execution time
• Single line comment: */ comments here
• Multline comment. // multi line comment here

Sorting

• A process of arranging data items in ascending or descending order

Sorting Algorithms Overview

• Arrange elements in ascending or descending order in an array, a list, or any other data structure
• Different sorting algorithms include:
  • Sorting by selection
  • Bubble sorting
  • Shell sorting
  • Heap sorting

Bubble Sort

• Bubble sort involves the steps:
  1. compare A[1] and A[2] and arrange them in desired order so that A[I]<A[2]. Continue this comparison until A[N-1] with A[NI and arrange them so that A[N-1]<A[N].
  2. Repeat step 1 with one less comparison. Now we stop after we compare A[N-2] and A[N-1],
  3. Compare A[1] with A[2] so that, A[1]< A[2]. After N-1 steps the list will be sorted in increasing order.

Binary Search

• For searching in a sorted list
• Elements are asumed to be arranged in ascending order
• Procedure includes:
  • calculating the mid point element's position
  • comparing desired value with the mid point element:
    • If it's less, reduce the search in the second half of the interval, centered on mid point
    • Repeat if the interval isn't empty
  • On successful search, output the position

Explore algorithms as step-by-step problem-solving tools and learn about data types in C++. Understand how data types define variable storage and memory allocation in programming. See how C++ supports diverse data types.