## Introduction to Fundamentals of Data Structure in C

A data structure is a particular configuration of information for arranging and saving information so any client can easily get to and work inside specified data to run a program proficiently. PC memory data can be coordinated logically or numerically, and this interaction is known as a data structure. By and large, choosing a specific configuration of data relies upon two elements. The data should be sufficiently rich to fulfill the genuine relationship of the data in reality. What’s more, then again, the data design should be easy to the point that one can without much of a stretch cycle the data when it should be utilized.

### Fundamentals of Data Structure in C

Now let’s see the different fundamental concepts of data structure in c as follows.

#### Characteristics

**Linear:**In linear data structure we arrange the data in a sequential manner like array structure.**Non-Linear:**In nonlinear data structure we arrange the data in a non-sequential manner like graph and tree structure.**Static:**It is a static data structure that depicts the size and structure of a collection of data values related to a memory area at assemble time that is fixed. For example- Array.**Homogenous:**It is a quality of data structures addressing whether the data types of all components are the same for example Array.**Non-Homogenous:**It is a quality of data structures addressing whether the data types of all components are not the same.**Dynamic:**It is a dynamic data structure that characterizes the contracting and growing of data items at the run time or the program’s execution. It is likewise identified with the usage of the memory area that can be changed at the program’s run time for example Linked List.- It has a few principles that characterize how the data items are identified with one another.
- It characterizes a few guidelines to show the relationship between data items and how they communicate with one another.
- It has a few tasks used to perform on data items such as insertion, deletion and searching, and so on.
- It helps in reducing the utilization of memory assets.

**Time Complexity:**It is used to define how much time is required for the execution of a program and it should be less as possible.**Space Complexity:**It is used to define how much memory space is required for the execution of a program and it should be less as possible.

#### Types of Data Structure

Basically, there are two types of data structure.

##### 1. Primitive Data Structure

Basically Primitive Data types directly work with the machine instruction and it has different data types for different machines such as integer, float, character, string, constant and pointer.

##### 2. Non Primitive Data Structure

This is a complex data structure as compared to the primitive data structure. It works on clusters or we can say that grouping the same or different data values and it includes the following data structure as follows.

**Array: **Normally an array is a collection of values that are stored in a sequential manner in a memory location. If we need to store the multiple values that have the same data type at that time we can use an array data structure. The array data structure we illustrate by using the following figure as follows.

In the above figure we show the value of the array that is 10, 20, 30, etc, and the index of array 0, 1 to 7. Note here array index always starts with 0.

**List: **List we divide into two different categories as follows.

**1. Linear List: **Linear data structure can further be divided into two parts as follows.

**Stack:**Stack is one type of data structure in which we can store the data element. On the stack, we can perform the two types of operation such as**push**and**pop.**By using push operation, we can add the element into the stack and by using pop operation we remove the top element of the stack, so that reason stack works as**LIFO**manner (Last In First Out). The stack data structure we illustrate by using the following figure as follows.

**Queue:**Queue is also a linear data structure in which we can add elements from the**rear side**and we can remove elements from the**front****side**of the queue. The queue works as**FIFO**manner means (First In First Out). The queue data structure we illustrate by using the following figure as follows.

**2. Non Linear List: **Non linear list means there is no sequence to store the data; in other words, we can say that every element has multiple paths. The Non linear list also has two categories as follows.

**Graph:**Basically a graph is a collection of different nodes and nodes containing data value, all nodes are connected to other nodes in the graph. Between two nodes one link is present that we call edge. So,**G= (Vertices and Edges)**

Graph has different terminology. The graph data structure we illustrate by using the following figure as follows.

**Trees:**A tree is a nonlinear data structure, in which nodes are connected by using edges and it maintains the hierarchical data structure. See other data structures work in a sequential manner, suppose we need to perform any operation that increases the complexity of structure, so that is the reason we use tree data structure. The tree data structure we illustrate by using the following figure as follows.

### Example of Fundamentals of Data Structure in C

Now let’s see a basic example in a data structure as follows.

Normally we can implement Array, Linked List, Stack, Queue, Tree and graph, etc. in Data structure by using the C programming language.

**Code:**

```
#include <stdio.h>
#define MAX 50
void queue_insert();
void queue_delete();
void queue_display();
int que_array[MAX];
int que_rear = - 1;
int que_front = - 1;
main()
{
int ch;
while (1)
{
printf("1.Add Data Element \n");
printf("2.Delete Data element \n");
printf("3.Display Data elements \n");
printf("4.Quit \n");
printf("Enter choice : ");
scanf("%d", &ch);
switch (ch)
{
case 1:
queue_insert();
break;
case 2:
queue_delete();
break;
case 3:
queue_display();
break;
case 4:
exit(1);
default:
printf("Choice is incorrect \n");
}
}
}
void queue_insert()
{
int add_element;
if (que_rear == MAX - 1)
printf("Now Queue is Overflow \n");
else
{
if (que_front == - 1)
que_front = 0;
printf("Enter data element : ");
scanf("%d", &add_element);
que_rear = que_rear + 1;
que_array[que_rear] = add_element;
}
}
void queue_delete()
{
if (que_front == - 1 || que_front > que_rear)
{
printf("Now Queue is Underflow \n");
return ;
}
else
{
printf("Data Element deleted: %d\n", que_array[que_front]);
que_front = que_front + 1;
}
}
void queue_display()
{
int a;
if (que_front == - 1)
printf("Empty Queue \n");
else
{
printf("Queue: \n");
for (a = que_front; a <= que_rear; a++)
printf("%d ", que_array[a]);
printf("\n");
}
}
```

**Explanation**: By using the above example we try to implement the queue in the data structure by using C programming. The final output of the above statement we illustrate by using the following snapshot.

### Conclusion

We hope from this article you learn the Fundamentals of data structure in C. From the above article, we have learned the basic theory of Fundamentals of data structure and we also see different examples of Fundamentals of data structure. From this article, we learned how and when we use the Fundamentals of data structure in C.

### Recommended Articles

This is a guide to Fundamentals of Data Structure in C. Here we also discuss the definition and different fundamental concepts of data structure in c along with examples and its code implementation. You may also have a look at the following articles to learn more –

3 Online Courses | 5 Hands-on Projects | 34+ Hours | Verifiable Certificate of Completion

4.5

View Course

Related Courses