স্ট্যাক হল একটি ডেটা স্ট্রাকচার যা LIFO (Last In, First Out) পদ্ধতির উপর কাজ করে, অর্থাৎ শেষ দিকে যুক্ত করা উপাদানটি প্রথমে অপসারণ করা হয়। স্ট্যাকের মধ্যে একটি উপাদান ইনসার্ট (Push) এবং অপসারণ (Pop) করার জন্য দুটি প্রধান অপারেশন রয়েছে।
নিচে C প্রোগ্রামিং ভাষায় স্ট্যাকের ধারণা, অপারেশন, এবং উদাহরণসহ আলোচনা করা হলো।
১. স্ট্যাকের ধারণা
স্ট্যাক একটি সুশৃঙ্খল ডেটা স্ট্রাকচার যা সাধারণত অ্যারে বা লিঙ্কড লিস্ট ব্যবহার করে বাস্তবায়িত হয়। স্ট্যাকের প্রধান দুটি অপারেশন হল:
- Push: স্ট্যাকের শীর্ষে একটি নতুন উপাদান যুক্ত করা।
- Pop: স্ট্যাকের শীর্ষ থেকে একটি উপাদান অপসারণ করা।
২. স্ট্যাকের মৌলিক গঠন
স্ট্যাকের একটি সাধারণ গঠন নিচে দেওয়া হলো:
#include <stdio.h>
#include <stdlib.h>
#define MAX 100 // Maximum size of stack
struct Stack {
int items[MAX]; // Array to hold stack elements
int top; // Index of the top element
};
৩. স্ট্যাকের অপারেশন
৩.১ স্ট্যাক তৈরি এবং ইনিশিয়ালাইজেশন
void initStack(struct Stack* s) {
s->top = -1; // Initialize top to -1, indicating the stack is empty
}
৩.২ স্ট্যাকে উপাদান যোগ করা (Push)
int isFull(struct Stack* s) {
return s->top == MAX - 1; // Check if the stack is full
}
void push(struct Stack* s, int value) {
if (isFull(s)) {
printf("Stack Overflow! Cannot push %d\n", value);
} else {
s->items[++(s->top)] = value; // Increment top and add the new value
printf("%d pushed to stack\n", value);
}
}
৩.৩ স্ট্যাক থেকে উপাদান অপসারণ করা (Pop)
int isEmpty(struct Stack* s) {
return s->top == -1; // Check if the stack is empty
}
int pop(struct Stack* s) {
if (isEmpty(s)) {
printf("Stack Underflow! Cannot pop\n");
return -1; // Return -1 to indicate underflow
} else {
return s->items[(s->top)--]; // Return top value and decrement top
}
}
৩.৪ স্ট্যাকের শীর্ষ উপাদান দেখা (Peek)
int peek(struct Stack* s) {
if (isEmpty(s)) {
printf("Stack is empty! No top element\n");
return -1; // Return -1 to indicate empty stack
} else {
return s->items[s->top]; // Return the top value
}
}
৪. উদাহরণ প্রোগ্রাম
#include <stdio.h>
#include <stdlib.h>
#define MAX 100 // Maximum size of stack
struct Stack {
int items[MAX]; // Array to hold stack elements
int top; // Index of the top element
};
// Function to initialize the stack
void initStack(struct Stack* s) {
s->top = -1; // Stack is initially empty
}
// Function to check if the stack is full
int isFull(struct Stack* s) {
return s->top == MAX - 1;
}
// Function to check if the stack is empty
int isEmpty(struct Stack* s) {
return s->top == -1;
}
// Function to push an element onto the stack
void push(struct Stack* s, int value) {
if (isFull(s)) {
printf("Stack Overflow! Cannot push %d\n", value);
} else {
s->items[++(s->top)] = value; // Increment top and add value
printf("%d pushed to stack\n", value);
}
}
// Function to pop an element from the stack
int pop(struct Stack* s) {
if (isEmpty(s)) {
printf("Stack Underflow! Cannot pop\n");
return -1; // Indicate underflow
} else {
return s->items[(s->top)--]; // Return top value and decrement top
}
}
// Function to peek at the top element of the stack
int peek(struct Stack* s) {
if (isEmpty(s)) {
printf("Stack is empty! No top element\n");
return -1; // Indicate empty stack
} else {
return s->items[s->top]; // Return top value
}
}
// Main function to demonstrate stack operations
int main() {
struct Stack stack; // Create a stack
initStack(&stack); // Initialize the stack
push(&stack, 10); // Push elements onto the stack
push(&stack, 20);
push(&stack, 30);
printf("Top element is %d\n", peek(&stack)); // Peek at top element
printf("%d popped from stack\n", pop(&stack)); // Pop element
printf("Top element is now %d\n", peek(&stack)); // Peek at top element
return 0;
}
৫. স্ট্যাকের সুবিধা এবং অসুবিধা
সুবিধা:
- ডাইনামিক সাইজ: স্ট্যাকের সাইজ প্রোগ্রাম চলাকালীন সময়ে পরিবর্তিত হতে পারে (যদি ডাইনামিক মেমরি ব্যবহার করা হয়)।
- সহজ কার্যকরী: স্ট্যাক ব্যবহার করে সমস্যা সমাধান করা সহজ, যেমন ব্যাকট্র্যাকিং বা রিকার্সিভ কলের জন্য।
অসুবিধা:
- মেমরি সীমাবদ্ধতা: যদি অ্যারের উপর ভিত্তি করে স্ট্যাক তৈরি করা হয় তবে এর সাইজ পূর্বনির্ধারিত থাকে।
- লিনিয়ার প্রবাহ: স্ট্যাকের উপাদানগুলি LIFO পদ্ধতিতে সংগঠিত হয়, যা কিছু সমস্যার জন্য সীমাবদ্ধতা তৈরি করতে পারে।
Content added By
Stack হল একটি ডেটা স্ট্রাকচার যা তথ্যকে একটি সুশৃঙ্খল পদ্ধতিতে সংগঠিত করতে ব্যবহৃত হয়। এটি LIFO (Last In, First Out) পদ্ধতি অনুসরণ করে, অর্থাৎ শেষের দিকে যুক্ত করা উপাদানটি প্রথমে অপসারণ করা হয়।
স্ট্যাককে সাধারণত একটি নির্দিষ্ট সাইজের অ্যারে বা লিঙ্কড লিস্ট ব্যবহার করে বাস্তবায়িত করা হয়। স্ট্যাকের মধ্যে প্রধান দুটি অপারেশন হল:
- Push: স্ট্যাকের শীর্ষে একটি নতুন উপাদান যুক্ত করা।
- Pop: স্ট্যাকের শীর্ষ থেকে একটি উপাদান অপসারণ করা।
১. Stack এর ধারণা
স্ট্যাক একটি সুশৃঙ্খল ডেটা স্ট্রাকচার, যা বিভিন্ন ধরনের ডেটা প্রক্রিয়াকরণে সহায়ক। স্ট্যাকের দুটি মৌলিক বৈশিষ্ট্য:
এলিমেন্ট সংযোজন (Insertion): স্ট্যাকে নতুন উপাদান যুক্ত করার প্রক্রিয়াকে Push বলা হয়। এই অপারেশন স্ট্যাকের শীর্ষে একটি নতুন উপাদান যুক্ত করে।
এলিমেন্ট অপসারণ (Deletion): স্ট্যাক থেকে উপাদান অপসারণের প্রক্রিয়াকে Pop বলা হয়। এই অপারেশন স্ট্যাকের শীর্ষ থেকে উপাদানটি সরিয়ে দেয়।
স্ট্যাকের মৌলিক অপারেশন:
- Push: নতুন উপাদান যুক্ত করা।
- Pop: উপাদান অপসারণ করা।
- Peek: শীর্ষে থাকা উপাদানটি দেখতে পাওয়া, তবে অপসারণ না করা।
- isEmpty: স্ট্যাক খালি কি না তা পরীক্ষা করা।
- isFull: স্ট্যাক পূর্ণ কি না তা পরীক্ষা করা।
২. Stack এর প্রয়োগ
স্ট্যাকের বিভিন্ন ক্ষেত্রে ব্যবহারের উদাহরণ দেওয়া হলো:
ফাংশন কল ট্র্যাকিং:
- স্ট্যাকের সাহায্যে ফাংশন কলের ইতিহাস সংরক্ষণ করা হয়। যখন একটি ফাংশন কল করা হয়, তখন তার অ্যাড্রেস স্ট্যাকে সংরক্ষণ করা হয় এবং ফাংশন সম্পন্ন হলে স্ট্যাক থেকে অ্যাড্রেস অপসারণ করা হয়।
ব্যাকট্র্যাকিং:
- সমস্যাগুলির সমাধানে ব্যাকট্র্যাকিংয়ের জন্য স্ট্যাক ব্যবহৃত হয়। যেমন, মেইজের মধ্যে পথ খোঁজা।
এক্সপ্রেশন মূল্যায়ন:
- ইনফিক্স, পোষ্টফিক্স এবং প্রিফিক্স এক্সপ্রেশনগুলির মূল্যায়ন করতে স্ট্যাক ব্যবহার করা হয়। যেমন, পোলিশ নোটেশন।
অতীত তথ্য পুনরুদ্ধার:
- ওয়েব ব্রাউজারে ফিরে যাওয়ার বোতাম ব্যবহার করে ইউজারের পূর্ববর্তী পৃষ্ঠায় যাওয়ার তথ্য স্ট্যাকে সংরক্ষণ করা হয়।
কনভার্টিং এক্সপ্রেশন:
- ইনফিক্স থেকে পোষ্টফিক্স বা প্রিফিক্স এক্সপ্রেশনে রূপান্তরের জন্য স্ট্যাক ব্যবহার করা হয়।
মেমরি ম্যানেজমেন্ট:
- স্থানীয় ভেরিয়েবল এবং ফাংশন কলের জন্য মেমরি বরাদ্দ ও মুক্ত করার জন্য স্ট্যাক ব্যবহৃত হয়।
Content added By
Stack হল একটি ডেটা স্ট্রাকচার যা LIFO (Last In, First Out) পদ্ধতি অনুসরণ করে। স্ট্যাকের মূল অপারেশনগুলির মধ্যে Push, Pop, এবং Peek অন্তর্ভুক্ত রয়েছে। নিচে এই অপারেশনগুলির বিস্তারিত আলোচনা এবং C প্রোগ্রামিং ভাষায় উদাহরণ দেওয়া হলো।
১. Push অপারেশন
Push অপারেশন স্ট্যাকের শীর্ষে একটি নতুন উপাদান যুক্ত করার জন্য ব্যবহৃত হয়। এটি সাধারণত মেমরিতে একটি নতুন স্থান বরাদ্দ করে এবং শীর্ষ পয়েন্টারকে আপডেট করে।
উদাহরণ:
#include <stdio.h>
#include <stdlib.h>
#define MAX 100 // Stack এর সর্বাধিক সাইজ
struct Stack {
int items[MAX]; // Stack উপাদানগুলির জন্য অ্যারে
int top; // Stack এর শীর্ষের ইনডেক্স
};
// Stack তৈরি এবং ইনিশিয়ালাইজেশন
void initStack(struct Stack* s) {
s->top = -1; // Stack খালি
}
// Push অপারেশন
void push(struct Stack* s, int value) {
if (s->top == MAX - 1) {
printf("Stack Overflow! Cannot push %d\n", value);
} else {
s->items[++(s->top)] = value; // নতুন উপাদান যোগ করা
printf("%d pushed to stack\n", value);
}
}
২. Pop অপারেশন
Pop অপারেশন স্ট্যাকের শীর্ষ থেকে একটি উপাদান অপসারণ করে এবং সেই উপাদানটি ফেরত দেয়। যদি স্ট্যাক খালি হয়, তাহলে এটি একটি ত্রুটি নির্দেশ করে।
উদাহরণ:
// Pop অপারেশন
int pop(struct Stack* s) {
if (s->top == -1) {
printf("Stack Underflow! Cannot pop\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->items[(s->top)--]; // শীর্ষ থেকে উপাদান অপসারণ করা
}
}
৩. Peek অপারেশন
Peek অপারেশন স্ট্যাকের শীর্ষে থাকা উপাদানটি দেখায় কিন্তু সেটি অপসারণ করে না। এটি স্ট্যাকের অবস্থা জানার জন্য ব্যবহৃত হয়।
উদাহরণ:
// Peek অপারেশন
int peek(struct Stack* s) {
if (s->top == -1) {
printf("Stack is empty! No top element\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->items[s->top]; // শীর্ষ উপাদান দেখানো
}
}
৪. সম্পূর্ণ প্রোগ্রাম উদাহরণ
#include <stdio.h>
#include <stdlib.h>
#define MAX 100 // Stack এর সর্বাধিক সাইজ
struct Stack {
int items[MAX]; // Stack উপাদানগুলির জন্য অ্যারে
int top; // Stack এর শীর্ষের ইনডেক্স
};
// Stack তৈরি এবং ইনিশিয়ালাইজেশন
void initStack(struct Stack* s) {
s->top = -1; // Stack খালি
}
// Push অপারেশন
void push(struct Stack* s, int value) {
if (s->top == MAX - 1) {
printf("Stack Overflow! Cannot push %d\n", value);
} else {
s->items[++(s->top)] = value; // নতুন উপাদান যোগ করা
printf("%d pushed to stack\n", value);
}
}
// Pop অপারেশন
int pop(struct Stack* s) {
if (s->top == -1) {
printf("Stack Underflow! Cannot pop\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->items[(s->top)--]; // শীর্ষ থেকে উপাদান অপসারণ করা
}
}
// Peek অপারেশন
int peek(struct Stack* s) {
if (s->top == -1) {
printf("Stack is empty! No top element\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->items[s->top]; // শীর্ষ উপাদান দেখানো
}
}
// Main ফাংশন
int main() {
struct Stack stack; // Stack তৈরি
initStack(&stack); // Stack ইনিশিয়ালাইজেশন
push(&stack, 10); // Stack এ উপাদান যুক্ত করা
push(&stack, 20);
push(&stack, 30);
printf("Top element is %d\n", peek(&stack)); // Peek করা
printf("%d popped from stack\n", pop(&stack)); // Pop অপারেশন
printf("Top element is now %d\n", peek(&stack)); // Peek করা
return 0;
}
Content added By
Stack হল একটি ডেটা স্ট্রাকচার যা LIFO (Last In, First Out) পদ্ধতির উপর ভিত্তি করে কাজ করে। এই ধরনের ডেটা স্ট্রাকচারকে অ্যারে এবং লিঙ্কড লিস্ট ব্যবহার করে বাস্তবায়ন করা যেতে পারে। নিচে উভয় পদ্ধতির বিস্তারিত আলোচনা ও উদাহরণ দেওয়া হলো।
১. অ্যারে ব্যবহার করে Stack ইমপ্লিমেন্টেশন
১.১ স্ট্যাকের গঠন
#include <stdio.h>
#include <stdlib.h>
#define MAX 100 // Stack এর সর্বাধিক সাইজ
struct Stack {
int items[MAX]; // Stack উপাদানগুলির জন্য অ্যারে
int top; // Stack এর শীর্ষের ইনডেক্স
};
// Stack তৈরি এবং ইনিশিয়ালাইজেশন
void initStack(struct Stack* s) {
s->top = -1; // Stack খালি
}
১.২ স্ট্যাকে উপাদান যোগ করা (Push)
void push(struct Stack* s, int value) {
if (s->top == MAX - 1) {
printf("Stack Overflow! Cannot push %d\n", value);
} else {
s->items[++(s->top)] = value; // নতুন উপাদান যোগ করা
printf("%d pushed to stack\n", value);
}
}
১.৩ স্ট্যাক থেকে উপাদান অপসারণ করা (Pop)
int pop(struct Stack* s) {
if (s->top == -1) {
printf("Stack Underflow! Cannot pop\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->items[(s->top)--]; // শীর্ষ থেকে উপাদান অপসারণ করা
}
}
১.৪ শীর্ষ উপাদান দেখা (Peek)
int peek(struct Stack* s) {
if (s->top == -1) {
printf("Stack is empty! No top element\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->items[s->top]; // শীর্ষ উপাদান দেখানো
}
}
১.৫ পুরো প্রোগ্রাম উদাহরণ
#include <stdio.h>
#include <stdlib.h>
#define MAX 100 // Stack এর সর্বাধিক সাইজ
struct Stack {
int items[MAX]; // Stack উপাদানগুলির জন্য অ্যারে
int top; // Stack এর শীর্ষের ইনডেক্স
};
// Stack তৈরি এবং ইনিশিয়ালাইজেশন
void initStack(struct Stack* s) {
s->top = -1; // Stack খালি
}
// Push অপারেশন
void push(struct Stack* s, int value) {
if (s->top == MAX - 1) {
printf("Stack Overflow! Cannot push %d\n", value);
} else {
s->items[++(s->top)] = value; // নতুন উপাদান যোগ করা
printf("%d pushed to stack\n", value);
}
}
// Pop অপারেশন
int pop(struct Stack* s) {
if (s->top == -1) {
printf("Stack Underflow! Cannot pop\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->items[(s->top)--]; // শীর্ষ থেকে উপাদান অপসারণ করা
}
}
// Peek অপারেশন
int peek(struct Stack* s) {
if (s->top == -1) {
printf("Stack is empty! No top element\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->items[s->top]; // শীর্ষ উপাদান দেখানো
}
}
// Main ফাংশন
int main() {
struct Stack stack; // Stack তৈরি
initStack(&stack); // Stack ইনিশিয়ালাইজেশন
push(&stack, 10); // Stack এ উপাদান যুক্ত করা
push(&stack, 20);
push(&stack, 30);
printf("Top element is %d\n", peek(&stack)); // Peek করা
printf("%d popped from stack\n", pop(&stack)); // Pop অপারেশন
printf("Top element is now %d\n", peek(&stack)); // Peek করা
return 0;
}
২. লিঙ্কড লিস্ট ব্যবহার করে Stack ইমপ্লিমেন্টেশন
২.১ স্ট্যাকের গঠন
#include <stdio.h>
#include <stdlib.h>
// Node structure
struct Node {
int data; // Data part
struct Node* next; // Pointer to the next node
};
// Stack structure
struct Stack {
struct Node* top; // Pointer to the top node
};
২.২ স্ট্যাক তৈরি এবং ইনিশিয়ালাইজেশন
void initStack(struct Stack* s) {
s->top = NULL; // Stack খালি
}
২.৩ স্ট্যাকে উপাদান যোগ করা (Push)
void push(struct Stack* s, int value) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); // Create new node
newNode->data = value; // Assign data
newNode->next = s->top; // Point new node to old top
s->top = newNode; // Move top to new node
printf("%d pushed to stack\n", value);
}
২.৪ স্ট্যাক থেকে উপাদান অপসারণ করা (Pop)
int pop(struct Stack* s) {
if (s->top == NULL) {
printf("Stack Underflow! Cannot pop\n");
return -1; // ত্রুটি নির্দেশ
} else {
struct Node* temp = s->top; // Store current top
int poppedValue = temp->data; // Get data from top
s->top = s->top->next; // Move top to next node
free(temp); // Free the old top
return poppedValue; // Return the popped value
}
}
২.৫ শীর্ষ উপাদান দেখা (Peek)
int peek(struct Stack* s) {
if (s->top == NULL) {
printf("Stack is empty! No top element\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->top->data; // Return the top value
}
}
২.৬ পুরো প্রোগ্রাম উদাহরণ
#include <stdio.h>
#include <stdlib.h>
// Node structure
struct Node {
int data; // Data part
struct Node* next; // Pointer to the next node
};
// Stack structure
struct Stack {
struct Node* top; // Pointer to the top node
};
// Function to initialize the stack
void initStack(struct Stack* s) {
s->top = NULL; // Stack খালি
}
// Function to push an element onto the stack
void push(struct Stack* s, int value) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); // Create new node
newNode->data = value; // Assign data
newNode->next = s->top; // Point new node to old top
s->top = newNode; // Move top to new node
printf("%d pushed to stack\n", value);
}
// Function to pop an element from the stack
int pop(struct Stack* s) {
if (s->top == NULL) {
printf("Stack Underflow! Cannot pop\n");
return -1; // ত্রুটি নির্দেশ
} else {
struct Node* temp = s->top; // Store current top
int poppedValue = temp->data; // Get data from top
s->top = s->top->next; // Move top to next node
free(temp); // Free the old top
return poppedValue; // Return the popped value
}
}
// Function to peek at the top element of the stack
int peek(struct Stack* s) {
if (s->top == NULL) {
printf("Stack is empty! No top element\n");
return -1; // ত্রুটি নির্দেশ
} else {
return s->top->data; // Return the top value
}
}
// Main function to demonstrate stack operations
int main() {
struct Stack stack; // Create a stack
initStack(&stack); // Initialize the stack
push(&stack, 10); // Push elements onto the stack
push(&stack, 20);
push(&stack, 30);
printf("Top element is %d\n", peek(&stack)); // Peek at top element
printf("%d popped from stack\n", pop(&stack)); // Pop element
printf("Top element is now %d\n", peek(&stack)); // Peek at top element
return 0;
}
Content added By
Stack হল একটি ডেটা স্ট্রাকচার যা LIFO (Last In, First Out) পদ্ধতি অনুসরণ করে। এই পদ্ধতি অনেক বাস্তব জীবনের পরিস্থিতিতে কার্যকরী। এর মধ্যে একটি অন্যতম উদাহরণ হলো Undo Operation। এটি প্রায় সব সফটওয়্যার অ্যাপ্লিকেশনে দেখা যায়, বিশেষ করে টেক্সট এডিটর, গ্রাফিক ডিজাইন সফটওয়্যার, এবং কোড এডিটরগুলিতে।
১. Undo Operation এর ধারণা
Undo Operation ব্যবহারকারীর শেষ করা কাজকে বাতিল করার সুযোগ দেয়। উদাহরণস্বরূপ, একটি টেক্সট এডিটরে আপনি যদি কিছু লেখেন এবং পরে সেটি মুছে ফেলতে চান, তবে Undo ফিচারটি আপনাকে পূর্ববর্তী অবস্থায় ফিরিয়ে নিয়ে যেতে সহায়তা করে।
২. Stack এর ভূমিকা
Undo Operation বাস্তবায়নের জন্য স্ট্যাক ব্যবহার করা হয়। যখন ব্যবহারকারী একটি কাজ করে (যেমন টেক্সট লেখা, ফাইল সেভ করা, বা একটি ছবি সম্পাদনা করা), তখন সেই কাজের তথ্য স্ট্যাকে Push করা হয়। যদি ব্যবহারকারী Undo অপারেশন চালায়, তাহলে শেষ করা কাজটি স্ট্যাক থেকে Pop করা হয়, এবং পূর্ববর্তী অবস্থায় ফিরে যাওয়া যায়।
৩. উদাহরণস্বরূপ কাজের প্রক্রিয়া
কাজের সংরক্ষণ:
- যখন ব্যবহারকারী একটি নতুন কাজ সম্পন্ন করে, যেমন কিছু টেক্সট টাইপ করে, সেই কাজের তথ্য (যেমন "Type Hello World") স্ট্যাকে Push করা হয়।
Undo অপারেশন:
- ব্যবহারকারী যদি Undo অপারেশন করে, তাহলে স্ট্যাক থেকে শেষের কাজটি Pop করা হয় এবং আগের অবস্থায় ফিরে যাওয়া হয় (যেমন "Hello World" মুছে ফেলা হয়)।
৪. স্ট্যাকের মাধ্যমে Undo Operation বাস্তবায়ন
নিচে একটি সাধারণ উদাহরণ দেওয়া হলো যেখানে Undo অপারেশন স্ট্যাকের মাধ্যমে কার্যকরীভাবে বাস্তবায়িত হয়।
C প্রোগ্রাম উদাহরণ:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 100 // Maximum number of operations
// Stack structure for undo operations
struct Stack {
char* items[MAX]; // Stack to hold operations
int top; // Index of the top operation
};
// Function to initialize the stack
void initStack(struct Stack* s) {
s->top = -1; // Stack is initially empty
}
// Function to check if the stack is empty
int isEmpty(struct Stack* s) {
return s->top == -1;
}
// Function to push an operation onto the stack
void push(struct Stack* s, char* operation) {
if (s->top < MAX - 1) {
s->items[++(s->top)] = strdup(operation); // Duplicate string to avoid memory issues
printf("Operation '%s' added to undo stack.\n", operation);
} else {
printf("Stack Overflow! Cannot add more operations.\n");
}
}
// Function to pop an operation from the stack
char* pop(struct Stack* s) {
if (isEmpty(s)) {
printf("No operations to undo.\n");
return NULL;
} else {
return s->items[(s->top)--]; // Return top operation
}
}
// Main function to demonstrate undo operations
int main() {
struct Stack undoStack; // Create the undo stack
initStack(&undoStack); // Initialize the stack
// Simulate operations
push(&undoStack, "Type 'Hello World'");
push(&undoStack, "Type 'This is a test'");
push(&undoStack, "Save the document");
// Undo last operation
char* lastOperation = pop(&undoStack);
if (lastOperation) {
printf("Undo operation: %s\n", lastOperation);
free(lastOperation); // Free the duplicated string
}
// Undo another operation
lastOperation = pop(&undoStack);
if (lastOperation) {
printf("Undo operation: %s\n", lastOperation);
free(lastOperation);
}
// Show remaining operations
while (!isEmpty(&undoStack)) {
lastOperation = pop(&undoStack);
if (lastOperation) {
printf("Remaining operation: %s\n", lastOperation);
free(lastOperation);
}
}
return 0;
}
৫. উপসংহার
Stack হল একটি অত্যন্ত কার্যকরী ডেটা স্ট্রাকচার যা Undo Operation বাস্তবায়নের জন্য ব্যবহৃত হয়। এই প্রযুক্তি ব্যবহার করে ব্যবহারকারীরা সহজেই তাদের পূর্ববর্তী কাজ বাতিল করতে পারে, যা বিভিন্ন অ্যাপ্লিকেশনে একটি গুরুত্বপূর্ণ ফিচার। স্ট্যাকের সাহায্যে Undo Operation কার্যকরভাবে পরিচালনা করা সম্ভব, যা ব্যবহারকারীর অভিজ্ঞতা উন্নত করে।
Content added By
Read more
