Notesale: Turn your study into money

Document Preview

Extracts from the notes are below, to see the PDF you'll receive please use the links above

---

1
...
The data can be taken from the user and stored in the array
...
The next step is to explore what
2d arrays are and how to access them
...
The declaration syntax of arrays is specific to the
language being used, such as C or Python
...
Later, the
passage talks about 1d array and how to initialize it using a loop or a
predefined function
...
The size of the array is specified at compile
time and cannot be changed during runtime
...
To access a particular element of the array, the base
address is added to the index value multiplied by the size of the data type
...
The concept of arrays was introduced to
process large amounts of data, as they allow for the storage of multiple
elements under a single variable name
...
This limitation can
be addressed using dynamic arrays or other data structures
...
The index can start from zero or one, and at run time, loops
such as for and while loops can be used to manipulate the data
...
To store data
in an array at compile time, loops can be used to continuously take five
integers from the user
...
The memory
manager allocates space for data and copies it to consecutive locations,
allowing the programmer to manipulate and access the data in the array
...
2 Array Operations - Traversal, Insertion |
Explanation with C Program | DSA Course
In this video about operations performed on arrays in data structures, the
author discusses traversal, insertion, and deletion of data from arrays
...
In an unsorted
array, you must take care of the relative ordering of the elements during a
shift operation
...
Initializing an array
can be done at compile time or runtime, with the latter involving asking the
user for input
...
The author explains that
scanf is used to take input from the user, while printf is used for output
...

The author provides information on various operations that can be
performed on 1D arrays in data structures
...
The author
instructs viewers on how to populate an array at runtime, asking users to
input the number of elements they wish to insert and the maximum size of
the array
...

The author explains that there is no concept of upper-bound checking in C
arrays, and therefore, the programmer must handle bound checking in the
code
...
The author also discusses the concept
of overflow conditions and suggests adding code to check for upper-bound
limits in arrays
...
Passage B provides additional information about
how programmers can check the upper-bound limit of an array and how to
insert an element at a specific position
...

The author also provides an example of how to locate duplicate values in

an array and how to shift elements to the right when inserting new data
...
Overall,
the author provides a comprehensive overview of array operations in data
structures, including key considerations such as overflow conditions and
bound checking
...
If
you get how data can be inserted at a specific position then you can easily
modify the code for inserting the data at the beginning and at the end of
the array
...
There is no upper bound checking concept of areas in C, so
the programmer has to write down the code itself for the checking of the
boundaries in C
...
e
...
If the user
enters the size of the array as 51 or 60, then the memory manager has
allocated to how many bytes two hundred bytes for storing 50 elements
...
The code for inserting data at a
specific position involves starting the for loop from size minus one and
going till position minus one
...
The
swapping is to insert, and it is to write a control, and it will be replaced by
the swap
...
After inserting the number,
the array size becomes size plus plus plus
...
You cannot insert at position zero or a position greater than the
size of the array plus 1
...
It is
possible to insert data at any specific position, including the sixth position
...
The program will not ask the user about the position,
but it is fine to insert at the end of the program
...
The programmer must manually write
a for loop to implement the swapping of arrays
...
After inserting a new number, the size of the array increases
by one, and the programmer can print the new array by again using "printf
percentage D and a of I"
...
For an unsorted array,
shifting all elements to the right side can be time-consuming
...
In the upcoming videos, the best ways to insert data into an
unordered and sorted array will be discussed, and the process of deleting
data from an array will also be explained
...
In unsorted array
you have to take care of the relative ordering of the elements in sorted
array in that case you are doing two shift operations so you can apply this
shifting operations in this unsorted area
...


1
...
We will use the example from a previous video and also include
additional details provided in a separate passage
...

The maximum size of the array is determined by the variable 'size'
...

The elements of the array will be initialized at runtime
...
The position entered by the user must be checked for
validity
...
If the position entered by the user is valid, the

program will start a loop from the position to be deleted up to the end of
the array
...
To print the updated array after the
deletion, the elements will be printed using a for loop
...
If the data is deleted from a specific position, all the elements to
the right of that position will need to be shifted, which will take O(n) time
...
This algorithm
takes constant time, or O(1)
...
If the user wants to insert only a few elements, the
code will allocate extra memory for the array based on the user's input
...
Finally, when
deleting data from the beginning of the array, all elements will need to be
shifted to the left, and the size of the array will need to be decremented
...


1
...
It explains that a pointer value at a particular
address will return the corresponding element of the 2d array
...
Esther then demonstrates how to
print the value of a specific element of the 2d array using the pointer
...
It explains that a 2d array is an array of 3 1d arrays,
each with three elements, and shows the logical and actual representations
of the array
...
The
author emphasizes that while it is possible to write "p = a[0][0]", it is invalid

to write "p = &a[0][0]"
...

In this video, we will discuss how to access the elements of a 2d array using
pointers instead of using the array name
...
It's worth
clarifying that the value of a 1d array doesn't necessarily mean it will return
the same values it contains If we have an array a of 0 containing three
integer values, and we assign P to contain the address of an integer
variable other than an invalid one, we can print the address in hexadecimal
form using %p
...
Additionally, if we
print a plus 1 using %f, it will return the value of the first and next element
in the array
...
The last element in the array is a of 0, and the base
address of the first element in an array is always the same as the base
address of the array itself
...
If we write a of 1, it will return
the address of the complete array, and the address of the first element can
always be found using the array name
...
Either explains how to print a of 1 plus 2 plus 2 and a of
2 plus two using the studio fine, which is a simple program that can be
used for a series or sequence of equations
...

A straight a astray K means value at this address value is what value is this
complete 1d array fine or you can say address of its first element first
element in 2d arrays this complete one dear so it is going to return pointer
to this one da find out
...
Address of a means
it is going to give you the address of the first element of the array
...
If a plus one arithmetic plus
one in the pointer then it is pointing to the CUDA obviously the next
element
...
going to point this the next
...
The base address of the complete array is
also 200, but if you add plus one and plus one, they will be different
...

Adding the size of the array (3) to the address gives us 211
...
If we add one more to the
address, we get 216
...


2
...
Therefore, it is the responsibility of a
memory manager to manage this resource
...
For example, if the
programmer emphasized that they wanted a size for three integers, the
memory manager would allocate 12 bytes for these integers
...
However, sometimes, a
fresh block of elements may need to be allocated, and the memory
manager may allocate 208 bytes for 452 elements
...
While arrays are a collection of
elements stored in consecutive locations, linked lists are a collection of
elements stored in non-consecutive locations
...
One advantage of linked lists is that they do not
require a fixed size to be declared at compile time, as with arrays
...
This creates wastage of
memory that could have been used to store data
...
The accessing of any element takes order of 1 only,
constant time
...


Additionally, binary search is not possible in Linked List, posing a
disadvantage
...
The Linked List stores data in a non-contiguous manner,
and each element is associated with the pointer to the next element
...
The manager locates free space ranging from 8 to 12 bytes for each
variable- eight bytes for the value and four bytes for storing the pointer to
the next
...
In an array, this is not possible, as all values
should be stored at contiguous locations
...

The memory manager will allocate space for all five variables
...
In contrast, in an array, accessing any element takes
constant time
...
On the other hand, structured arrays are
well-suited for sorted insertion
...
The type of
values in a linked list can vary, and a node can contain different values such
as an integer value and an address
...
The memory manager will allocate space for noncontiguous values in a linked list, while in an array, all values must be in
contiguous locations
...
2 Introduction to Linked List in Data Structures
With a very good example, I will show what is linked list and why you would
like to use it
...
If you're hearing about it for the first time or didn't
understand it before, I will start with an example of a hospital to explain it
...
The advantage of using linked
lists is that we don't need to have all data elements at the same place, and

we can allocate memory dynamically based on our requirements
...
To
extend the list, we can simply add a new node and connect it to the
previous one through the pointer
...
For example, assume that a hospital has four beds with bed
numbers 0, 1, 2, and 3, and these beds are used for conducting full body
checkups
...
The doctors then informed the patients
that many other hospitals have beds available, such as Hospital H1 in Delhi
that has four beds with bed numbers 0, 1, 2, and 3
...
Patients can go to any of these hospitals and
use the available beds
...
The analogy of a hospital
bed allocation helps in understanding how linked list works and how we
can extend it as per our requirements
...
The advantage of using a
linked list is that it allows for constant time access to specific elements,
even if they are not contiguous in memory
...
In contrast, arrays
cannot easily remove elements or access non-contiguous elements in
constant time
...
In hospitals, for example, a linked list system can be
used to manage patient beds
...
This system allows hospitals to allocate beds and manage patient
flow effectively and efficiently, ensuring that all occupied beds are utilized
properly
...
Unlike arrays, linked lists
allow the joining and removal of nodes anywhere in the list
...
Compared to arrays, linked lists
offer advantages such as precise allocation of memory, allowing for the use
of only the necessary amount of memory, regardless of the size of the list
...


2
...
Plus you should have the knowledge of
pointers plus structure what is structure data type in c
...
In C
language we are going to write struct node if you do n't write def fine in
C++ you can simply write this node that is fine but here I am discussing C
language fine now we have created this head node initially suppose we n't
have any node in the list so initially what head pointer will store head is
going to contain word 0 or you can say null
...
In C++ you can use new keyword fine to use malloc
function in C++
...

The data type is int so we are going to use percentage D and now C you
can not directly write here hash in this address of and data
...
Head is
equal to new node so simply you can write head is
...
new node
...
going to contain
zero now next thing is you have to point this to this right so now you have
...
You simply write head is equal to new
new node then in this case also now head is going to contain head is
equals to new node
...


In the next video, we will discuss inserting a newly created node into a list
at the beginning, any position, or the end of the list
...
However, while
inserting a new node, it is essential to take extra care to avoid losing the
link to the previous node by using another pointer
...
Instead, the new node pointer should
contain the address or pointer to the newly created node
...
Therefore, inserting a new
node is permanent, and the process involves making the head pointer point
to the first node while the new node pointer is pointing to the end of the
list
...
In this
way, as many nodes as possible can be created and accessed
...
Overall, extra care must be taken while inserting nodes
into a list to avoid losing the reference to previous nodes
...
In the next video, the creation and
traversal of nodes in a list will be discussed, as well as how to insert new
nodes at various positions
...


2
...
The author explains that accessing the linked list is done through
the head node that points to the first element
...
There are no time complexities as it
does not depend on (n)
...
com and dailymailonline
...
The author then returns to the topic of linked

list insertion in which they describe the process of insertion and how it
makes the user feel like they are being injected into the linked list
...

Passage A describes the process of inserting a node at any given index in a
linked list
...
However, if a node is
being inserted at the beginning of the list, the time complexity will be
constant, i
...
, O(1)
...

Passage B, on the other hand, is unrelated to the topic of linked lists and
talks about wanting to give the world a chance and being a good person
...
It also mentions that if
someone is not aware of what a linked list is, they may find it interesting to
read about it
...

In the previously mentioned linked list insertion technique, there are four
important cases that need to be considered
...
After the insertion process, it is important to print and observe the
list to ensure that the insertion was successful
...
Once
someone has a linked list, they can use it to find out more about the people
they are following in the UK, and the list includes important information
about the world's most significant people
...
The list
also provides information on popular cities in these countries, including the
most significant places to visit
...
Moreover, the list of the most
popular films, videos, and images can be found on several websites
...
The
notes on this topic are being made available by the speaker, and interested

individuals can find the link in the description or directly on the website
...
The speaker also shows how insertion
can be done in the beginning, and later in the video, he explains how to
insert between elements
...
The speaker
further states that he is creating a strategy for the insertion of nodes in
linked lists, and demonstrates how the four different types of insertions can
be used
...
c" to write
the code for these insertions
...
He further explains how these insertions can help
to create a new list or add nodes to the existing list
...

Passage A describes the process of creating and inserting nodes into a
linked list
...
The author emphasizes the simplicity of
working with linked lists and the reliability of computers in executing
code
...
The author also mentions a handwritten note they created
and offers it as a download
...
While the two passages appear unrelated, the
author's interest in sharing their work and helping others understand their
methods is evident in both
...
In all four cases, you have to follow the same process of
joining links as I have explained
...
To do so, the
author needs the head and data that they want to insert
...
They also explain the steps they took to
create the new head, such as making ptr equals the first element and
making ptr's next equal to head
...
Finally, they return
the head with the new node added to the beginning of the linked list

2
...
This method is based on a data structure that has been used to
create the list
...
It is
used for a list to create the list, which includes deleting a link in a link list, or
a list with a node that is linked to a list of linked lists or deleting a new
node in the linked list, or deleting it in a new list
...

This technique involves removing nodes, deleting nodes, creating nodes,
adding nodes, removing lists, creating lists, adding lists, taking lists,
discarding lists, and removing nodes and destroying lists
...

After this video you'll never ask how to do deletion of any node in linked
list because I am going to tell you in a very clear way
...
If you want to tag me, feel free to use
@codewithharry
...

If you do not free it, its memory will be lost
...

I have been given the head, which is pointing to the first index, and the
index of the node to be deleted (let's assume it's index 2)
...
I will
show you how to delete a node in between nodes in our linked list
...
1 Single Linked List Operations | Data Structures
Tutorial
All operations that can be performed on a single linkedlist can be done
using the Malloc or Ml log function in the C language
...
When inserting elements into the
linkedlist, a temporary variable must be created, which is a user-defined
data type variable called a node structure type variable
...

The values and information that need to be placed inside the node can now
be added
...
If the root element does not point to any other elements, the
newly created element should be the root element
...
This
involves providing the base address to the data location address using the
temporary variable
...
When inserting an element directly, the temporary
variable must be assigned to the root
...

Four elements are there for t it's null how to store all these things
...
Now
we are inserting one more element already node is ready right
...
based on null pointer only we should
travel from first location to last location
...
We have to check
what is the pvalue is a 1 0-2 2, 4 1 0, 0-2-4-2 link
...
This
is the insertion part how to insert an element in a linkedlist
...
So once we reach the last location, then we have to connect the
newly created node at the end of the list
...
When p2 link is equal to null, it means that the last
node has already been reached
...
Additionally, the author
states that when adding a new element to the linkedlist, one needs to
declare one local variable and another temporary variable, which will be
used to travel
...


3
...
This time,
we will discuss how to find the length of a single linked list
...
The root variable should
always point to the first node, and we collect the root variable into a
temporary variable called temp for memory allocation
...
In the case of
creating a linked list, the nodes are stored in random memory locations,
and root is pointed to the first node
...
Suppose we have a simple linked list with three nodes: 1>2->3, and the node addresses are 3000, 2000, and 1000, respectively
...

Therefore, the linked list has three nodes, and the root variable always
points to the first node, which is 1 in this example
...
We store the root variable into the temp variable, which gets
memory allocation
...

Finally, we return the count value, which is the length of the linked list
...
The

value of the node address should be unique and different from the existing
nodes, and the link value should point to the previous head
...

Listed below are the instructions for creating a node at the beginning of a
linked list, as explained in the video from Nourish ID channel
...
To create a node, first declare a local variable "temp" of the
structure "node"
...
This will give you a wide
pointer of type "node", which is collected into "temp"
...
Connect "temp" to the linked list by doing a temporary
connection to the "temp" node
...
If there are no elements in the list, the root value
should be null
...
As explained in the video, it is important to always connect
nodes to the right to ensure that information about the linked list is not
lost
...
3 Single Linked List Implementation | Data
Structures
In Java, the data in a linked list is stored in the form of nodes which have
two fields- data and link
...
To write a class node
implementation in Java, we use the class implementation 'c' and define two
non-static variables - data and next, where next is of type node
...
While
implementing a single linked list manually, the code is not used, but instead
the data is stored in the form of nodes which have a data field and a next
field
...
The external
variables are accessed using an internal pointer and don't need to specify
the default values
...
The data structures
in Java through C language videos and core Java are almost the same
...
The first static
method, "append()," is used to add a node to the list, followed by more
"append()" calls and then another static method, "display()
...
The
data for the new node is collected using the "Scanner" class object
...
Passage B provides additional details
about the implementation, particularly in regards to the use of static
methods and the creation of nodes
...
The author also emphasizes that it is not necessary to
follow programming rules strictly, stating "that is your wish right you can
follow the rules but not mandatory once you are perfect in programming
...
The author also discusses the use of the "sc" static variable, which can
be accessed globally
...

When a node is added, the root variable is checked and replaced with a
new value if necessary to connect the new node to the list
...

To create a fourth node, one needs to consider the location where it needs
to be created
...
Once the node is created, we need to assign the last node's address
to the third node's link
...
We use a while loop to traverse the list until we reach the
last node (which is p
...
We then check if p
...
link
...
Once the last
node is reached, we add the newly created node at that location
...
Furthermore, we should not print anything if the list is
empty
...
data to print
the data
...
The root value is initially set to 2 0 4 6 since it is
pointing to some other node
...
To assign
the last node's address, we traverse the list using a while loop and
temporarily collect the first node address
...
When
displaying elements, we use temp
...
The program should be compiled
and executed using the command prompt
...
java" and compile it successfully
...
To determine the length of the nodes in the list, use the method
"length()", which iterates through the nodes and increments a counter until
the current node is null
...
The video shown in session one of the series
demonstrated how to add and append nodes in a single linked list
...
java" and it was
saved in the D drive
...
4 Node swap in Single Linked List | Data Structures
Tutorial
Ramos is discussing how to swap two adjacent nodes in a single linked list
using their addresses
...

Additionally, he emphasizes the importance of understanding how the
structure of the nodes will change before swapping after nodes
...
next
...
Ramos notes that it
is crucial to use simple and straightforward solutions when swapping nodes

in a linked list
...
The added information from
Passage B also mentions a channel called Nourish 80 and a feature called
iReport, but this is not relevant to the discussion on swapping nodes in a
linked list

4
...
The structure of a node in a
single linked list is different from that of a double linked list
...
The first node is created at a specific memory location, which is
stored in the root variable to point to the first node
...
The data field address is crucial in the node, as it is the
field where data is stored
...
The connection is a two-way connection,
with each node being connected to the previous and next nodes'
addresses
...

In a double linked list, if the if block evaluates to true then the else block
will not be executed
...
To add more
nodes, the else block executes and a pointer variable p is defined which
points to the node where the new node needs to be created
...
To travel to the next node, p2 is used to traverse to
the right node
...
This process is repeated for adding multiple
nodes
...
2 Double Linked List in Data Structures and
Algorithms | Part-2
Passage A covers how to find the length of a linked list, display all its
elements, and add a new element to the beginning of the list using a
simple logic
...
However, it does not discuss appending a node in a double linked list,
allocating memory with the help of a malloc function, or any techniques
used in cinemas
...
It highlights the
importance of establishing three connections to ensure proper connectivity
between nodes and points out that left-side connections cannot be
established directly
...
Therefore, combining the information in Passage A and B, one
can learn how to find the length, display all elements, add a new element to
the beginning of a linked list, and append nodes in a double linked list
...
However, the information on
techniques used in cinemas seems unrelated to the topic discussed in
Passage A, and therefore, may not be relevant to the learner's objective
...

According to passage B, we can also simply write root instead of a
temporary variable
...
To find the length of the linked list,
we can traverse the list and count the number of nodes, as described in
passage A
...
To display all the elements in a double linked list, we
can traverse the list starting at the root and print each node's value, as
described in passage A
...
Finally, passage B mentions that there are more videos
available on the Nourish It channel, and thanks viewers for their support

4
...
As discussed previously, we have learned how to append
elements in a double linked list, how to add a node at the beginning of the
list, how to display the elements, and how to find the length of the list
...
We will create a pointer variable "*p" and initialize
its value with the root value
...
The first
node's address is at 1000, and the "*p" value is initially set to 1000
...
Once this function's
execution is completed, it will be deleted
...
We will check if the location is
greater than the available number of nodes in the list
...
The temporary pointer
variable "temp" is temporarily pointing to the newly created node, which is
created at location 5000 after the memory allocation of sizeof struct node
...
This
process will continue until the desired location is reached, and the new
node's right value will be stored as 3000
...
" This
helps in identifying errors in the program and makes it easier to fix them
...

Follow these steps to add a node after a specified node in a double linked
list
...
Next, create a new node with
the desired value
...
Set the "prev" pointer of the new node
to the specified node, and set the "next" pointer of the specified node to
the new node
...
This process automatically applies to
the last node in the list
...
To store a value like 5000,
use the location or node specified in Passage B
...
To store a value
like 3000, store it into the specified node or location
...
1 Stack in Data Structure | Data Structure Tutorial
What is a stack? A stack is a simple algorithm that operates based on a last
in, first out rule
...
The main purpose of a stack is to store
information in certain situations, allowing for efficient access to the
information
...
Initially,
the capacity of the stack is set to 5
...
In order to allocate memory dynamically, we can use a
catalog function and free function
...
However, we should use dynamic
memory allocation concepts to allocate memory to the stack
...
In order to perform operations on a stack data, a logic must be
written, which can be done with the help of pointers concept
...

Overall, a stack is a useful tool for storing information and accessing it
efficiently
...

The stack data structure is implemented using several main functions, which
include traversing elements, as well as optional functions that can be
implemented as needed
...
The
operations of pushing and popping elements can be performed on the

stack using the variable "top"
...
This information is important for
effectively storing and processing information in programming
applications
...
The logic for implementing these
functions can be written using the information provided in a book by the
author
...
2 Creation of Stack in DS | Data Structures Tutorial
In this session we are going to discuss how to implement a stack using
static erase
...
All these things okay, so in the main method either locally you
can declare or globally
...

programmatically programmatically
...
right with the help of a
constant size constant is nothing but a write preprocessor
...
if a stack
is a full it returns a one
...
if a block
...
If block fails, then block executes another block in an
attempt to insert an element into the stack
...

When an element is inserted using the push method for the first time, it
becomes the top value at index 1 and is stored in location 20
...
The pop method removes the top
element of the stack, and the empty function determines whether the stack
is devoid of elements
...

The if-else block is used to execute code under specific circumstances
...
Passage B also
expressed that every operation performed on the stack utilizes the top
variable
...
We will discuss how to perform all the stack operations,
including creating the stack, storing, and removing information, and
printing the information
...

With the help of a constant size constant, which is nothing but a write
preprocessor macro, we check if the stack is full or not, and it returns a one
if the condition is true; else, it returns zero
...
Additionally, there is no function to delete
the information that is in a memory location
...
Therefore, by implementing
the stack in a single program, we can combine all these logics and
understand how to perform stack operations
...
To collect elements in a stack, we can declare and
use them with for loops as well
...
3 Program to Implement all the Stack Operations
using Static Array | Data Structures
We are going to write a program to implement all the stack operations
using static array
...
How to perform operations on a stack
...
I will show you the execution how it will execute
...
traverse
is nothing but just printing the elements right is full method is empty
method so we 'll write that right
...
[UNK] "any number you give then it will execute
...
the message very clearly invalid input This two lines gap
gap are given after printing that one invalid input" "No still program is
executing of course logic not in define"
...
[UNK]
"we are writing prototypes
...
No
need to write the element just wide push of in teaser sir" when a stack is full
there is no place to insert the new element into the stack place is not there
so here simply whenever whenever a top value is equals to capacity minus
1
...

Whenever we are trying to push one more element it will give the error
message directly is full condition true
...
Here it is
stack is
...
We are
just printing that a deleted item, deleted item or
...
What item you
deleted that item
...
There were no
elements directly
...
A value is a traversing from 0 to
up to top location
...
So this is now we
have to write prototype of all only
...
After execution of every
case
...
the program represents how
to perform all the stack operations using static arrays nothing but with a
constant memory
...
We will discuss how to use a dynamic
memory using a static memory
...
4 Stack Using Single Linked List - Part 1 | Data
Structures Tutorial
In this session, we will discuss how to implement a stack using the single
linked list concept
...
All the operations would be performed in such a
way that it aligns with last in first out (LIFO) and will be performed with the
help of a top variable
...
First, let us understand the basic concepts like how to
create a node, how to insert elements, and how to push the elements onto
the stack
...
The top value is initially null
...
The key is a data field that we take as an integer
type, and the pointer value is used to link the nodes to form a single linked
list
...
To create a node using single
linked list, we need to declare a temporary variable using "struct node
*temp;" and get memory allocation at some location
...
With this implementation, the stack becomes a last in first out data
structure, and all operations can be performed using the top variable
...

Using a single linked list, a stack can be implemented by following the LastIn-First-Out (LIFO) principle
...
To insert elements into the
stack, a new node with the element to be inserted is created, and the next
pointer of the new node is set to point to the current top of the stack
...
Similarly, to remove
elements from the stack, the top element is saved in a variable, and the top
of the stack is set to be the next node in the list before returning the saved
element
...
It
should be kept in mind that iterating through the nodes while displaying
the elements in the stack can modify it
...
However, in a separate passage, the author
discusses how to call the push method when using a single linked list as a
stack correctly
...

Additionally, the author briefly discusses inserting elements into a single
linkedlist and how to pop and display them
...
5 Stack Using Single Linked List - Part 2 | Data
Structures Tutorial
Lynn and Travis discussed the implementation of a stack in a single linked
list
...
Lynn
emphasized that when deleting an element from the stack, the top node is
always deleted, and checking first for the presence of elements is necessary
...

However, if elements are present, the top value is collected into a temp
variable, the address of the node to delete, and the data of that node is
stored
...
" Additionally, the last node address is
pointing to the fourth node, which is, in turn, pointing to the third node, in
a last in first out (LIFO) manner
...
To delete all elements from the
stack or to traverse them, a void function, which is called "the function," is
required
...
Finally, Travis emphasized that the function would delete a certain
number of nodes or elements in the list
...
A stack is a collection of elements that follows the Last-In-FirstOut (LIFO) principle, meaning the elements added to the stack tend to be
removed first
...
Additionally, the
video shows how to traverse and display all elements on the stack
...
If the stack is not empty, one should start from the top of the
position
...
Finally, the video shows how to
create a stack class that uses the node class to create and manipulate the
stack, with methods to add elements, remove elements, and to display
elements on the stack
...
6 How to Perform Operations on Queue | Data
Structures
We will learn how to perform operations on a queue
...
Insertion of elements into the queue is
possible through rail and deletion is possible through x1
...

If the queue is already full, you cannot insert the elements
...
To traverse
the elements, we read the element using printf and scanf functions
...
We should move the
rare position to insert the next element
...
Suppose we want to insert one more
element, "insert into the queue
...
To
find the total number of elements, simply display them
...
If it is, no operation can be
performed
...
Then, increase i to 1
...
To perform deletion, decrease the value of rare by 1
...
7 Circular Queue | Data Structures using C
A circular queue is a concept in data structures and algorithms that involves
representing a queue in the form of a circle to avoid shifting all the
elements when deleting from the front
...
However, insertions
are done using the rear variable, while deletions are performed with the
front variable
...
The circular queue has a size of six index numbers, from
zero to five
...
Insertion involves storing an

element at q[rare], wrapping around to the beginning of the queue if
necessary
...

Deletion involves moving the front variable forward by one and printing the
deleted item
...
To insert
an element, the rare value is incremented by one
...
The circular queue allows for efficient insertion, deletion, and
display operations
...
8 Operations on Circular Queue | Data Structures
Tutorial
We will focus on circular queues and look at the different operations that
we can perform on them
...

Let's consider the insertion process first
...
Here's how we can do it: Retrieve
the position of the element to be inserted, let's say it's at the end of the
queue Collect the element from this position Assign this element to a
variable, say "deleted_item" Increment the "front" pointer to the next
position Now, let's look at the process for deleting an element from the
circular queue
...
Here's how we can delete an element: Delete the element
pointed by the "front" pointer, which is 30 in this case Increment the "front"
pointer to the next position After the deletion, the circular queue will
contain the elements [40, 50, 60]
...




---