Mehwish Khan

Panel-K

LINKED LIST
THEORY QUESTIONS:
1. Define a linked list. What are its main components?
Ans- What is a Linked List?

A linked list is a data structure where elements, called nodes, are connected by pointers. Each
node contains:

1. Data: The value.

2. Pointer: A reference to the next node (or NULL for the last node).

Types:

1. Singly Linked List: Points forward only.

2. Doubly Linked List: Points forward and backward.
3. Circular Linked List: The last node links back to the first.

Simple to grow or shrink, but slower to access specific elements compared to arrays.

2. Explain the advantages and disadvantages of

linked lists compared to arrays.
Ans- Advantages of Linked Lists over Arrays

1. Dynamic Size: Can grow or shrink at runtime.

2. Efficient Insertions/Deletions: No shifting of elements is required.
3. Memory Utilization: Allocates memory as needed, avoiding waste.

Disadvantages of Linked Lists compared to Arrays

1. Sequential Access: Requires traversal to access elements;

slower than arrays.
2. Memory Overhead: Extra space is needed for pointers.
3. Complexity: More difficult to implement and debug.
 3.What is the difference between a singly linked
list, a doubly linked list, and a circular linked list?
Ans- Comparison of Singly, Doubly, and Circular Linked Lists

Feature Singly Linked List Doubly Linked List Circular Linked List

2 (next and previous 1 or 2 (depending on

Pointers per Node 1 (next node)
nodes) singly/doubly circular)

Traversal
Unidirectional Bidirectional Unidirectional or bidirectional
Direction

Last Node Points to NULL Points to NULL Points back to the first node

Less (1 pointer per More (2 pointers per Similar to singly or doubly based
Memory Usage
node) node) on type

Easier at head; harder Easier at both ends Similar to singly or doubly based
Insertion/Deletion
elsewhere or middle on type

Better for
Simple operations with Useful in applications requiring
Use Cases bidirectional
linear data cyclic data (e.g., scheduling)
traversal

4.Describe the structure of a node in a linked list.

Ans- Structure of a Node in a Linked List

A node in a linked list typically contains two parts:

1. Data: Stores the actual value or information.

2. Pointer (Next): Holds the address of the next node in the list (or NULL if it is the last
node).

struct Node {

int data; // Data part

struct Node* next; // Pointer to the next node

};

4.What is a generalized linked list (GLL)? How does

it differ from a regular linked list?
 Ans- A Generalized Linked List (GLL) is a data structure that extends the concept of a
regular linked list by allowing its elements to be either atomic data (like integers or
characters) or other lists (sub-lists). This means that a GLL can represent hierarchical or
nested data structures, making it more flexible than a standard linked list.

Differences Between Generalized Linked Lists and Regular Linked Lists:

1. Element Types:
 Regular Linked List: Each node contains a single data item and a pointer to the next node. All
elements are of the same type (homogeneous).
 Generalized Linked List: Nodes can contain either atomic data or pointers to other lists,
allowing for heterogeneous data types and nested structures.

2. Structure Complexity:
 Regular Linked List: Represents a linear sequence of elements.
 Generalized Linked List: Can represent complex hierarchical relationships and nested lists,
making it suitable for more complex data representations.

3. Use Cases:
 Regular Linked List: Typically used for simple linear data structures like stacks, queues, or lists
where all elements are of the same type.
 Generalized Linked List: Useful in applications requiring the representation of more complex
data structures, such as symbolic expressions in Lisp, where lists can contain other lists.

5.How can polynomials be represented using linked

lists? Provide an example. Explain the process of
adding two polynomials represented as linked lists.
What are the advantages of using linked lists for
polynomial representation over arrays.
Ans- Polynomials can be effectively represented using linked lists, particularly when dealing with
sparse polynomials where many coefficients are zero. In this representation, each node of the
linked list typically contains two fields: one for the coefficient and another for the exponent of the
term. This allows for a flexible and efficient way to store polynomial terms without wasting
memory on zero coefficients.

Example of Polynomial Representation Using Linked Lists

Consider the polynomial P(x)=8x3+3x2+2x+6P(x)=8x3+3x2+2x+6 . This polynomial can be
represented using a linked list as follows:

 Each node in the linked list contains:

 coef : the coefficient of the term
 exp : the exponent of the term
 next : a pointer to the next node

The linked list representation of the polynomial P(x)P(x) would look like this:
 Head -> [coef: 8, exp: 3] -> [coef: 3, exp: 2] -> [coef: 2, exp: 1] -> [coef: 6, exp: 0] ->
NULL
Adding Two Polynomials Represented as Linked Lists
To add two polynomials represented as linked lists, we can follow these steps:

1. Initialize Pointers: Start with two pointers, one for each polynomial (let's call them p1 and p2 ),
and a pointer for the result polynomial ( result ).
2. Iterate Through Both Polynomials: Compare the exponents of the current terms pointed to
by p1 and p2 :
 If the exponents are equal, create a new node in the result with the sum of the coefficients and
the common exponent. Move both pointers to their respective next nodes.
 If the exponent of p1 is less than that of p2 , copy the term from p2 to the result and move
the p2 pointer.
 If the exponent of p1 is greater than that of p2 , copy the term from p1 to the result and move
the p1 pointer.

3. Handle Remaining Terms: Once one of the polynomials is fully traversed, append the
remaining terms of the other polynomial to the result.

4. Return the Result: The resulting linked list will represent the sum of the two polynomials.
Example of Adding Two Polynomials
Let’s say we have two polynomials:

 P1(x)=8x3+3x2+2x+6P1(x)=8x3+3x2+2x+6
 P2(x)=23x4+18x−3P2(x)=23x4+18x−3

Their linked list representations would be:

 P1P1: Head -> [8, 3] -> [3, 2] -> [2, 1] -> [6, 0] -> NULL
 P2P2: Head -> [23, 4] -> [18, 1] -> [-3, 0] -> NULL

Adding Process:

1. Start with p1 at 8x38x3 and p2 at 23x423x4.

2. Since 4>34>3 , add 23x423x4 to the result.
3. Move p2 to 18x118x1.
4. Now, 1<31<3, so add 2x2x from P1P1.
5. Continue this process until all terms are added.

The resulting polynomial will be:

 P(x)=23x4+8x3+3x2+20x+3P(x)=23x4+8x3+3x2+20x+3

Advantages of Using Linked Lists for Polynomial Representation Over

Arrays
1. Dynamic Size: Linked lists can grow and shrink dynamically, allowing for efficient memory
usage, especially for sparse polynomials where many coefficients might be zero.
2. Efficient Insertions/Deletions: Adding or removing terms in a polynomial can be done without
shifting elements, as would be necessary in an array. This is particularly useful when modifying
polynomials frequently.

3. Memory Efficiency: Linked lists only allocate memory for the terms that exist, avoiding the
waste associated with allocating a large array for a polynomial that may have many zero
coefficients.

4. Flexibility: Linked lists can easily represent polynomials of varying degrees without needing to
define a maximum size in advance, making them more adaptable to different polynomial forms.

6. What are the implications of using pointers in linked lists?

Discuss potential issues such as memory leaks.
Ans- Advantages of Using Pointers in Linked Lists
1. Dynamic Memory Allocation: Pointers allow linked lists to grow and shrink dynamically. Unlike
arrays, which require a fixed size, linked lists can allocate memory as needed, making them
suitable for applications where the number of elements is unpredictable.

2. Efficient Insertions and Deletions: Pointers facilitate efficient insertions and deletions of nodes
without the need to shift elements, as would be necessary in an array. This is particularly
beneficial for operations at arbitrary positions in the list.

3. Non-contiguous Memory Storage: Linked lists can store elements in non-contiguous memory
locations, which can lead to better memory utilization, especially for sparse data structures.
Potential Issues with Pointers in Linked Lists
1. Memory Leaks: One of the most significant issues associated with pointers in linked lists is the
potential for memory leaks. A memory leak occurs when allocated memory is not properly
deallocated after it is no longer needed. For example, if a node is removed from a linked list but
the memory allocated for that node is not freed, it remains allocated in the heap, leading to
wasted memory. Over time, this can accumulate and exhaust available memory, potentially
causing the program to crash or behave unpredictably.

2. Dangling Pointers: A dangling pointer arises when a pointer still references a memory location
that has been freed. If the program attempts to access or modify the data at that location, it can
lead to undefined behavior, crashes, or data corruption. This is particularly problematic in linked
lists where nodes are frequently added and removed.

3. Complexity of Memory Management: Managing memory manually with pointers can introduce
complexity and increase the likelihood of errors. Developers must ensure that every allocated
node is properly deallocated when it is no longer needed, which can be challenging in larger
applications.

4. Increased Risk of Bugs: The use of pointers can lead to bugs that are difficult to trace. For
instance, if a pointer is incorrectly updated or if multiple pointers reference the same node
without proper management, it can lead to inconsistencies in the linked list structure.

5. Performance Overhead: While linked lists provide flexibility, the overhead of managing pointers
can lead to performance issues, especially in scenarios where frequent allocations and
deallocations occur. This can result in fragmentation of memory, which may slow down the
program.
 7.What is dynamic memory management? How is it
related to linked lists? Explain the concept of
garbage collection in memory management.

Ans- Dynamic Memory Management

Dynamic memory management refers to the process of allocating and deallocating memory at
runtime, allowing programs to request memory as needed and release it when it is no longer
required. This flexibility is crucial for applications where the amount of data to be handled is
unpredictable, such as in linked lists, where the number of elements can vary significantly during
the program's execution.

In linked lists, dynamic memory management is particularly relevant because each node in a
linked list is typically allocated memory on the heap using functions like malloc() in C. This
allows linked lists to grow and shrink dynamically, accommodating varying amounts of data
without the need for a predefined size, as would be necessary with static data structures like
arrays.
Garbage Collection in Memory Management
Garbage collection is an automatic memory management feature that helps reclaim memory that
is no longer in use, preventing memory leaks and optimizing the use of available memory. In
programming environments that support garbage collection, the system automatically tracks
memory allocations and deallocations, identifying which objects are still reachable (i.e., can be
accessed by the program) and which are not.

The importance of garbage collection lies in its ability to manage memory efficiently without
requiring the programmer to manually free memory. This reduces the risk of memory leaks—
situations where allocated memory is not released, leading to wasted resources and potential
program crashes.

8. Describe the mark-and-sweep garbage collection

algorithm. Provide a case study on garbage collection
and its importance in programming.
Ans- Mark-and-Sweep Garbage Collection Algorithm
The mark-and-sweep algorithm is a common garbage collection technique that consists of two
main phases:

1. Mark Phase: In this phase, the garbage collector traverses all reachable objects in memory,
starting from a set of root references (such as global variables or stack variables). Each
reachable object is marked, typically by setting a flag or bit associated with the object to indicate
that it is still in use.

2. Sweep Phase: After marking, the garbage collector performs a second pass through the
memory. It identifies all objects that were not marked in the previous phase (i.e., those that are
no longer reachable) and deallocates their memory. This effectively "sweeps" away the
unreachable objects, freeing up memory for future allocations.
Case Study on Garbage Collection and Its Importance
Consider a scenario in a software application that manages a large number of user-generated
content, such as images or documents. As users upload and delete content, the application
 frequently allocates and deallocates memory for these objects. Without garbage collection, the
application would require the developers to manually manage memory, leading to potential
issues such as:

 Memory Leaks: If a user uploads and then deletes content, but the memory for the deleted
content is not properly freed, the application may gradually consume more memory over time,
leading to performance degradation or crashes.

 Dangling Pointers: If the application does not properly manage memory, pointers may
reference memory that has been freed, leading to undefined behavior when the application
attempts to access that memory.
By implementing garbage collection, the application can automatically reclaim memory that is no
longer in use, ensuring that resources are efficiently managed. This allows developers to focus
on the core functionality of the application without worrying about the intricacies of memory
management.

9. Represent P(x,y)=5x2+3xy+2y Using a GLL

1. ANS- The polynomial consists of three terms:
o 5x2: Coefficient 5, sublist [(x,2)]
o 3xy: Coefficient 3, sublist [(x,1),(y,1)]
o 2y: Coefficient 2, sublist [(y,1)]

Node Relationships:

 Head → [5,[(x,2]] → [3,[(x,1),(y,1)]]→ [2,[(y,1)]]→ NULL.

10. Represent A=(a,b,(c,(d,e),f),g) Using a GLL

ANS- Representation:

1. The main list has elements:

o Atomic elements: a,b,g
o A sublist: (c,(d,e),f)
2. The sublist (c,(d,e),f) contains:
o Atomic element c.
o Nested sublist (d,e)
o Atomic element f

Node Relationships:

 Head → [a] → [b] → Sublist → [g] → NULL.

 Sublist → [c] → Sublist → [f] → NULL.
 Nested Sublist → [d] → [e]→ NULL.

PSEUDOCODES:
  FOR SLL
1. Creation of a Linked List

 A linked list is created by allocating memory for the head node and initializing it. The head node
typically points to the first data node, which can be set to NULL if the list is empty.

Example Algorithm:

struct node {
int data;
struct node *next;
};
struct node *head = (struct node *)malloc(sizeof(struct node));
head->next = NULL; // Initialize as an empty list

Traversal

 Traversing a linked list involves visiting each node in the list, typically starting from the head node
and moving to the next node until the end of the list is reached.

Example Algorithm for Traversal:

void traverse(struct node *head) {

struct node *current = head;
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");
}

Searching

 Searching for a specific value in the linked list involves traversing the list and checking each
node's data until the desired value is found or the end of the list is reached.

Example Algorithm for Searching:

struct node* search(struct node *head, int key) {

struct node *current = head;
while (current != NULL) {
if (current->data == key) return current; // Return the node if found
current = current->next;
}
return NULL; // Return NULL if not found
}

Reversing the List

 Reversing a linked list involves changing the direction of the links so that the last node becomes
the first and vice versa.
 Example Algorithm for Reversing:

void reverse(struct node **head) {

struct node *prev = NULL;
struct node *current = *head;
struct node *next = NULL;
while (current != NULL) {
next = current->next; // Store next node
current->next = prev; // Reverse the link
prev = current; // Move prev and current one step forward
current = next;
}
*head = prev; // Update head to the new first node
}

Merging Two Linked Lists

 Two linked lists can be merged into a larger list while maintaining order.

Example Algorithm for Merging:

struct node* merge(struct node *list1, struct node *list2) {

struct node *merged = NULL;
struct node **lastPtrRef = &merged;

while (list1 != NULL && list2 != NULL) {

if (list1->data <= list2->data) {
*lastPtrRef = list1;
list1 = list1->next;
} else {
*lastPtrRef = list2;
list2 = list2->next;
}
lastPtrRef = &((*lastPtrRef)->next);
}
*lastPtrRef = (list1 == NULL) ? list2 : list1; // Append remaining nodes
return merged;
}

Insert Operation

Insert at the Beginning:

Algorithm InsertAtBeginning(*head, data)

{
// Allocate memory for new node
newNode = (struct node*)malloc(sizeof(struct node));
newNode->data = data; // Set data

// Point new node to the current head

newNode->next = *head;

// Update head to point to the new node

*head = newNode;
}

Insert at the End:

Algorithm InsertAtEnd(*head, data)
{
// Allocate memory for new node
newNode = (struct node*)malloc(sizeof(struct node));
newNode->data = data; // Set data
newNode->next = NULL; // New node will be the last node

if (*head == NULL) // If the list is empty

{
*head = newNode; // New node becomes the head
return;
}

// Traverse to the last node

curr = *head;
while (curr->next != NULL)
{
curr = curr->next;
}
curr->next = newNode; // Link the last node to the new node
}

Insert at a Specific Position:

Algorithm InsertAtPosition(*head, data, pos)

{
// Allocate memory for new node
newNode = (struct node*)malloc(sizeof(struct node));
newNode->data = data; // Set data

if (pos == 1) // Insert at the beginning

{
newNode->next = *head;
*head = newNode;
return;
}

// Traverse to the position before the desired position

curr = *head;
for (i = 1; i < pos - 1 && curr != NULL; i++)
{
curr = curr->next;
}

if (curr == NULL) // If the position is greater than the length

{
printf("Position is out of bounds\n");
return;
}

newNode->next = curr->next; // Link new node to the next node

curr->next = newNode; // Link previous node to the new node
}
Delete Operation

Delete from the Beginning:

Algorithm DeleteFromBeginning(*head)
{
if (*head == NULL) // If the list is empty
{
printf("List is empty\n");
return;
}

// Store the current head

temp = *head;
*head = (*head)->next; // Update head to the next node
free(temp); // Free the old head
}

Delete from the End:

Algorithm DeleteFromEnd(*head)
{
if (*head == NULL) // If the list is empty
{
printf("List is empty\n");
return;
}

if ((*head)->next == NULL) // If there's only one node

{
free(*head);
*head = NULL; // Update head to NULL
return;
}

// Traverse to the second last node

curr = *head;
while (curr->next->next != NULL)
{
curr = curr->next;
}

free(curr->next); // Free the last node

curr->next = NULL; // Set the next of second last node to NULL
}

Delete from a Specific Position:

Algorithm DeleteAtPosition(*head, pos)

{
if (*head == NULL) // If the list is empty
{
printf("List is empty\n");
return;
}

if (pos == 1) // Delete from the beginning

{
temp = *head;
*head = (*head)->next; // Update head
free(temp); // Free the old head
 return;
}

// Traverse to the node before the desired position

curr = *head;
for (i = 1; i < pos - 1 && curr != NULL; i++)
{
curr = curr->next;
}

if (curr == NULL || curr->next == NULL) // If position is out of bounds

{
printf("Position is out of bounds\n");
return;
}

// Store the node to be deleted

temp = curr->next;
curr->next = temp->next; // Link previous node to the next node
free(temp); // Free the deleted node
}

Sorting sll using pointers:

Algorithm sort(*H){
len=len(H);
for i=1 to len-1 {
prev=H; curr=H->next;
for j=0 to next
if(curr->data > temp->data {
prev->next=temp;
curr->next=temp->next;
temp->next=curr;
prev=temp;
} else {
prev=curr; curr=curr->next;
}
} //end for inner for
} //end for outer for
} //end Algorithm

 FOR DLL:
Algorithm to Create a Node in a Doubly Linked List (DLL)
Algorithm CreateNode(data)
Allocate memory for newNode
newNode->data = data
newNode->next = NULL
newNode->prev = NULL
Return newNode
End Algorithm
Insert Operation
Insert at the Beginning:

Algorithm InsertAtBeginning(*head, data)

{
// Allocate memory for new node
newNode = (struct node*)malloc(sizeof(struct node));
newNode->data = data; // Set data

newNode->next = *head; // Point new node to the current head

if (*head != NULL) // If the list is not empty

{
(*head)->prev = newNode; // Update the previous head's prev pointer
}
newNode->prev = NULL; // New node will be the first node
*head = newNode; // Update head to the new node
}
Insert at the End:

Algorithm InsertAtEnd(*head, data)

{
// Allocate memory for new node
newNode = (struct node*)malloc(sizeof(struct node));
newNode->data = data; // Set data
newNode->next = NULL; // New node will be the last node

if (*head == NULL) // If the list is empty

{
newNode->prev = NULL; // New node will be the first node
*head = newNode; // Update head to the new node
return;
}

// Traverse to the last node

curr = *head;
while (curr->next != NULL)
{
curr = curr->next;
}

curr->next = newNode; // Link the last node to the new node

newNode->prev = curr; // Link new node's prev to the last node
}
Insert at a Specific Position:

Algorithm InsertAtPosition(*head, data, pos)

{
// Allocate memory for new node
newNode = (struct node*)malloc(sizeof(struct node));
newNode->data = data; // Set data

if (pos == 1) // Insert at the beginning

{
newNode->next = *head;
newNode->prev = NULL;
if (*head != NULL)
{
(*head)->prev = newNode;
}
*head = newNode;
return;
}
 // Traverse to the position before the desired position
curr = *head;
for (i = 1; i < pos - 1 && curr != NULL; i++)
{
curr = curr->next;
}

if (curr == NULL) // If the position is greater than the length

{
printf("Position is out of bounds\n");
return;
}

newNode->next = curr->next; // Link new node to the next node

newNode->prev = curr; // Link new node's prev to current node

if (curr->next != NULL) // If not inserting at the end

{
curr->next->prev = newNode; // Link next node's prev to new node
}
curr->next = newNode; // Link current node to new node
}

Delete Operation

Delete from the Beginning:

Algorithm DeleteFromBeginning(*head)
{
if (*head == NULL) // If the list is empty
{
printf("List is empty\n");
return;
}

// Store the current head

temp = *head;
*head = (*head)->next; // Update head to the next node

if (*head != NULL) // If the list is not empty after deletion

{
(*head)->prev = NULL; // Update the new head's prev pointer
}
free(temp); // Free the old head
}

Delete from the End:

Algorithm DeleteFromEnd(*head)
{
if (*head == NULL) // If the list is empty
{
printf("List is empty\n");
return;
}

if ((*head)->next == NULL) // If there's only one node

{
free(*head);
*head = NULL; // Update head to NULL
 return;
}

// Traverse to the second last node

curr = *head;
while (curr->next != NULL)
{
curr = curr->next;
}

curr->prev->next = NULL; // Set the next of second last node to NULL

free(curr); // Free the last node
}

Algorithm to Delete a Node from a Specific Position in a Doubly Linked List

Algorithm DeleteNodeByPosition(head, pos)
// Check if the list is empty
If head is NULL
Print "List is empty"
Return

// Initialize pointers
curr = head->next // Start from the first node
prev = head // Pointer to the previous node
count = 1 // Position counter

// Traverse the list to find the node at the specified position

While curr is not NULL AND count < pos
prev = curr
curr = curr->next
count = count + 1

// If the position is greater than the number of nodes

If curr is NULL
Print "Position exceeds the length of the list"
Return

// If the node to be deleted is the head node

If count == 1
head->next = curr->next
If curr->next is not NULL
curr->next->prev = head
free(curr)
Return

// If the node to be deleted is not the head node

prev->next = curr->next
If curr->next is not NULL
curr->next->prev = prev

// Free the memory of the deleted node

free(curr)
End Algorithm

 DCLL:
Algorithm to Create a Doubly Circular Linked List (DCLL)
Algorithm CreateDCLL(head)
Allocate memory for head node
head->next = head
 head->prev = head
temp = head
Repeat until choice = 'y'
Allocate memory for curr
Accept curr->data
curr->next = head
curr->prev = temp
temp->next = curr
temp = curr
End Repeat
End Algorithm

Algorithm to Display a Doubly Circular Linked List (DCLL):

Display_forward(Head) {
temp=head->next;
while(temp!=head) {
print temp->data;
temp=temp->next;
}
Display_backward(Head) {
temp=head->prev;
while(temp!=head) {
print temp->data;
temp=temp->prev;
}

Algorithm to Add a Node in a Doubly Circular Linked List (DCLL)

Algorithm AddNodeDCLL(head, data, pos)
len = LengthDCLL(head)
curr = Allocate memory for newNode
newNode->data = data
newNode->next = NULL
newNode->prev = NULL

If pos > len + 1

Print "Not possible to add"
Return
End If

If pos == 1
newNode->next = head->next
newNode->prev = head
head->next->prev = newNode
head->next = newNode
Else
count = 1
prevptr = head
temp = head->next
While temp != head && count != pos
prevptr = temp
temp = temp->next
count++
End While
prevptr->next = newNode
newNode->prev = prevptr
 newNode->next = temp
temp->prev = newNode
End If
End Algorithm

Algorithm to Delete a Node from a Doubly Circular Linked List (DCLL)

Algorithm DeleteNodeDCLL(head, pos)
len = LengthDCLL(head)
If pos > len
Print "Not possible to delete"
Return
End If

temp = head->next
count = 1
While temp != head && count != pos
prevptr = temp
temp = temp->next
count++
End While

prevptr->next = temp->next
temp->next->prev = prevptr
free(temp)
End Algorithm

 POLYNOMIALS: ADDITION, EVALUATION

Node Structure for Polynomial
struct polyNode {
int coef; // Coefficient
int exp; // Exponent
struct polyNode *next;
};

Algorithm for Polynomial Addition

Algorithm AddPolynomials(H1, H2, H3)
Allocate memory for H3
H3->next = NULL
t1 = H1->next
t2 = H2->next
t3 = H3

While t1 != NULL OR t2 != NULL

If t1->exp == t2->exp
Allocate memory for newNode
newNode->coef = t1->coef + t2->coef
newNode->exp = t1->exp
t3->next = newNode
t3 = newNode
t1 = t1->next
t2 = t2->next
Else If t1->exp < t2->exp
Allocate memory for newNode
newNode->coef = t2->coef
newNode->exp = t2->exp
 t3->next = newNode
t3 = newNode
t2 = t2->next
Else
Allocate memory for newNode
newNode->coef = t1->coef
newNode->exp = t1->exp
t3->next = newNode
t3 = newNode
t1 = t1->next
End If
End While
End Algorithm

Algorithm for Evaluating a Polynomial

Algorithm EvaluatePolynomial(H, x)
cur = H->next
sum = 0
While cur != NULL
sum = sum + (cur->coef * (x ^ cur->exp))
cur = cur->next
End While
Print sum
End Algorithm