Understanding Data Structures

• Data structures are formats for managing, assessing, retrieving, and storing data
• Appropriate data structure selection helps users work with data in required ways
• Data structures are designed for storing data for algorithms and are integrated with basic algorithm operations
• Data structures contain info related to data values and associations between data and functions applied to them

Data Structures

• Data structures organize data in computer memory for effective later use
• They can be arranged using mathematical or logical models
• The choice of data model depends on exhibiting real-world data relationships and simplicity for processing
• Data structure involves arranging data and its functions

Need for Data Structures

• Data structures should be efficient, reusable, and invisible
• Data structures efficiently establish, handle, and store data
• They comprise data collections and actions applicable to that data

Significance of Data Structures

• Programmers can effectively manage data
• Improves software or program performance
• Facilitates efficient data arrangement in every program or software system
• Enables specific data storage methods in memory
• A significant factor for efficient algorithms, managing large data amounts like databases and indexing services (hash tables)
• Helps in effective data retrieval and search
• Manages data retrieval and storage, which can be stored in secondary and main memory

Classifications

• Trees originate in the non-primitive and non-linear group, signifying hierarchical relationships
• The CREATE operation stores memory for program components
• Data structures are classified into primitive and non-primitive types

Primitive Data Structures

• Basic data structures operate directly on machine instructions
• Defined by programming languages
• Examples: integer, floating point number, real, and pointer

Non-Primitive Data Structures

• Derived from primitive data structures
• Examples: stacks, graphs, trees, and linked lists

Data Structure Operations

• Data Structure is a mathematical or logical model to store data and perform operation
• Operations are the purposes for managing the data
• Data structures share common operations for user manipulation and processing

Traversing

• Visiting each element to manage operations like searching or sorting
• Compute the average, traverse an array, compute the total sum and divide that sum to compute the average

Insertion

• Adding elements to data structures at any location
• With n as the data structure size, you can insert n-1 data elements

Deletion

• Removing an element from the data structure
• Underflow occurs when deleting from an empty data structure

Searching

• Detecting the location of an element within the data structure
• Algorithms such as linear and binary search are available

Sorting

• Organizing the data structure in a particular order
• Algorithms include selection, insertion, and bubble sort

Merging

• Combining two lists (List X of size K and List Y of size L) with identical element types to generate a third list, List Z of size (K+L)

Pointers

• Derived data types store the address of another variable
• Contain memory addresses as their values
• Used to assign, access, and manipulate data values stored in memory by accessing the memory address

Pointer Basics

• Variables store value locations in memory.
• Dereferencing occurs when acquiring a stored value by reference.
• Analogous to textbook indexes where pages are located usning the page number's index.
• Employed in dynamic data structure implementations like lists or stacks.
• Declarations: pointer declarations use the * operator.
  • Example:

    int a=12;
    int *ptr;  //pointer declaration
    pte =&a; // pointer initialization
    

  • p is a pointer storing the integer variable's address.

Pointer with Functions

• Function pointers eliminate code redundancy, qsort() sorts arrays of structures and void pointers and function pointers are used to use qsort for any data type
• Function pointers refer to function addresses and called at run time. Functions are late binding.
• Syntax: Returntype (*function pointer) (parameter1, parameter2);
• Function pointers point to functions with a sign with parameters/return type, function pointer signs should match the address.
• Example:

int (*pfunc) (int l, int M);
 // pfunc generally takes integers as return values and parameters.
 int plus (int l, int K)
 //in this function, the address is valued by the function pointer.

Pass By Reference

• C, C++, and Java use pass by value which can be simulated with dereferenced pointers in fn definition and passing the address.
• Pointers serve as a copy but point to the same memory address to allow changes outside fn.
• Outside values are the same in swap functions with pointers.

Array of Pointers

• Indexed set of variables using pointers.
• Arrays develop, utilise and eliminate all forms of data structures
• arrays help in indexing large sets of variables numerically
• Pointers point to the integers in another array
• Code displays value in memory where pointers refer.