Module 2 computer language

Programming and Data Structures

Module Overview

Focus on programming languages and data structures, exploring their usage, importance, and evolution in the field of computer science.

Content Outline

Computer Programming Languages:

  • Types of programming languages: Machine, Assembly, High-level.

Data Structures:

  • Introduction to data structures: Fundamental concept in computer science that defines how data is organized, accessed, and manipulated—key to optimizing performance in programming.

  • Basic structures: Arrays, Stacks, Queues—each with unique characteristics and operations that are utilized across various applications.

Computer Programming Languages & Types

Programming Languages:

  • Used to write programs that control the behavior of a computer. They are essential for implementing algorithms and managing data.

  • Categorized into three types:

    1. Low-level: (Machine, Assembly)

    2. Middle-level: (Assembly language)

    3. High-level: (C, Java, Python, etc.)

Machine Language:

  • Numerical form specific to computer hardware, composed of binary code that the computer's processor can directly execute. Each instruction corresponds directly to a basic operation.

Assembly Language:

  • Utilizes mnemonic codes instead of binary, making it slightly more understandable. Requires translation into machine language through an assembler.

  • Closely tied to a specific computer architecture, making it less portable.

High-level Languages:

  • Designed to abstract complexities away from the programmer, facilitating easier writing and understanding of code. They resemble human languages, enabling quicker development.

  • Examples include C, Java, Python, which require compilation or interpretation to translate into machine code for execution.

Types of Computer Programming Languages

Low-level Programming Languages:

  • Includes Binary and Assembly languages.

  • Offer minimal abstraction from the hardware, directly manipulating memory; thus, they are difficult to read or edit and are typically non-portable across different types of systems.

Middle-level Programming Languages:

  • Assembly is one level above machine language, allowing for more readable code with mnemonics for instructions.

  • C is a notable example, combining low and high-level features which allow for both control and ease of use, making it fundamental in system programming.

High-level Programming Languages:

  • Include languages like Java, .Net, Pascal, COBOL, C++, known for their strong abstraction capabilities.

  • They are more accessible for developers but require compilers or interpreters to convert code into machine language for execution.

Features of High-level Programming Languages

  • Generally machine-independent, facilitating cross-system usage.

  • Have easier syntax that enhances comprehension and maintainability.

  • Although they may operate slower than low-level languages, their extensive use in application development is due to their productivity benefits.

Algorithmic Languages

  • Specifically designed for performing mathematical and symbolic computations.

  • First high-level language representatives, they enable structured programming and algorithmic notation.

Key Algorithmic Languages

  • FORTRAN (1957): Tailored for scientific computations, it introduced features like support for arrays and control structures such as IF statements and loops.

  • ALGOL (1958-60): Emphasized the publication of algorithms and supported recursive subprogram structures, pioneering block structures for program organization.

  • C (1972): Developed primarily for operating systems and has influenced many other languages, combining high and low-level linguistic features.

Business-oriented Languages

  • COBOL: Known for its English-like syntax, ideal for business tasks involving vast data management and process automation. Introduced structured record data for efficient manipulation.

  • SQL (Structured Query Language): A critical database language, widely used for querying and managing relational databases.

Java Programming Language

  • Designed for versatile internet applications; it is an object-oriented language that emphasizes plan portability across different computing environments, bolstered by its write-once, run-anywhere philosophy.

Python

  • An open-source language introduced in 1991, celebrated for its simplicity and power. It has become a favored choice in various sectors including data science, web development, and automation due to its readability and vast libraries.

Introduction to Data Structures

  • Data structures define how data is systematically organized to allow for efficient operations, essential for data handling and storage within programs.

  • Can encompass various data types and their representations, leveraging both memory efficiency and speed.

Basic Types of Data Structures

  • Primitive Data Structures: Include Integer, Float, Boolean, Char—building blocks for data manipulation.

  • Complex Data Structures: Such as Linked Lists, Trees, Graphs, Stacks, and Queues—allow for sophisticated data management depending on the needs of the application.

Classifications of Data Structures

  • Linear: Organizes data items sequentially; example: Array.

  • Non-Linear: Data items are arranged hierarchically or in a graph; example: Tree, Graph.

  • Homogeneous: All elements are of the same data type; example: Array.

  • Non-Homogeneous: Elements may vary in type; example: Structures.

  • Static: Fixed size determined at compile time; example: Array.

  • Dynamic: Size can change during program execution; example: Linked List.

Systems of Classification for Data Structures

  • Primitive: Basic types like integers and characters.

  • Non-Primitive: User-defined structures, like Linked Lists and Trees, providing advanced data handling.

Representation in Memory

  • Data structures can be represented in two formats:

    1. Sequential: Such as arrays, allocates a continuous block of memory.

    2. Pointer-based: Such as linked lists, where each element points to the next, allowing for non-contiguous memory allocation.

Operations on Linear Structures

  • Traversal: Visiting each element in the data structure.

  • Search: Locating an element or record within the structure.

  • Insertion: Adding a new element at a specified point.

  • Deletion: Removing an element from a specified point.

  • Sorting: Arranging elements in a specified order.

  • Merging: Combining two data lists into a single structure.

Linear Arrays

  • Defined as a finite list of homogeneous data elements, allowing for quick access via their index: A[i] signifies the ith element.

  • The length of the array is determined by the formula: Length = Upper Bound (UB) - Lower Bound (LB) + 1, facilitating dynamic adjustments in usage.

Memory Representation of Linear Arrays

  • Elements are stored in successive memory locations, enabling efficient access.

  • Access can be computed using the formula: LOC(A[K]) = Base(A) + size_of_element * (K - LB).

Traversing Linear Arrays

  • Involves accessing and processing each element systematically, crucial for various operations such as searching or deletion.

Insertion and Deletion

  • Insertion: New elements can be added at the beginning, middle, or end of an array, depending on requirements.

  • Deletion: Occurs similarly at designated points, requiring careful relocation of subsequent elements to maintain order.

  • Algorithms for Insertion and Deletion: Structured methods designed to efficiently handle the complexities of adding or removing elements while managing pointers effectively.

Multidimensional Arrays

  • Structured as arrays of arrays, allowing for complex data representation:

    • One-Dimensional Array: A linear structure of elements.

    • Two-Dimensional Array: Arranged in a matrix format (rows and columns), allowing for a grid representation.

    • Three-Dimensional Array: Extends into a grid format, facilitating even more complex data modeling.

Linked Lists

  • Singly Linked List: A series of nodes, where each points to the next, allowing for sequential access but limited in backward traversal.

  • Doubly Linked List: Nodes point both to the next and previous elements, facilitating bi-directional traversal and easier deletion.

Stack Concepts

  • Defined as an Abstract Data Type (ADT) characterized by Last-In-First-Out (LIFO) behavior. Access to elements only occurs from one end (top of the stack).

  • Implements basic operations including:

    • Push: Adding an element to the top.

    • Pop: Removing the top element.

    • Check Status: Determining if the stack is empty or full.

Queue Concepts

  • Defined as an Abstract Data Type (ADT) characterized by First-In-First-Out (FIFO) behavior, allowing for orderly processing of items.

  • Implements operations including:

    • Enqueue: Adding an element to the back.

    • Dequeue: Removing the front element.

    • Status Checks: Determining if the queue is empty or obtaining the current size.