Get free ebooK with 50 must do coding Question for Product Based Companies solved
Fill the details & get ebook over email
Thank You!
We have sent the Ebook on 50 Must Do Coding Questions for Product Based Companies Solved over your email. All the best!

# Difference between Primitive and Non Primitive Data Structure

Last Updated on May 9, 2023 by Prepbytes

Data structures are closely linked with primitive and non-primitive data types. Data structures provide a way for programmers to organize and manage data efficiently, by choosing the appropriate data structure for the task at hand. This can help optimize the code and improve the performance of the application.

## Primitive Data Type

These are basic data types that are built into a programming language and are generally considered the most basic data types. They are called primitive because they are not composed of any other data types. Examples of primitive data types include integers, float, characters, and boolean values.

• Integer: It is a whole number that can be positive, negative, or zero. These are represented by the "int" data type.

Example of primitive data type:

C++:

``int num = 10;``

Java:

``int num = 10;``
• Float: It is a number with a decimal point that can be positive, negative, or zero. Floats are represented by the "float" or "double" data type.

Example:

C++:

``float num = 3.14;``

Java:

``float num = 3.14f;``
• Character: It is a single symbol, letter, or digit. These are represented by the "char" data type.

Example:

C++:

``char letter = 'a';``

Java:

``char letter = 'a';``
• Boolean: It is a data type that can have one of two values: true or false. These are represented by the "bool" data type.

Example:

C++:

``bool isTrue = true;``

Java:

``boolean isTrue = true;``

## Non-primitive Data Type

These are more complex data types that are composed of primitive data types or other non-primitive data types. They are also referred to as composite data types or reference data types. Examples of non-primitive data types include arrays, stacks, queues, and trees.

Here, are some examples of non-primitive data types:

• Array: An array is a collection of elements of the same data type stored in contiguous memory locations. Elements in an array can be accessed using their index value.

Example of Non-primitive data type:

• Stack: It defines the Last-In-First-Out (LIFO) principle. Elements are inserted and removed from the top of the stack. Common operations on stacks include push (insertion), pop (remove), peek (accessing the top element without removing it), and checking if the stack is empty.

Example:

• Queue: It follows the First-In-First-Out (FIFO) principle. Elements are inserted at the back of the queue and removed from the front. Common operations on queues include enqueue (insertion), dequeue (removal), peek (accessing the front element without removing it), and checking if the queue is empty.

Example:

• Tree: A tree is a collection of nodes, where each node has a value and a set of zero or more child nodes. The topmost node in the tree is called the root node, and every other node is connected to the root node by a unique path. To represent hierarchical relationships between data elements in a tree, they are:

• Root node: The topmost node in a tree.
• Child node: A node directly connected to another node when moving away from the root.
• Parent node: A node directly connected to another node when moving toward the root.
• Leaf node: A node without any children.
• Subtree: A smaller tree that is part of a larger tree.

Example:

## Key Difference between Primitive and Non Primitive Data Structure

Here, is the difference between primitive and non primitive data structure:

Primitive Data Structures Non-Primitive Data Structures
1. It has basic data types in programming languages 1. These are complex data types composed of one or more primitive data types
2. These are used to represent simple values such as integers, booleans, and characters 2. These are used to represent more complex data objects such as arrays, queues, trees, and stacks
3. It has a fixed size and range of values 3. They can be resized or modified during runtime
4. These are defined by the language 4. These are defined by the programmer
5. It is Immutable 5. It is mutable
6. These are stored in the stack 6. These are stored in the heap

Conclusion
In conclusion, the difference between primitive and non primitive data structure serve different purposes in programming. Primitive data structures are basically used to represent simple values, while non-primitive data structures are used to represent more complex data objects. Understanding the difference between primitive and non primitive data structure is essential for building efficient and effective programs.

## Frequently Asked Question(FAQs)

Q1. Name some examples of primitive data types?
Ans: Some of the examples for primitive data types include integers, floating-point numbers, booleans, and characters.

Q2. Does primitive data types can be modified?
Ans: Primitive data types are immutable, which means they cannot be modified after they are initialized.

Q3. Name some examples of non-primitive data types?
Ans: Some examples for non-primitive data types include arrays, queues, trees, graphs, and objects.

Q4. Can non-primitive data types be resized or modified?
Ans: Non-primitive data types can be resized or modified during runtime, which makes them more flexible than primitive data types.

Q5. How do primitive and non-primitive data types stored in memory?
Ans: Primitive data types are usually stored in the stack, while non-primitive data types are stored in the heap.

Menu