What are the different Characteristics of data structures?

Data structures are frequently categorized according to their properties. The following three characteristics are examples:

a) Linear or non-linear:

• Linear data structures store data elements in a sequential manner, where each element has a unique predecessor and successor (except for the first and last elements).

Examples of linear data structures include arrays, linked lists, stacks, and queues.

• Non-linear data structures do not follow a sequential arrangement of elements. They allow for more complex relationships among the data elements.

Examples of non-linear data structures include trees and graphs.

b) Homogeneous or heterogeneous:

• Homogeneous data structures store elements of the same data type. All the elements in the structure have the same kind of data.

Examples of homogeneous data structures include arrays.

• Heterogeneous data structures store elements of different data types. The elements in the structure can vary in size and data type.

Examples of heterogeneous data structures include structures and classes.

c) Static or dynamic:

• Static data structures have a fixed size and memory allocation at compile-time. Once the size of the data structure is determined, it remains constant throughout the program execution.

Examples of static data structures include arrays and static arrays.

• Dynamic data structures have a flexible size and memory allocation that can be adjusted at runtime. They can grow or shrink as needed to accommodate the data elements.

Examples of dynamic data structures include linked lists, dynamic arrays, stacks, queues, trees, and graphs.

Classification of Data Structure:

Data structures can be classified into various categories based on their characteristics and the way they organize and store data. Initially, Data Structures is classified into two categories:

1. Primitive Data Structure
2. Non-Primitive Data Structure

Figure below shows the classification hierarchy of data structure. Let us discuss each classification elaborately.

1) Primitive Data Structures:

Primitive data structures refer to the basic or fundamental data types provided by a programming language. These data structures are typically built-in and directly supported by the language.

a) Integer: Represents whole numbers without decimal places.

• Examples: int, long, short, byte

b) Floating-point Number: Represents real numbers with decimal places.

• Examples: float, double

c) Character: Represents a single character or symbol.

• Example: char

d) Boolean: Represents logical values of true or false.

• Example: bool

Important details of primitive data structures:

• They are the most fundamental and basic data types that a computer language offers.
• They have a fixed size and memory representation determined by the language.
• They are typically represented directly in binary form.
• They have specific operations and behaviors defined by the language.
• They are used for storing and manipulating individual values rather than complex data structures.
• For more advanced data structures and algorithms, they are frequently employed as building blocks.
• They are usually stored in stack memory rather than heap memory.
• In comparison to more complicated data structures, they are typically more memory and performance efficient.

It’s important to Note that depending on the programming language being used, the precise primitive data structures that are available may change. C, C++, Java, and Python frequently use primitive data types like those shown in the examples above, although other languages might offer additional or slightly different primitive data types.

2) Non-Primitive Data Structures:

Non-primitive data structures, also known as composite or user-defined data structures, are data structures that are created by combining one or more primitive data types and organizing them in a way that suits a specific purpose or problem. These data structures can be more complex and versatile compared to primitive data structures. Different types of non-primitive data structures are explained below

a) Array:

• • An ordered collection of elements, each identified by an index.
  • Elements can be of the same or different data types.
  • Arrays can be one-dimensional (lists), multi-dimensional (matrices), or jagged (arrays of arrays).

b) Structures (or Structs):

• • Allows grouping different data types into a single entity under one name.
  • Each element, or field, within a structure can have its own data type.
  • Commonly used in languages like C and C++.

c) Classes (or Objects):

• • A blueprint for creating objects, combining both data (attributes) and methods (functions).
  • Encapsulation allows data hiding and abstracting the implementation details.
  • Commonly used in object-oriented programming languages like Java, Python, and C++.

d) Linked Lists:

• • A collection of nodes, where each node contains data and a reference to the next node.
  • Allows dynamic memory allocation and flexible size.
  • Types include singly linked lists, doubly linked lists, and circular linked lists.

e) Stacks:

• • Follows the Last-In-First-Out (LIFO) principle.
  • Supports two primary operations: push (to add an element) and pop (to remove the top element).
  • Often used for managing function calls and undo functionality.

f) Queues:

• • Follows the First-In-First-Out (FIFO) principle.
  • Supports two primary operations: enqueue (to add an element) and dequeue (to remove the front element).
  • Commonly used in scenarios like task scheduling and print spooling.

g) Trees:

• • Hierarchical data structures with a root node and child nodes.
  • Common types include binary trees, binary search trees, AVL trees, and red-black trees.
  • Used for tasks like searching, sorting, and hierarchical data representation.

h) Graphs:

• • A collection of nodes (vertices) connected by edges.
  • Used to represent complex relationships, networks, and data dependencies.
  • Types include directed graphs, undirected graphs, weighted graphs, and more.

i) Hash Tables (or Dictionaries):

• • Uses a hash function to map keys to values, enabling efficient key-value pair lookups.
  • Provides fast access times for retrieval and insertion operations.
  • Commonly used for implementing data structures like sets, maps, and caches.

Non-primitive data structures are essential in solving complex problems and are a fundamental part of computer science and software development. They provide the means to store, organize, and manipulate data efficiently for various applications.