0% found this document useful (0 votes)
69 views4 pages

C++ Singly Linked List Operations

The document contains C++ code for implementing various operations on a singly linked list such as insertion, deletion, searching, and sorting of nodes. It includes functions to insert a node at the beginning, after a given node, and at the end of the linked list. The main function demonstrates inserting several nodes and printing the list before and after deleting a node.

Uploaded by

Rei Cembrano
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
69 views4 pages

C++ Singly Linked List Operations

The document contains C++ code for implementing various operations on a singly linked list such as insertion, deletion, searching, and sorting of nodes. It includes functions to insert a node at the beginning, after a given node, and at the end of the linked list. The main function demonstrates inserting several nodes and printing the list before and after deleting a node.

Uploaded by

Rei Cembrano
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 4

Cembrano, Stephanie Rei Allana S.

DICT 2-1

QUIZ 1

#include <stdlib.h>
#include <iostream>
using namespace std;

struct Node {
int data;
struct Node* next;
};

void insertAtBeginning(struct Node** head_ref, int new_data) {


struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}

void insertAfter(struct Node* prev_node, int new_data) {


if (prev_node == NULL) {
cout << "the given previous node cannot be NULL";
return;
}

struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));


new_node->data = new_data;
new_node->next = prev_node->next;
prev_node->next = new_node;
}

void insertAtEnd(struct Node** head_ref, int new_data) {


struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));

struct Node* last = *head_ref;

new_node->data = new_data;
new_node->next = NULL;

if (*head_ref == NULL) {
*head_ref = new_node;
return;
}

while (last->next != NULL) last = last->next;

last->next = new_node;
return;
}

void deleteNode(struct Node** head_ref, int key) {


struct Node *temp = *head_ref, *prev;

if (temp != NULL && temp->data == key) {


*head_ref = temp->next;
free(temp);
return;
}

while (temp != NULL && temp->data != key) {


prev = temp;
temp = temp->next;
}

if (temp == NULL) return;

prev->next = temp->next;

free(temp);
}

bool searchNode(struct Node** head_ref, int key) {


struct Node* current = *head_ref;

while (current != NULL) {


if (current->data == key) return true;
current = current->next;
}
return false;
}

void sortLinkedList(struct Node** head_ref) {


struct Node *current = *head_ref, *index = NULL;
int temp;

if (head_ref == NULL) {
return;
} else {
while (current != NULL) {
index = current->next;

while (index != NULL) {


if (current->data > index->data) {
temp = current->data;
current->data = index->data;
index->data = temp;
}
index = index->next;
}
current = current->next;
}
}
}
void printList(struct Node* node) {
while (node != NULL) {
cout << node->data << " ";
node = node->next;
}
}

int main() {
struct Node* head = NULL;

insertAtEnd(&head, 1);
insertAtBeginning(&head, 2);
insertAtBeginning(&head, 3);
insertAtEnd(&head, 4);
insertAfter(head->next, 5);

cout << "Linked list: ";


printList(head); 1

cout << "\nAfter deleting an element: ";


deleteNode(&head, 3);
printList(head); 2
}

OUTPUT AT 1. __3 2 5 1 4______________________

OUTPUT AT 2. __2 5 1 4______________________

3. Create C++ program (singly linked list) using array with the same data/parameters as above.

#include <bits/stdc++.h>
#include <iostream>
using namespace std;

class Node {
public:
int value;
Node* next;
};

int main() {
Node* head;
Node* one = NULL;
Node* two = NULL;
Node* three = NULL;
Node* four = NULL;
Node* five = NULL;

one = new Node();


two = new Node();
three = new Node();
four = new Node();
five = new Node();

one->value = 3;
two->value = 2;
three->value = 5;
four->value = 1;
five->value = 4;

one->next = two;
two->next = three;
three->next = four;
four->next = five;
five->next = NULL;

head = one;
while (head != NULL) {
cout << head->value;
head = head->next;
}
}

You might also like