#include <stdio.
h>
#include <stdlib.h>
int main()
int item , i = 0;
int a[5]={34,56,32,78,12};
printf("enter serching item");
scanf ("%d", &item);
while (i<5)
if (a[i] == item)
printf ("item found at %d", i);
exit (0);
++i;
printf("Item nof found");
exit (0);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
void printList(struct Node* head) {
struct Node* temp = head;
while (temp != NULL) {
printf("%d -> ", temp->data);
temp = temp->next;
printf("NULL\n");
struct Node* findMiddle(struct Node* head) {
if (head == NULL) return head;
struct Node* slow = head;
struct Node* fast = head->next;
while (fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
return slow;
struct Node* merge(struct Node* left, struct Node* right) {
if (left == NULL) return right;
if (right == NULL) return left;
struct Node* result = NULL;
if (left->data <= right->data) {
result = left;
result->next = merge(left->next, right);
} else {
result = right;
result->next = merge(left, right->next);
return result;
struct Node* mergeSort(struct Node* head) {
if (head == NULL || head->next == NULL) {
return head;
}
struct Node* middle = findMiddle(head);
struct Node* nextOfMiddle = middle->next;
middle->next = NULL;
struct Node* left = mergeSort(head);
struct Node* right = mergeSort(nextOfMiddle);
return merge(left, right);
void insertAtEnd(struct Node** headRef, int data) {
struct Node* newNode = createNode(data);
if (*headRef == NULL) {
*headRef = newNode;
return;
struct Node* temp = *headRef;
while (temp->next != NULL) {
temp = temp->next;
temp->next = newNode;
}
int main() {
struct Node* head = NULL;
insertAtEnd(&head, 4);
insertAtEnd(&head, 2);
insertAtEnd(&head, 8);
insertAtEnd(&head, 1);
insertAtEnd(&head, 6);
printf("Original list: ");
printList(head);
head = mergeSort(head);
printf("Sorted list: ");
printList(head);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
void printList(struct Node* head) {
struct Node* temp = head;
while (temp != NULL) {
printf("%d -> ", temp->data);
temp = temp->next;
printf("NULL\n");
struct Node* findMiddle(struct Node* head) {
if (head == NULL) return head;
struct Node* slow = head;
struct Node* fast = head->next;
while (fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
return slow;
struct Node* merge(struct Node* left, struct Node* right) {
if (left == NULL) return right;
if (right == NULL) return left;
struct Node* result = NULL;
if (left->data <= right->data) {
result = left;
result->next = merge(left->next, right);
} else {
result = right;
result->next = merge(left, right->next);
return result;
struct Node* mergeSort(struct Node* head) {
if (head == NULL || head->next == NULL) {
return head;
}
struct Node* middle = findMiddle(head);
struct Node* nextOfMiddle = middle->next;
middle->next = NULL;
struct Node* left = mergeSort(head);
struct Node* right = mergeSort(nextOfMiddle);
return merge(left, right);
void insertAtEnd(struct Node** headRef, int data) {
struct Node* newNode = createNode(data);
if (*headRef == NULL) {
*headRef = newNode;
return;
struct Node* temp = *headRef;
while (temp->next != NULL) {
temp = temp->next;
temp->next = newNode;
}
int main() {
struct Node* head = NULL;
insertAtEnd(&head, 4);
insertAtEnd(&head, 2);
insertAtEnd(&head, 8);
insertAtEnd(&head, 1);
insertAtEnd(&head, 6);
printf("Original list: ");
printList(head);
head = mergeSort(head);
printf("Sorted list: ");
printList(head);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
typedef struct {
int items[MAX_SIZE];
int front;
int rear;
} Queue;
Queue* createQueue() {
Queue* q = (Queue*)malloc(sizeof(Queue));
q->front = -1;
q->rear = -1;
return q;
int isEmpty(Queue* q) {
return q->rear == -1;
int isFull(Queue* q) {
return q->rear == MAX_SIZE - 1;
void enqueue(Queue* q, int value) {
if (isFull(q)) {
printf("Queue is full\n");
} else {
if (q->front == -1) {
q->front = 0;
q->rear++;
q->items[q->rear] = value;
int dequeue(Queue* q) {
int item;
if (isEmpty(q)) {
printf("Queue is empty\n");
item = -1;
} else {
item = q->items[q->front];
q->front++;
if (q->front > q->rear) {
q->front = q->rear = -1;
return item;
void reverse_queue(Queue* q) {
int temp[MAX_SIZE];
int top = -1;
while (!isEmpty(q)) {
temp[++top] = dequeue(q);
while (top != -1) {
enqueue(q, temp[top--]);
}
void display(Queue* q) {
if (isEmpty(q)) {
printf("Queue is empty\n");
} else {
for (int i = q->front; i <= q->rear; i++) {
printf("%d ", q->items[i]);
printf("\n");
int main() {
Queue* q = createQueue();
enqueue(q, 1);
enqueue(q, 2);
enqueue(q, 3);
enqueue(q, 4);
enqueue(q, 5);
printf("Queue elements are:\n");
display(q);
printf("Reverse Queue, elements are:\n");
reverse_queue(q);
display(q);
enqueue(q, 100);
enqueue(q, 200);
printf("Add two elements to the said queue:\n");
printf("Queue elements are:\n");
display(q);
printf("Reverse Queue, elements are:\n");
reverse_queue(q);
display(q);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#define MAX 100 // Maximum size of the stack
// Stack structure definition
typedef struct Stack {
int data[MAX];
int top;
} Stack;
// Stack operations function prototypes
void init(Stack* s);
int isEmpty(Stack* s);
int isFull(Stack* s);
void push(Stack* s, int value);
int pop(Stack* s);
int peek(Stack* s);
// Initialize the stack
void init(Stack* s) {
s->top = -1;
// Check if the stack is empty
int isEmpty(Stack* s) {
return s->top == -1;
// Check if the stack is full
int isFull(Stack* s) {
return s->top == MAX - 1;
// Push an element onto the stack
void push(Stack* s, int value) {
if (isFull(s)) {
printf("Stack overflow\n");
return;
s->data[++(s->top)] = value;
// Pop an element from the stack
int pop(Stack* s) {
if (isEmpty(s)) {
printf("Stack underflow\n");
return -1;
return s->data[(s->top)--];
// Peek at the top element of the stack without popping it
int peek(Stack* s) {
if (isEmpty(s)) {
printf("Stack is empty\n");
return -1;
return s->data[s->top];
// Function to copy the contents of one stack into another, preserving order
void copyStack(Stack* source, Stack* dest) {
Stack temp;
init(&temp);
// Step 1: Pop elements from the source stack and push them into a temporary stack
while (!isEmpty(source)) {
push(&temp, pop(source));
// Step 2: Pop elements from the temporary stack, push them back into source and into the
destination stack
while (!isEmpty(&temp)) {
int value = pop(&temp);
push(source, value); // Restore the original stack
push(dest, value); // Copy to the destination stack
// Main function to demonstrate the program
int main() {
Stack source, dest;
init(&source);
init(&dest);
// Example data for the source stack
push(&source, 10);
push(&source, 20);
push(&source, 30);
// Copy the contents of the source stack to the destination stack
copyStack(&source, &dest);
// Display the contents of the source stack
printf("Source stack after copying:\n");
while (!isEmpty(&source)) {
printf("%d\n", pop(&source));
// Display the contents of the destination stack
printf("Destination stack:\n");
while (!isEmpty(&dest)) {
printf("%d\n", pop(&dest));
return 0;
