C Program to Implement a Stack Using Union

Welcome to another exciting blog post where we explore the world of data structures in the programming language C. In this post, we will dive deep into the concept of stacks and learn how to implement a stack using a union in C. So, fasten your seatbelts and get ready for an exhilarating journey into the world of stacks and unions!

Introduction to Stacks

Let’s start by understanding what a stack is. Simply put, a stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle. Imagine a stack of books – you remove the last book placed on top as the first one. Similarly, in a stack, you remove the most recently added element first.

In programming, a stack is quite similar. It has two main operations: push and pop. The push operation adds an element to the top of the stack, while the pop operation removes the topmost element. Additionally, we have a peek operation, which allows us to view the topmost element without removing it.

Stacks have numerous real-world applications. For example, they are often used in function calls to store the return addresses and local variables of each function. They are also used in parsing algorithms to evaluate expressions, undo-redo functionality, and more.

Union: A Powerful C Construct

Before we jump into implementing a stack, let’s touch upon the concept of a union in C. A union is a user-defined data type that allows different variables to be stored in the same memory location. Unlike a structure, which allocates separate memory for each member, a union shares memory between its members.

To define a union in C, we use the union keyword, followed by the union name and the members enclosed in braces. Here’s an example:

union myUnion {
  int iValue;
  float fValue;
  char cValue;
};

In this example, the union myUnion can store an integer, a float, or a character. The largest member determines the size of a union.

Now that we have a basic understanding of stacks and unions, let’s dive into the implementation of a stack using a union in C!

Implementing a Stack Using Union

To implement a stack using a union in C, we’ll define a struct to represent the stack itself. This struct will contain an array to store the stack elements and an integer variable to keep track of the top of the stack.

First, let’s define our struct:

struct Stack {
  int top;
  union {
    int intArray[STACK_SIZE];
    float floatArray[STACK_SIZE];
    char charArray[STACK_SIZE];
  } items;
};

In this struct, the top variable keeps track of the index of the topmost element in the stack. The union allows us to choose the data type for our stack elements. Here, we have defined three options: intArray, floatArray, and charArray, each capable of holding STACK_SIZE elements.

Next, we need to write the functions to perform stack operations: push, pop, and peek.

Push Operation

The push operation adds an element to the top of the stack. Here’s the code to implement the push operation for each data type:

void pushInt(struct Stack* stack, int value) {
  if (stack->top < STACK_SIZE) {
    stack->items.intArray[stack->top++] = value;
    printf("Pushed: %d\n", value);
  } else {
    printf("Stack Overflow\n");
  }
}

void pushFloat(struct Stack* stack, float value) {
  if (stack->top < STACK_SIZE) {
    stack->items.floatArray[stack->top++] = value;
    printf("Pushed: %.2f\n", value);
  } else {
    printf("Stack Overflow\n");
  }
}

void pushChar(struct Stack* stack, char value) {
  if (stack->top < STACK_SIZE) {
    stack->items.charArray[stack->top++] = value;
    printf("Pushed: %c\n", value);
  } else {
    printf("Stack Overflow\n");
  }
}

These functions receive a pointer to the stack (struct Stack*) and the value to be pushed. If the stack is not full (i.e., top < STACK_SIZE), the value is added to the appropriate array based on the data type chosen.

Pop Operation

The pop operation removes the topmost element from the stack. Here’s the code to implement the pop operation for each data type:

int popInt(struct Stack* stack) {
  if (stack->top > 0) {
    return stack->items.intArray[--stack->top];
  } else {
    printf("Stack Underflow\n");
    return INT_MIN;
  }
}

float popFloat(struct Stack* stack) {
  if (stack->top > 0) {
    return stack->items.floatArray[--stack->top];
  } else {
    printf("Stack Underflow\n");
    return FLT_MIN;
  }
}

char popChar(struct Stack* stack) {
  if (stack->top > 0) {
    return stack->items.charArray[--stack->top];
  } else {
    printf("Stack Underflow\n");
    return '\0';
  }
}

These functions also receive a pointer to the stack and return the popped value. If the stack is not empty (i.e., top > 0), the appropriate array is accessed, and the value at --top is returned.

Peek Operation

The peek operation allows us to view the topmost element without removing it. Here’s the code to implement the peek operation for each data type:

int peekInt(struct Stack* stack) {
  if (stack->top > 0) {
    return stack->items.intArray[stack->top - 1];
  } else {
    printf("Stack Underflow\n");
    return INT_MIN;
  }
}

float peekFloat(struct Stack* stack) {
  if (stack->top > 0) {
    return stack->items.floatArray[stack->top - 1];
  } else {
    printf("Stack Underflow\n");
    return FLT_MIN;
  }
}

char peekChar(struct Stack* stack) {
  if (stack->top > 0) {
    return stack->items.charArray[stack->top - 1];
  } else {
    printf("Stack Underflow\n");
    return '\0';
  }
}

Similar to the pop operation, these functions return the value at top - 1 without modifying the stack.

Putting It All Together

Now that we have defined the necessary data structures and functions, let’s see how we can use them to create a stack and perform various operations.

First, we’ll need to initialize our stack:

int main() {
  struct Stack stack;
  stack.top = 0;
}

Before we proceed, we should choose the desired data type for our stack elements. For example, to create a stack of integers, we’ll use:

int main() {
  struct Stack stack;
  stack.top = 0;

  pushInt(&stack, 42); // Pushing an integer value
  pushInt(&stack, 17);
  int topInt = peekInt(&stack); // Getting the topmost integer without removing it
  int poppedInt = popInt(&stack); // Popping the topmost integer
}

Similarly, we can create stacks of floats or characters by replacing the function names and the data type.

Conclusion

Congratulations! You’ve successfully implemented a stack using a union in C. In this blog post, we discussed the concept of stacks, unions, and how one can combine them to create an efficient data structure.

Remember, stacks are incredibly versatile and find applications in various domains of computer science. By understanding how to implement a stack using a union in C, you’ve gained a powerful tool to solve a wide range of problems.

If you want to dive deeper into the topic, consider exploring more advanced variations of stacks, such as dynamic stacks or stack applications in different algorithms.

Now it’s time to put your newfound knowledge into practice. Create your own programs, experiment with different operations, and explore the fascinating world of stack-based data structures.

Happy coding!