{"id":9576,"date":"2025-06-16T09:04:43","date_gmt":"2025-06-16T09:04:43","guid":{"rendered":"https:\/\/www.examsnap.com\/certification\/?p=9576"},"modified":"2026-09-29T19:16:12","modified_gmt":"2026-09-29T19:16:12","slug":"understanding-data-structures-in-c-and-their-applications","status":"publish","type":"post","link":"https:\/\/www.examsnap.com\/certification\/understanding-data-structures-in-c-and-their-applications\/","title":{"rendered":"Understanding Data Structures in C and Their Applications"},"content":{"rendered":"

In the programming world, data needs to be stored, organized, and manipulated efficiently. To achieve this, various types of containers called data structures are used. These data structures serve as specialized formats to arrange and manage data, enabling operations like insertion, deletion, searching, and sorting. Understanding data structures is fundamental for writing efficient code, optimizing memory use, and solving complex problems.<\/span><\/p>\n

The C programming language offers several built-in and derived data structures. These allow programmers to manage data effectively based on the requirements of their applications.<\/span><\/p>\n

This article introduces different data structures available in C, categorizes them, and provides examples and explanations of their implementation.<\/span><\/p>\n

What Are Data Structures?<\/b><\/h2>\n

Data structures are containers that hold collections of data values. They define how data is stored and accessed. Each data structure has its unique properties that make it suitable for particular use cases.<\/span><\/p>\n

The choice of data structure directly impacts the efficiency of an algorithm. For instance, choosing an appropriate data structure can optimize search times or simplify the code.<\/span><\/p>\n

Classification of Data Structures in C<\/b><\/h2>\n

Data structures in C can be broadly classified into two categories: primitive and non-primitive. Each category has its subtypes and characteristics.<\/span><\/p>\n

Primitive Data Structures<\/b><\/h3>\n

Primitive data structures, also known as primitive data types, are the basic types defined directly by the C language. These are the simplest forms of data storage and manipulation. Primitive data types store only a single value at a time.<\/span><\/p>\n

The common primitive data types in C include:<\/span><\/p>\n

    \n
  • Int<\/b>: Stores integer values (whole numbers).<\/span><\/li>\n
  • Char<\/b>: Stores single characters.<\/span><\/li>\n
  • Float<\/b>: Stores single-precision floating-point numbers.<\/span><\/li>\n
  • Double<\/b>: Stores double-precision floating-point numbers.<\/span><\/li>\n
  • Pointers<\/b>: Store memory addresses pointing to other variables or data.<\/span><\/li>\n<\/ul>\n

    Primitive data structures form the foundation for building more complex data structures. They are efficient and straightforward, but limited in storing just one value per variable.<\/span><\/p>\n

    Non-Primitive Data Structures<\/b><\/h3>\n

    Non-primitive data structures, also called derived data structures, are constructed from primitive data types. These structures allow the storage of multiple values or complex data sets.<\/span><\/p>\n

    Non-primitive data structures support operations such as insertion, deletion, searching, and sorting. This makes them essential for implementing algorithms and handling larger data collections.<\/span><\/p>\n

    Examples of non-primitive data structures include arrays, linked lists, stacks, queues, trees, and graphs.<\/span><\/p>\n

    Non-primitive data structures can be further divided into two categories:<\/span><\/p>\n

    Linear Data Structures<\/b><\/h4>\n

    Linear data structures store data elements sequentially. Each element is connected in a linear order, meaning the data can be traversed in a single run from beginning to end.<\/span><\/p>\n

    Although elements might not be stored in contiguous memory locations, each element links logically to the next, making sequential access possible.<\/span><\/p>\n

    Common linear data structures include:<\/span><\/p>\n

      \n
    • Arrays<\/span><\/li>\n
    • Linked lists<\/span><\/li>\n
    • Stacks<\/span><\/li>\n
    • Queues<\/span><\/li>\n<\/ul>\n

      These structures are easier to implement and manage due to their simple, ordered nature.<\/span><\/p>\n

      Non-Linear Data Structures<\/b><\/h4>\n

      Non-linear data structures organize data in a hierarchical or interconnected manner. Data is stored at multiple levels, which makes traversal more complex than linear structures.<\/span><\/p>\n

      Examples of non-linear data structures are:<\/span><\/p>\n

        \n
      • Trees<\/span><\/li>\n
      • Graphs<\/span><\/li>\n<\/ul>\n

        These are used to represent more complicated relationships, such as hierarchical data or networks.<\/span><\/p>\n

        Non-linear structures require more sophisticated algorithms for operations like traversal and searching, but they provide powerful ways to model real-world problems.<\/span><\/p>\n

        Classification Based on Memory Allocation<\/b><\/h2>\n

        Data structures can also be classified based on how they allocate memory during program execution.<\/span><\/p>\n

        Static Data Structures<\/b><\/h3>\n

        Static data structures have a fixed size. Their memory is allocated at compile time, meaning the size is predetermined and cannot change during runtime.<\/span><\/p>\n

        While the values stored in static data structures can be modified, the number of elements remains constant throughout the program’s execution.<\/span><\/p>\n

        An example of a static data structure is an array with a fixed size.<\/span><\/p>\n

        Dynamic Data Structures<\/b><\/h3>\n

        Dynamic data structures allocate memory during runtime. Their size can grow or shrink as needed, providing flexibility in data management.<\/span><\/p>\n

        This dynamic allocation is useful for programs where the amount of data is unknown or varies.<\/span><\/p>\n

        Linked lists are a classic example of dynamic data structures. They can expand or contract by adding or removing nodes.<\/span><\/p>\n

        Dynamic data structures typically require careful memory management to avoid leaks or corruption, but offer greater adaptability.<\/span><\/p>\n

        Summary of Data Structure Classifications<\/b><\/h2>\n\n\n\n\n\n\n\n\n\n
        Classification<\/b><\/span><\/td>\nDescription<\/b><\/span><\/td>\nExamples<\/b><\/span><\/td>\n<\/tr>\n
        Primitive<\/span><\/td>\nBasic data types hold a single value<\/span><\/td>\nint, char, float, double, pointers<\/span><\/td>\n<\/tr>\n
        Non-Primitive<\/span><\/td>\nDerived structures storing multiple values<\/span><\/td>\nArrays, linked lists, stacks, queues, trees, graphs<\/span><\/td>\n<\/tr>\n
        Linear<\/span><\/td>\nElements stored sequentially<\/span><\/td>\nArrays, linked lists, stacks, queues<\/span><\/td>\n<\/tr>\n
        Non-Linear<\/span><\/td>\nData is organized hierarchically or as a network<\/span><\/td>\nTrees, graphs<\/span><\/td>\n<\/tr>\n
        Static<\/span><\/td>\nFixed size, allocated at compile time<\/span><\/td>\nArrays<\/span><\/td>\n<\/tr>\n
        Dynamic<\/span><\/td>\nVariable size, allocated at runtime<\/span><\/td>\nLinked lists, stacks, queues<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

        Importance of Data Structures<\/b><\/h2>\n

        Data structures are crucial for efficient algorithm design. Proper use of data structures enables:<\/span><\/p>\n

          \n
        • Efficient data storage and retrieval<\/span><\/li>\n
        • Improved program performance<\/span><\/li>\n
        • Easier data manipulation<\/span><\/li>\n
        • Better resource management<\/span><\/li>\n<\/ul>\n

          Choosing the right data structure depends on factors such as:<\/span><\/p>\n

            \n
          • The type and amount of data<\/span><\/li>\n
          • Operations to be performed<\/span><\/li>\n
          • Memory constraints<\/span><\/li>\n
          • Execution speed requirements<\/span><\/li>\n<\/ul>\n

            Understanding the characteristics and use cases of each data structure is fundamental for any programmer.<\/span><\/p>\n

            Primitive Data Structures in Detail<\/b><\/h2>\n

            Integer (int)<\/b><\/h3>\n

            The integer data type stores whole numbers without fractional parts. It is one of the most commonly used data types for arithmetic operations, indexing, and counters.<\/span><\/p>\n

            Typically size of an int is 4 bytes (32 bits), but it can vary depending on the system architecture.<\/span><\/p>\n

            Example:<\/span><\/p>\n

            c<\/span><\/p>\n

            CopyEdit<\/span><\/p>\n

            int age = 25;<\/span><\/p>\n

             <\/p>\n

            Character (char)<\/b><\/h3>\n

            The char type stores a single character and usually takes 1 byte of memory. Characters are enclosed in single quotes.<\/span><\/p>\n

            Example:<\/span><\/p>\n

            c<\/span><\/p>\n

            CopyEdit<\/span><\/p>\n

            char letter = ‘A’;<\/span><\/p>\n

             <\/p>\n

            Characters can also represent small integers because they store ASCII values internally.<\/span><\/p>\n

            Floating Point (float)<\/b><\/h3>\n

            The float type stores single-precision decimal numbers. It is used when fractional numbers with less precision are sufficient.<\/span><\/p>\n

            Example:<\/span><\/p>\n

            c<\/span><\/p>\n

            CopyEdit<\/span><\/p>\n

            float temperature = 36.5;<\/span><\/p>\n

             <\/p>\n

            Double<\/b><\/h3>\n

            The double type stores double-precision decimal numbers with higher accuracy and range than float.<\/span><\/p>\n

            Example:<\/span><\/p>\n

            c<\/span><\/p>\n

            CopyEdit<\/span><\/p>\n

            double pi = 3.1415926535;<\/span><\/p>\n

             <\/p>\n

            Pointers<\/b><\/h3>\n

            Pointers store memory addresses of variables. They are essential for dynamic memory allocation, referencing variables, and implementing complex data structures.<\/span><\/p>\n

            Example:<\/span><\/p>\n

            c<\/span><\/p>\n

            CopyEdit<\/span><\/p>\n

            int x = 10;<\/span><\/p>\n

            int *p = &x; \/\/ p holds address of x<\/span><\/p>\n

             <\/p>\n

            Pointers require careful use because incorrect handling can lead to undefined behavior or program crashes.<\/span><\/p>\n

            Non-Primitive Data Structures in C<\/b><\/h2>\n

            Non-primitive data structures are derived from primitive data types and are designed to store collections of values. They allow more complex data management and are crucial for implementing many algorithms and systems.<\/span><\/p>\n

            Common non-primitive data structures include arrays, linked lists, stacks, queues, trees, and graphs. In this section, we will focus primarily on arrays, one of the fundamental data structures used widely in programming.<\/span><\/p>\n

            Arrays in C<\/b><\/h2>\n

            An array is a collection of elements of the same data type stored in contiguous memory locations. Arrays are the simplest form of data structures that store multiple values under a single name.<\/span><\/p>\n

            Characteristics of Arrays<\/b><\/h3>\n
              \n
            • Arrays store elements of the same data type.<\/span><\/li>\n
            • Elements are stored sequentially in memory.<\/span><\/li>\n
            • Each element can be accessed directly via its index.<\/span><\/li>\n
            • The size of an array is fixed at the time of declaration (static arrays).<\/span><\/li>\n
            • Indexing in arrays starts from zero.<\/span><\/li>\n
            • Arrays support efficient random access, but insertion and deletion can be costly.<\/span><\/li>\n<\/ul>\n

              Why Use Arrays?<\/b><\/h3>\n

              Arrays are used to store multiple data elements of the same type when the number of elements is known or can be predetermined. They provide:<\/span><\/p>\n

                \n
              • Easy access to elements using indices.<\/span><\/li>\n
              • Efficient memory usage as elements are stored contiguously.<\/span><\/li>\n
              • Speed in retrieving data due to direct addressing.<\/span><\/li>\n<\/ul>\n

                Declaring Arrays in C<\/b><\/h3>\n

                To declare an array in C, you specify the data type, the array name, and the number of elements (size):<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                dataType arrayName[size];<\/span><\/p>\n

                 <\/p>\n

                For example:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                int numbers[5];<\/span><\/p>\n

                 <\/p>\n

                This declares an integer array named <\/span>numbers<\/span> that can store five integer elements.<\/span><\/p>\n

                Initializing Arrays<\/b><\/h3>\n

                Arrays can be initialized at the time of declaration by specifying values within curly braces:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                int numbers[5] = {1, 2, 3, 4, 5};<\/span><\/p>\n

                 <\/p>\n

                If fewer elements are provided than the size, the remaining elements are automatically initialized to zero.<\/span><\/p>\n

                Example:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                int numbers[5] = {1, 2};<\/span><\/p>\n

                 <\/p>\n

                Here, <\/span>numbers[0] = 1<\/span>, <\/span>numbers[1] = 2<\/span>, and <\/span>numbers[2]<\/span>, <\/span>numbers[3]<\/span>, <\/span>numbers[4]<\/span> are initialized to 0.<\/span><\/p>\n

                Accessing Array Elements<\/b><\/h3>\n

                Each element in the array can be accessed using the array name and the index in square brackets:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                int firstNumber = numbers[0]; \/\/ Access first element<\/span><\/p>\n

                numbers[2] = 10;\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \/\/ Modify third element<\/span><\/p>\n

                 <\/p>\n

                Since array indices start at zero, <\/span>numbers[0]<\/span> is the first element, <\/span>numbers[1]<\/span> is the second, and so on.<\/span><\/p>\n

                Example Program: Basic Array Operations<\/b><\/h3>\n

                The following example demonstrates declaration, initialization, accessing, and printing elements of an array:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                #include <stdio.h><\/span><\/p>\n

                 <\/p>\n

                int main() {<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0int numbers[5] = {10, 20, 30, 40, 50};<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0int i;<\/span><\/p>\n

                 <\/p>\n

                \u00a0\u00a0\u00a0\u00a0printf(“Array elements are:\\n”);<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0for (i = 0; i < 5; i++) {<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“%d “, numbers[i]);<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                 <\/p>\n

                \u00a0\u00a0\u00a0\u00a0numbers[2] = 100; \/\/ Modify third element<\/span><\/p>\n

                 <\/p>\n

                \u00a0\u00a0\u00a0\u00a0printf(“\\nAfter modification:\\n”);<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0for (i = 0; i < 5; i++) {<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“%d “, numbers[i]);<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                 <\/p>\n

                \u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

                }<\/span><\/p>\n

                 <\/p>\n

                Multidimensional Arrays<\/b><\/h3>\n

                C supports arrays with more than one dimension. These are useful for representing tables, matrices, or grids.<\/span><\/p>\n

                Example of a two-dimensional (2D) array:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                int matrix[3][4]; \/\/ 3 rows, 4 columns<\/span><\/p>\n

                 <\/p>\n

                Elements are accessed using two indices:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                matrix[1][2] = 5; \/\/ Set value at second row, third column<\/span><\/p>\n

                 <\/p>\n

                Initializing Multidimensional Arrays<\/b><\/h3>\n

                A 2D array can be initialized as follows:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                int matrix[2][3] = {<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0{1, 2, 3},<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0{4, 5, 6}<\/span><\/p>\n

                };<\/span><\/p>\n

                 <\/p>\n

                Traversing Multidimensional Arrays<\/b><\/h3>\n

                You can traverse a 2D array using nested loops:<\/span><\/p>\n

                c<\/span><\/p>\n

                CopyEdit<\/span><\/p>\n

                for (int i = 0; i < 2; i++) {<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0for (int j = 0; j < 3; j++) {<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“%d “, matrix[i][j]);<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                \u00a0\u00a0\u00a0\u00a0printf(“\\n”);<\/span><\/p>\n

                }<\/span><\/p>\n

                 <\/p>\n

                Array Limitations<\/b><\/h3>\n
                  \n
                • The size of a static array must be known at compile time and cannot be changed during execution.<\/span><\/li>\n
                • Arrays can waste memory if the size is overestimated.<\/span><\/li>\n
                • Inserting or deleting elements requires shifting other elements, which can be inefficient.<\/span><\/li>\n
                • Arrays do not provide built-in methods for resizing or dynamic allocation.<\/span><\/li>\n<\/ul>\n

                  To overcome these limitations, programmers use dynamic data structures like linked lists, which allow flexible sizes and easier insertion and deletion.<\/span><\/p>\n

                  Dynamic Arrays in C<\/b><\/h2>\n

                  C does not have built-in dynamic arrays like some higher-level languages. However, you can create dynamic arrays using pointers and dynamic memory allocation functions such as <\/span>malloc()<\/span>, <\/span>calloc()<\/span>, and <\/span>realloc()<\/span> from the <\/span>stdlib.h<\/span> library.<\/span><\/p>\n

                  Creating Dynamic Arrays<\/b><\/h3>\n

                  To create a dynamic array, first allocate memory on the heap:<\/span><\/p>\n

                  c<\/span><\/p>\n

                  CopyEdit<\/span><\/p>\n

                  int *dynamicArray;<\/span><\/p>\n

                  dynamicArray = (int *)malloc(n * sizeof(int));<\/span><\/p>\n

                   <\/p>\n

                  Here, <\/span>n<\/span> is the number of elements you want to store. <\/span>Malloc<\/span> returns a pointer to the allocated memory.<\/span><\/p>\n

                  Example: Dynamic Array Allocation and Initialization<\/b><\/h3>\n

                  C<\/span><\/p>\n

                  CopyEdit<\/span><\/p>\n

                  #include <stdio.h><\/span><\/p>\n

                  #include <stdlib.h><\/span><\/p>\n

                   <\/p>\n

                  int main() {<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0int n = 5;<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0int *dynamicArray;<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0int i;<\/span><\/p>\n

                   <\/p>\n

                  \u00a0\u00a0\u00a0\u00a0dynamicArray = (int *)malloc(n * sizeof(int));<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0if (dynamicArray == NULL) {<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Memory allocation failed.\\n”);<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return 1;<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                   <\/p>\n

                  \u00a0\u00a0\u00a0\u00a0for (i = 0; i < n; i++) {<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0dynamicArray[i] = i + 1;<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                   <\/p>\n

                  \u00a0\u00a0\u00a0\u00a0printf(“Dynamic array elements:\\n”);<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0for (i = 0; i < n; i++) {<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“%d “, dynamicArray[i]);<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                   <\/p>\n

                  \u00a0\u00a0\u00a0\u00a0free(dynamicArray); \/\/ Free allocated memory<\/span><\/p>\n

                  \u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

                  }<\/span><\/p>\n

                   <\/p>\n

                  Resizing Dynamic Arrays<\/b><\/h3>\n

                  If you need to change the size of a dynamic array, use <\/span>realloc()<\/span>:<\/span><\/p>\n

                  c<\/span><\/p>\n

                  CopyEdit<\/span><\/p>\n

                  dynamicArray = (int *)realloc(dynamicArray, newSize * sizeof(int));<\/span><\/p>\n

                   <\/p>\n

                  This adjusts the allocated memory to <\/span>newSize<\/span> elements. If <\/span>newSize<\/span> is larger, additional memory is allocated.<\/span><\/p>\n

                  Advantages of Dynamic Arrays<\/b><\/h3>\n
                    \n
                  • Size can be changed at runtime.<\/span><\/li>\n
                  • Efficient use of memory.<\/span><\/li>\n
                  • Useful when the amount of data is unknown beforehand.<\/span><\/li>\n<\/ul>\n

                    Disadvantages<\/b><\/h3>\n
                      \n
                    • More complex to manage.<\/span><\/li>\n
                    • Requires manual memory management.<\/span><\/li>\n
                    • Possibility of memory leaks if not handled properly.<\/span><\/li>\n<\/ul>\n

                      Operations on Arrays<\/b><\/h2>\n

                      Arrays support various operations crucial for manipulating data:<\/span><\/p>\n

                      Insertion<\/b><\/h3>\n

                      Inserting an element into an array requires shifting existing elements to make space at the desired position.<\/span><\/p>\n

                      Example: To insert at position <\/span>pos<\/span>, shift elements from <\/span>pos<\/span> onwards one step right.<\/span><\/p>\n

                      Deletion<\/b><\/h3>\n

                      Deleting an element involves shifting elements after the deleted element to fill the gap.<\/span><\/p>\n

                      Searching<\/b><\/h3>\n

                      Searching involves traversing the array to find an element. Linear search scans elements sequentially, while binary search requires sorted arrays and is faster.<\/span><\/p>\n

                      Sorting<\/b><\/h3>\n

                      Sorting arranges elements in ascending or descending order. Common algorithms include bubble sort, selection sort, insertion sort, quicksort, and mergesort.<\/span><\/p>\n

                      Insertion in Arrays: Detailed Example<\/b><\/h2>\n

                      Here is a program that inserts an element into an array at a given position:<\/span><\/p>\n

                      c<\/span><\/p>\n

                      CopyEdit<\/span><\/p>\n

                      #include <stdio.h><\/span><\/p>\n

                       <\/p>\n

                      int main() {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0int i, pos, element;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0int my_array[11] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}; \/\/ 10 elements, extra space for insertion<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0int n = 10; \/\/ Current number of elements<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0printf(“Enter the position to insert (1 to %d): “, n+1);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0scanf(“%d”, &pos);<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0if (pos < 1 || pos > n + 1) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Invalid position!\\n”);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return 1;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0printf(“Enter the element to insert: “);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0scanf(“%d”, &element);<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0for (i = n – 1; i >= pos – 1; i–) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0my_array[i + 1] = my_array[i];<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0my_array[pos – 1] = element;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0n++;<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0printf(“Array after insertion:\\n”);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0for (i = 0; i < n; i++) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“%d “, my_array[i]);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

                      }<\/span><\/p>\n

                       <\/p>\n

                      This program takes user input for the position and the element to insert, shifts elements rightward, and places the new element correctly.<\/span><\/p>\n

                      Deletion from Arrays: Example<\/b><\/h2>\n

                      Deletion from an array removes the element at a specified position and shifts the rest to fill the gap.<\/span><\/p>\n

                      c<\/span><\/p>\n

                      CopyEdit<\/span><\/p>\n

                      #include <stdio.h><\/span><\/p>\n

                       <\/p>\n

                      int main() {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0int i, pos;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0int my_array[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0int n = 10; \/\/ Number of elements<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0printf(“Enter the position to delete (1 to %d): “, n);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0scanf(“%d”, &pos);<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0if (pos < 1 || pos > n) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Invalid position!\\n”);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return 1;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0for (i = pos – 1; i < n – 1; i++) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0my_array[i] = my_array[i + 1];<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0n–;<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0printf(“Array after deletion:\\n”);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0for (i = 0; i < n; i++) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“%d “, my_array[i]);<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                       <\/p>\n

                      \u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

                      }<\/span><\/p>\n

                       <\/p>\n

                      Searching in Arrays<\/b><\/h2>\n

                      Linear Search<\/b><\/h3>\n

                      Linear search scans every element sequentially until the target is found or the end is reached.<\/span><\/p>\n

                      c<\/span><\/p>\n

                      CopyEdit<\/span><\/p>\n

                      int linearSearch(int arr[], int n, int target) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0for (int i = 0; i < n; i++) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if (arr[i] == target) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return i; \/\/ Return index if found<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0return -1; \/\/ Not found<\/span><\/p>\n

                      }<\/span><\/p>\n

                       <\/p>\n

                      Binary Search<\/b><\/h3>\n

                      Binary search works on sorted arrays by repeatedly dividing the search interval in half.<\/span><\/p>\n

                      c<\/span><\/p>\n

                      CopyEdit<\/span><\/p>\n

                      int binarySearch(int arr[], int left, int right, int target) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0while (left <= right) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0int mid = left + (right – left) \/ 2;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if (arr[mid] == target) return mid;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if (arr[mid] < target) left = mid + 1;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0else right = mid – 1;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0return -1; \/\/ Not found<\/span><\/p>\n

                      }<\/span><\/p>\n

                       <\/p>\n

                      Sorting Arrays<\/b><\/h2>\n

                      Sorting arranges the elements in order, usually ascending or descending.<\/span><\/p>\n

                      Bubble Sort Example<\/b><\/h3>\n

                      Bubble sort repeatedly swaps adjacent elements if they are in the wrong order.<\/span><\/p>\n

                      c<\/span><\/p>\n

                      CopyEdit<\/span><\/p>\n

                      void bubbleSort(int arr[], int n) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0int i, j, temp;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0for (i = 0; i < n – 1; i++) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0for (j = 0; j < n – i – 1; j++) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if (arr[j] > arr[j + 1]) {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0temp = arr[j];<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0arr[j] = arr[j + 1];<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0arr[j + 1] = temp;<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                      }<\/span><\/p>\n

                      Linked Lists in C<\/b><\/h2>\n

                      A linked list is a dynamic data structure consisting of nodes where each node contains data and a pointer to the next node in the sequence. Unlike arrays, linked lists do not store elements in contiguous memory locations, allowing efficient insertion and deletion without the need to shift elements.<\/span><\/p>\n

                      Advantages of Linked Lists<\/b><\/h3>\n
                        \n
                      • Dynamic size: Can grow or shrink during execution.<\/span><\/li>\n
                      • Efficient insertion and deletion: No shifting required, just pointer adjustments.<\/span><\/li>\n
                      • Memory utilization is efficient because nodes are allocated as needed.<\/span><\/li>\n<\/ul>\n

                        Disadvantages of Linked Lists<\/b><\/h3>\n
                          \n
                        • No direct access to elements; traversal is required.<\/span><\/li>\n
                        • Extra memory is needed to store pointers.<\/span><\/li>\n
                        • Access time is linear, slower than arrays for indexing.<\/span><\/li>\n<\/ul>\n

                          Structure of a Node<\/b><\/h2>\n

                          In C, a node in a linked list is typically defined using a struct containing data and a pointer to the next node.<\/span><\/p>\n

                          c<\/span><\/p>\n

                          CopyEdit<\/span><\/p>\n

                          struct Node {<\/span><\/p>\n

                          \u00a0\u00a0\u00a0\u00a0int data;<\/span><\/p>\n

                          \u00a0\u00a0\u00a0\u00a0struct Node *next;<\/span><\/p>\n

                          };<\/span><\/p>\n

                           <\/p>\n

                          Here, <\/span>data<\/span> stores the value, and the <\/span>next<\/span> points to the next node.<\/span><\/p>\n

                          Types of Linked Lists<\/b><\/h2>\n
                            \n
                          • Singly Linked List<\/b>: Each node points to the next node; traversal is one-way.<\/span><\/li>\n
                          • Doubly Linked List<\/b>: Nodes have pointers to both next and previous nodes; traversal in both directions.<\/span><\/li>\n
                          • Circular Linked List<\/b>: The last node points back to the first node, forming a circle.<\/span><\/li>\n<\/ul>\n

                            Singly Linked List<\/b><\/h3>\n

                            This is the simplest form, where each node contains data and a pointer to the next node.<\/span><\/p>\n

                            Operations on Singly Linked Lists<\/b><\/h2>\n

                            Creating a Node<\/b><\/h3>\n

                            Dynamic memory allocation is used to create new nodes.<\/span><\/p>\n

                            c<\/span><\/p>\n

                            CopyEdit<\/span><\/p>\n

                            struct Node* createNode(int data) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* newNode = (struct Node*) malloc(sizeof(struct Node));<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (!newNode) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Memory allocation error\\n”);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return NULL;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0newNode->data = data;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0newNode->next = NULL;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0return newNode;<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            Inserting at the Beginning<\/b><\/h3>\n

                            To insert a node at the start of the list:<\/span><\/p>\n

                            c<\/span><\/p>\n

                            CopyEdit<\/span><\/p>\n

                            void insertAtBeginning(struct Node** head, int data) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* newNode = createNode(data);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (!newNode) return;<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0newNode->next = *head;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0*head = newNode;<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            Inserting at the End<\/b><\/h3>\n

                            To insert a node at the end of the list:<\/span><\/p>\n

                            c<\/span><\/p>\n

                            CopyEdit<\/span><\/p>\n

                            void insertAtEnd(struct Node** head, int data) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* newNode = createNode(data);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (!newNode) return;<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (*head == NULL) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0*head = newNode;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* temp = *head;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0while (temp->next != NULL) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0temp = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0temp->next = newNode;<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            Deleting a Node<\/b><\/h3>\n

                            Deleting a node with a given value:<\/span><\/p>\n

                            c<\/span><\/p>\n

                            CopyEdit<\/span><\/p>\n

                            void deleteNode(struct Node** head, int key) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* temp = *head;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* prev = NULL;<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (temp != NULL && temp->data == key) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0*head = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0free(temp);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0while (temp != NULL && temp->data != key) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0prev = temp;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0temp = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (temp == NULL) return;<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0prev->next = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0free(temp);<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            Traversing the List<\/b><\/h3>\n

                            To print the elements:<\/span><\/p>\n

                            c<\/span><\/p>\n

                            CopyEdit<\/span><\/p>\n

                            void printList(struct Node* head) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* temp = head;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0while (temp != NULL) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“%d -> “, temp->data);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0temp = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0printf(“NULL\\n”);<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            Example Program: Singly Linked List Operations<\/b><\/h2>\n

                            c<\/span><\/p>\n

                            CopyEdit<\/span><\/p>\n

                            #include <stdio.h><\/span><\/p>\n

                            #include <stdlib.h><\/span><\/p>\n

                             <\/p>\n

                            struct Node {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0int data;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* next;<\/span><\/p>\n

                            };<\/span><\/p>\n

                             <\/p>\n

                            struct Node* createNode(int data) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* newNode = (struct Node*) malloc(sizeof(struct Node));<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (!newNode) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Memory allocation error\\n”);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return NULL;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0newNode->data = data;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0newNode->next = NULL;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0return newNode;<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            void insertAtBeginning(struct Node** head, int data) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* newNode = createNode(data);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (!newNode) return;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0newNode->next = *head;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0*head = newNode;<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            void insertAtEnd(struct Node** head, int data) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* newNode = createNode(data);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (!newNode) return;<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (*head == NULL) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0*head = newNode;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* temp = *head;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0while (temp->next != NULL) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0temp = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0temp->next = newNode;<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            void deleteNode(struct Node** head, int key) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* temp = *head;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* prev = NULL;<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (temp != NULL && temp->data == key) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0*head = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0free(temp);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0while (temp != NULL && temp->data != key) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0prev = temp;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0temp = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0if (temp == NULL) return;<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0prev->next = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0free(temp);<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            void printList(struct Node* head) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* temp = head;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0while (temp != NULL) {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“%d -> “, temp->data);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0temp = temp->next;<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0printf(“NULL\\n”);<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            int main() {<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0struct Node* head = NULL;<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0insertAtEnd(&head, 10);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0insertAtBeginning(&head, 5);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0insertAtEnd(&head, 15);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0insertAtEnd(&head, 20);<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0printf(“Linked list: “);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0printList(head);<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0deleteNode(&head, 15);<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0printf(“After deleting 15: “);<\/span><\/p>\n

                            \u00a0\u00a0\u00a0\u00a0printList(head);<\/span><\/p>\n

                             <\/p>\n

                            \u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

                            }<\/span><\/p>\n

                             <\/p>\n

                            Stacks in C<\/b><\/h2>\n

                            A stack is a linear data structure that follows the Last In, First Out (LIFO) principle. Elements are added and removed only from the top of the stack.<\/span><\/p>\n

                            Characteristics of a Stack<\/b><\/h3>\n
                              \n
                            • Insertion (push) adds an element to the top.<\/span><\/li>\n
                            • Deletion (pop) removes the top element.<\/span><\/li>\n
                            • The element last added is the first to be removed.<\/span><\/li>\n
                            • Useful for function calls, expression evaluation, backtracking, etc.<\/span><\/li>\n<\/ul>\n

                              Stack Implementation Methods<\/b><\/h3>\n

                              Stacks can be implemented using arrays or linked lists.<\/span><\/p>\n

                              Stack Using Arrays<\/b><\/h3>\n

                              An array-based stack has a fixed size and uses an integer to track the top index.<\/span><\/p>\n

                              Stack Structure<\/b><\/h4>\n

                              c<\/span><\/p>\n

                              CopyEdit<\/span><\/p>\n

                              #define MAX 100<\/span><\/p>\n

                               <\/p>\n

                              struct Stack {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0int arr[MAX];<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0int top;<\/span><\/p>\n

                              };<\/span><\/p>\n

                               <\/p>\n

                              Initializing Stack<\/b><\/h4>\n

                              Set <\/span>top<\/span> to -1 to indicate an empty stack.<\/span><\/p>\n

                              c<\/span><\/p>\n

                              CopyEdit<\/span><\/p>\n

                              void initStack(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0s->top = -1;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              Checking Stack State<\/b><\/h4>\n

                              c<\/span><\/p>\n

                              CopyEdit<\/span><\/p>\n

                              int isFull(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return s->top == MAX – 1;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              int isEmpty(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return s->top == -1;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              Push Operation<\/b><\/h4>\n

                              c<\/span><\/p>\n

                              CopyEdit<\/span><\/p>\n

                              void push(struct Stack* s, int value) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0if (isFull(s)) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Stack overflow\\n”);<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return;<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0s->arr[++(s->top)] = value;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              Pop Operation<\/b><\/h4>\n

                              c<\/span><\/p>\n

                              CopyEdit<\/span><\/p>\n

                              int pop(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0if (isEmpty(s)) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Stack underflow\\n”);<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return -1;<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return s->arr[(s->top)–];<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              Peek Operation<\/b><\/h4>\n

                              c<\/span><\/p>\n

                              CopyEdit<\/span><\/p>\n

                              int peek(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0if (isEmpty(s)) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Stack is empty\\n”);<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return -1;<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return s->arr[s->top];<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              Example Program: Stack Using Array<\/b><\/h3>\n

                              c<\/span><\/p>\n

                              CopyEdit<\/span><\/p>\n

                              #include <stdio.h><\/span><\/p>\n

                              #define MAX 100<\/span><\/p>\n

                               <\/p>\n

                              struct Stack {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0int arr[MAX];<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0int top;<\/span><\/p>\n

                              };<\/span><\/p>\n

                               <\/p>\n

                              void initStack(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0s->top = -1;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              int isFull(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return s->top == MAX – 1;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              int isEmpty(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return s->top == -1;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              void push(struct Stack* s, int value) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0if (isFull(s)) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Stack overflow\\n”);<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return;<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0s->arr[++(s->top)] = value;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              int pop(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0if (isEmpty(s)) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Stack underflow\\n”);<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return -1;<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return s->arr[(s->top)–];<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              int peek(struct Stack* s) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0if (isEmpty(s)) {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Stack is empty\\n”);<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return -1;<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return s->arr[s->top];<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              int main() {<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0struct Stack stack;<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0initStack(&stack);<\/span><\/p>\n

                               <\/p>\n

                              \u00a0\u00a0\u00a0\u00a0push(&stack, 10);<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0push(&stack, 20);<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0push(&stack, 30);<\/span><\/p>\n

                               <\/p>\n

                              \u00a0\u00a0\u00a0\u00a0printf(“Top element: %d\\n”, peek(&stack));<\/span><\/p>\n

                               <\/p>\n

                              \u00a0\u00a0\u00a0\u00a0printf(“Popped: %d\\n”, pop(&stack));<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0printf(“Popped: %d\\n”, pop(&stack));<\/span><\/p>\n

                               <\/p>\n

                              \u00a0\u00a0\u00a0\u00a0printf(“Top element after pops: %d\\n”, peek(&stack));<\/span><\/p>\n

                               <\/p>\n

                              \u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

                              }<\/span><\/p>\n

                               <\/p>\n

                              Queues in C<\/b><\/h2>\n

                              A queue is a linear data structure that follows the First In First Out (FIFO) principle. Elements are added at the rear and removed from the front.<\/span><\/p>\n

                              Characteristics of a Queue<\/b><\/h3>\n
                                \n
                              • Insertion (enqueue) at rear.<\/span><\/li>\n
                              • Deletion (dequeue) from the front.<\/span><\/li>\n
                              • Used in scheduling, buffering, and resource management.<\/span><\/li>\n<\/ul>\n

                                Queue Implementation Methods<\/b><\/h3>\n

                                Queues can be implemented using arrays or linked lists.<\/span><\/p>\n

                                Queue Using Arrays<\/b><\/h3>\n

                                Queue uses an array along with two pointers or indices: front and rear.<\/span><\/p>\n

                                Queue Structure<\/b><\/h4>\n

                                c<\/span><\/p>\n

                                CopyEdit<\/span><\/p>\n

                                #define MAX 100<\/span><\/p>\n

                                 <\/p>\n

                                struct Queue {<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0int arr[MAX];<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0int front, rear;<\/span><\/p>\n

                                };<\/span><\/p>\n

                                 <\/p>\n

                                Initializing Queue<\/b><\/h4>\n

                                c<\/span><\/p>\n

                                CopyEdit<\/span><\/p>\n

                                void initQueue(struct Queue* q) {<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0q->front = -1;<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0q->rear = -1;<\/span><\/p>\n

                                }<\/span><\/p>\n

                                 <\/p>\n

                                Checking Queue State<\/b><\/h4>\n

                                c<\/span><\/p>\n

                                CopyEdit<\/span><\/p>\n

                                int isEmpty(struct Queue* q) {<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0return q->front == -1;<\/span><\/p>\n

                                }<\/span><\/p>\n

                                 <\/p>\n

                                int isFull(struct Queue* q) {<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0return q->rear == MAX – 1;<\/span><\/p>\n

                                }<\/span><\/p>\n

                                 <\/p>\n

                                Enqueue Operation<\/b><\/h4>\n

                                c<\/span><\/p>\n

                                CopyEdit<\/span><\/p>\n

                                void enqueue(struct Queue* q, int value) {<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0if (isFull(q)) {<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0printf(“Queue overflow\\n”);<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return;<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0if (isEmpty(q)) {<\/span><\/p>\n

                                \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/p>\n

                                Final Thoughts<\/b><\/h2>\n

                                The study and implementation of fundamental data structures\u2014arrays, linked lists, stacks, and queues\u2014form a cornerstone of computer science and software development. These structures are not only essential for academic purposes but also highly practical, forming the backbone of numerous algorithms and system-level operations in real-world applications.<\/span><\/p>\n

                                Arrays<\/b><\/h3>\n

                                Arrays provide a straightforward way of storing and accessing a fixed number of elements. They offer constant-time access via indexing, which is extremely efficient for many applications. However, their fixed size and the cost of inserting or deleting elements\u2014especially in the middle\u2014can be limiting. Arrays are best used when the number of elements is known in advance and when fast access is critical.<\/span><\/p>\n

                                Linked Lists<\/b><\/h3>\n

                                Linked lists overcome the limitations of arrays by allowing dynamic memory allocation. Nodes can be added or removed without reallocating or reorganizing the entire structure. This makes linked lists ideal for applications where the number of data elements is unpredictable or changes frequently. However, the trade-off comes in the form of increased memory usage due to pointer storage and slower access times since traversal is required to locate elements.<\/span><\/p>\n

                                Stacks<\/b><\/h3>\n

                                Stacks follow the Last In First Out (LIFO) principle and are pivotal in scenarios like function call management, expression evaluation, backtracking algorithms, and undo operations in software. Both array-based and linked list-based implementations have their merits: arrays offer simplicity and speed at the cost of flexibility, while linked lists offer dynamic sizing at the cost of slightly higher memory usage and complexity.<\/span><\/p>\n

                                Queues<\/b><\/h3>\n

                                Queues, operating on the First In First Out (FIFO) principle, are invaluable in scenarios such as task scheduling, handling asynchronous data (e.g., IO buffers), and breadth-first search algorithms. Like stacks, queues can also be implemented using arrays or linked lists, with similar trade-offs. Circular queues further optimize array-based queues by efficiently reusing array space.<\/span><\/p>\n

                                Real-World Applications<\/b><\/h3>\n

                                Understanding these data structures is crucial for developing efficient software systems. Operating systems use stacks for managing function calls and system state. Compilers use linked lists and stacks for parsing and syntax analysis. Queues are integral to job scheduling in operating systems, managing print queues, and buffering in network communication.<\/span><\/p>\n

                                Choosing the Right Structure<\/b><\/h3>\n

                                Selecting the right data structure often depends on the specific requirements of the problem. Arrays work well for read-heavy workloads with predictable sizes. Linked lists are better for insert-heavy or delete-heavy tasks. Stacks are best for depth-first scenarios, while queues shine in breadth-first or first-come-first-serve situations.<\/span><\/p>\n

                                Final Word<\/b><\/h3>\n

                                Mastering these foundational data structures not only enhances programming proficiency but also lays the groundwork for understanding more complex data structures like trees, graphs, heaps, and hash tables. Whether you are preparing for technical interviews, improving your software design, or studying computer science academically, a deep and practical understanding of arrays, linked lists, stacks, and queues is indispensable.<\/span><\/p>\n

                                In conclusion, each data structure has its strengths and weaknesses. A good programmer must understand these trade-offs and choose the most appropriate structure for the task at hand. With practice and thoughtful application, these basic tools can be harnessed to build powerful and efficient programs.<\/span><\/p>\n

                                 <\/p>\n","protected":false},"excerpt":{"rendered":"

                                In the programming world, data needs to be stored, organized, and manipulated efficiently. To achieve this, various types of containers called data structures are used. These data structures serve as specialized formats to arrange and manage data, enabling operations like insertion, deletion, searching, and sorting. Understanding data structures is fundamental for writing efficient code, optimizing memory use, and solving complex problems. The C programming language offers several built-in and derived data structures. These allow programmers to manage data effectively based on the requirements of their applications. This article introduces different…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[711],"tags":[],"class_list":["post-9576","post","type-post","status-publish","format-standard","hentry","category-programming"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t