Docsity
Log inSign up
Docsity
Prepare for your exams
Prepare for your exams

Study with the several resources on Docsity

Earn points to download
Earn points to download

Earn points by helping other students or get them with a premium plan

Guidelines and tips
Guidelines and tips
Sell on Docsity
Sell on Docsity
Log inSign up

Prepare for your exams

Study with the several resources on Docsity

Find documents

Prepare for your exams with the study notes shared by other students like you on Docsity

Search Store documents

The best documents sold by students who completed their studies

Search through all study resources
Docsity AINEW

Summarize your documents, ask them questions, convert them into quizzes and concept maps

Explore questions

Clear up your doubts by reading the answers to questions asked by your fellow students

Earn points to download

Earn points by helping other students or get them with a premium plan

Share documents
download point icon20 Points

For each uploaded document

Answer questions
download point icon5 Points

For each given answer (max 1 per day)

All the ways to get free points
Get points immediately

Choose a premium plan with all the points you need

Study Opportunities

Choose your next study program

Get in touch with the best universities in the world. Search through thousands of universities and official partners

Community

Ask the community

Ask the community for help and clear up your study doubts

University Rankings

Discover the best universities in your country according to Docsity users

Free resources

Our save-the-student-ebooks!

Download our free guides on studying techniques, anxiety management strategies, and thesis advice from Docsity tutors

From our blog

Exams and Study
Go to the blog

Data Structures and Algorithms: Implementation in C, Schemes and Mind Maps of Data Structures and Algorithms

Dr. A.P.J. Abdul Kalam Technical UniversityData Structures and Algorithms

A comprehensive collection of c programming examples demonstrating the implementation of various data structures, including stacks, queues, linked lists, and arrays. It covers fundamental operations like insertion, deletion, traversal, and searching, along with sorting algorithms such as bubble sort, selection sort, insertion sort, and quick sort. Valuable for students learning data structures and algorithms in c, offering practical code examples and explanations.

Typology: Schemes and Mind Maps

2023/2024

Uploaded on 01/07/2025

yash-raj-31
yash-raj-31 šŸ‡®šŸ‡³

1 document

1 / 57

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
P a g e | 1
Experiment: 1
WAP for implementation of stack using Array.
1. #include <stdio.h>
2. #define MAX 5
3.
4. int stack[MAX];
5. int top = -1;
6.
7. int isFull() {
8. return top == MAX - 1;
9. }
10.
11. int isEmpty() {
12. return top == -1;
13. }
14.
15. void push(int value) {
16. if (isFull()) {
17. printf("Stack Overflow\n");
18. } else {
19. stack[++top] = value;
20. }
21. }
22.
23. int pop() {
24. if (isEmpty()) {
25. printf("Stack Underflow\n");
26. return -1;
27. } else {
28. return stack[top--];
29. }
30. }
31.
32. int peek() {
33. if (isEmpty()) {
34. printf("Stack is empty\n");
35. return -1;
36. } else {
37. return stack[top];
38. }
39. }
40.
41. void display() {
42. if (isEmpty()) {
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e
pf1f
pf20
pf21
pf22
pf23
pf24
pf25
pf26
pf27
pf28
pf29
pf2a
pf2b
pf2c
pf2d
pf2e
pf2f
pf30
pf31
pf32
pf33
pf34
pf35
pf36
pf37
pf38
pf39

Partial preview of the text

Download Data Structures and Algorithms: Implementation in C and more Schemes and Mind Maps Data Structures and Algorithms in PDF only on Docsity!

Experiment: 1

WAP for implementation of stack using Array.

  1. #include <stdio.h>
  2. #define MAX 5
  4. int stack[MAX];
  5. int top = -1;
  7. int isFull() {
  8. return top == MAX - 1;
  9. }
  11. int isEmpty() {
  12. return top == -1;
  13. }
  15. void push(int value) {
  16. if (isFull()) {
  17. printf("Stack Overflow\n");
  18. } else {
  19. stack[++top] = value;
  20. }
  21. }
  23. int pop() {
  24. if (isEmpty()) {
  25. printf("Stack Underflow\n");
  26. return -1;
  27. } else {
  28. return stack[top--];
  29. }
  30. }
  32. int peek() {
  33. if (isEmpty()) {
  34. printf("Stack is empty\n");
  35. return -1;
  36. } else {
  37. return stack[top];
  38. }
  39. }
  41. void display() {
  42. if (isEmpty()) {
  1. printf("Stack is empty\n");
  2. } else {
  3. printf("Stack elements are:\n");
  4. for (int i = 0; i <= top; i++) {
  5. printf("%d ", stack[i]);
  6. }
  7. printf("\n");
  8. }
  9. }
  11. int main() {
  12. push(10);
  13. push(20);
  14. push(30);
  15. display();
  16. printf("Top element is %d\n", peek());
  17. printf("Popped element is %d\n", pop());
  18. display();
  20. return 0;
  21. }

Experiment: 2

WAP for implementation of Queue using Array.

  1. #include <stdio.h>
  2. #define MAX 5
  4. int queue[MAX];
  5. int front = -1;
  6. int rear = -1;
  8. int isFull() {
  9. return (rear + 1) % MAX == front;
  10. }
  12. int isEmpty() {
  13. return front == -1;
  14. }
  16. void enqueue(int value) {
  17. if (isFull()) {
  18. printf("Queue Overflow\n");
  19. } else {
  20. if (front == -1) {
  21. front = 0;
  22. }
  23. rear = (rear + 1) % MAX;
  24. queue[rear] = value;
  25. }
  26. }
  27. int dequeue() {
  28. if (isEmpty()) {
  29. printf("Queue Underflow\n");
  30. return -1;
  31. } else {
  32. int value = queue[front];
  33. if (front == rear) {
  1. front = rear = -1;
  2. } else {
  3. front = (front + 1) % MAX;
  4. }
  5. return value;
  6. }
  7. }
  8. int peek() {
  9. if (isEmpty()) {
  10. printf("Queue is empty\n");
  11. return -1;
  12. } else {
  13. return queue[front];
  14. }
  15. }
  16. void display() {
  17. if (isEmpty()) {
  18. printf("Queue is empty\n");
  19. } else {
  20. printf("Queue elements are:\n");
  21. int i;
  22. for (i = front; i != rear; i = (i + 1) % MAX) {
  23. printf("%d ", queue[i]);
  24. }
  25. printf("%d\n", queue[i]);
  26. }
  27. }
  28. int main() {
  29. enqueue(10);
  30. enqueue(20);
  31. enqueue(30);
  32. display();
  33. printf("Front element is %d\n", peek());
  34. printf("Dequeued element is %d\n", dequeue());
  35. display();
  36. return 0;
  37. }

Experiment: 3

WAP for implementation of stack using Linked list.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. struct Node {
  5. int data;
  6. struct Node* next;
  7. };
  9. struct Node* top = NULL;
  11. int isEmpty() {
  12. return top == NULL;
  13. }
  15. void push(int value) {
  16. struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
  17. if (newNode == NULL) {
  18. printf("Stack Overflow\n");
  19. } else {
  20. newNode->data = value;
  21. newNode->next = top;
  22. top = newNode;
  23. }
  24. }
  25. int pop() {
  26. if (isEmpty()) {
  27. printf("Stack Underflow\n");
  28. return -1;
  29. } else {
  30. struct Node* temp = top;
  31. int value = temp->data;
  32. top = top->next;
  33. free(temp);
  1. return value;
  2. }
  3. }
  5. int peek() {
  6. if (isEmpty()) {
  7. printf("Stack is empty\n");
  8. return -1;
  9. } else {
  10. return top->data;
  11. }
  12. }
  14. void display() {
  15. if (isEmpty()) {
  16. printf("Stack is empty\n");
  17. } else {
  18. struct Node* temp = top;
  19. printf("Stack elements are:\n");
  20. while (temp != NULL) {
  21. printf("%d ", temp->data);
  22. temp = temp->next;
  23. }
  24. printf("\n");
  25. }
  26. }
  28. int main() {
  29. push(11);
  30. push(21);
  31. push(30);
  32. display();
  33. printf("Top element is %d\n", peek());
  34. printf("Popped element is %d\n", pop());
  35. display();
  37. return 0;
  38. }

Experiment: 4

WAP for creation and implementation of linked list.

  1. #include <stdio.h>

  2. #include <stdlib.h>

  4. // Define a node structure

  5. struct Node {

  6. int data;

  7. struct Node* next;

  8. };

  10. // Function to create a new node

  11. struct Node* createNode(int data) {

  12. struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

  13. if (!newNode) {

  14. printf("Memory allocation failed\n");

  15. exit(1);

  16. }

  17. newNode->data = data;

  18. newNode->next = NULL;

  19. return newNode;

  20. }

  22. // Function to insert a node at the beginning of the linked list

  23. void insertAtBeginning(struct Node** head, int data) {

  24. struct Node* newNode = createNode(data);

  25. newNode->next = *head;

  26. *head = newNode;

  27. }

  29. // Function to print the linked list

  30. void printList(struct Node* head) {

  31. struct Node* temp = head;

  32. while (temp != NULL) {

  33. printf("%d -> ", temp->data);

  34. temp = temp->next;

  35. }

  36. printf("NULL\n");

  37. }

  39. // Function to free the linked list memory

  40. void freeList(struct Node* head) {

  41. struct Node* temp;

  42. while (head != NULL) {

  43. temp = head;

  44. head = head->next;

  45. free(temp);

  46. }

  47. }

  49. int main() {

  50. struct Node* head = NULL;

  52. // Insert elements into the linked list

  53. insertAtBeginning(&head, 3);

  54. insertAtBeginning(&head, 2);

  55. insertAtBeginning(&head, 1);

  57. // Print the linked list

  58. printList(head);

  60. // Free the linked list memory

  61. freeList(head);

  63. return 0;

  64. }

Experiment:

WAP for insertion in singly linked list from beginning, end

any position.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. // Define a node structure
  5. struct Node {
  6. int data;
  7. struct Node* next;
  8. };
  10. // Function to create a new node
  11. struct Node* createNode(int data) {
  12. struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
  13. if (!newNode) {
  14. printf("Memory allocation failed\n");
  15. exit(1);
  16. }
  17. newNode->data = data;
  18. newNode->next = NULL;
  19. return newNode;
  20. }
  22. // Function to insert a node at the beginning of the linked list
  23. void insertAtBeginning(struct Node** head, int data) {
  24. struct Node* newNode = createNode(data);
  25. newNode->next = *head;
  26. *head = newNode;
  27. }
  29. // Function to insert a node at the end of the linked list
  30. void insertAtEnd(struct Node** head, int data) {
  31. struct Node* newNode = createNode(data);
  32. if (*head == NULL) {
  33. *head = newNode;
  34. } else {
  35. struct Node* temp = *head;
  36. while (temp->next != NULL) {
  1. temp = temp->next;
  2. }
  3. temp->next = newNode;
  4. }
  5. }
  7. // Function to insert a node at a given position in the linked list
  8. void insertAtPosition(struct Node** head, int data, int position) {
  9. struct Node* newNode = createNode(data);
  10. if (position == 1) {
  11. newNode->next = *head;
  12. *head = newNode;
  13. return;
  14. }
  15. struct Node* temp = *head;
  16. for (int i = 1; i < position - 1 && temp != NULL; i++) {
  17. temp = temp->next;
  18. }
  19. if (temp == NULL) {
  20. printf("Position out of bounds\n");
  21. free(newNode);
  22. } else {
  23. newNode->next = temp->next;
  24. temp->next = newNode;
  25. }
  26. }
  28. // Function to print the linked list
  29. void printList(struct Node* head) {
  30. struct Node* temp = head;
  31. while (temp != NULL) {
  32. printf("%d -> ", temp->data);
  33. temp = temp->next;
  34. }
  35. printf("NULL\n");
  36. }
  38. // Function to free the linked list memory
  39. void freeList(struct Node* head) {
  40. struct Node* temp;
  41. while (head != NULL) {
  42. temp = head;
  43. head = head->next;
  44. free(temp);

Output:

Experiment: 6

WAP for creation and implementation of doubly linked list.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. // Define a node structure
  5. struct Node {
  6. int data;
  7. struct Node* next;
  8. struct Node* prev;
  9. };
  11. // Function to create a new node
  12. struct Node* createNode(int data) {
  13. struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
  14. if (!newNode) {
  15. printf("Memory allocation failed\n");
  16. exit(1);
  17. }
  18. newNode->data = data;
  19. newNode->next = NULL;
  20. newNode->prev = NULL;
  21. return newNode;
  22. }
  24. // Function to insert a node at the beginning of the doubly linked list
  25. void insertAtBeginning(struct Node** head, int data) {
  26. struct Node* newNode = createNode(data);
  27. if (*head != NULL) {
  28. (*head)->prev = newNode;
  29. }
  30. newNode->next = *head;
  31. *head = newNode;
  32. }
  34. // Function to insert a node at the end of the doubly linked list
  35. void insertAtEnd(struct Node** head, int data) {
  36. struct Node* newNode = createNode(data);
  37. if (*head == NULL) {
  38. *head = newNode;

Output:

Experiment: 7

WAP to search an element using linear search.

  1. #include <stdio.h>
  3. // Function to perform linear search
  4. int linearSearch(int arr[], int size, int target) {
  5. for (int i = 0; i < size; i++) {
  6. if (arr[i] == target) {
  7. return i; // Return the index of the target element
  8. }
  9. }
  10. return -1; // Return -1 if the target element is not found
  11. }
  13. int main() {
  14. int arr[] = {10, 20, 30, 40, 50};
  15. int size = sizeof(arr) / sizeof(arr[0]);
  16. int target = 30;
  18. int result = linearSearch(arr, size, target);
  20. if (result != -1) {
  21. printf("Element %d found at index %d\n", target, result);
  22. } else {
  23. printf("Element %d not found in the array\n", target);
  24. }
  26. return 0;
  27. }