How to use C and Python to implement stacks and typical applications

This article first introduces how to use C and Python to implement the stack through examples, and then introduces the typical application of the stack. it is of reference value for everyone to learn the stack. let's take a look at it. Preface

What is a stack? you can understand it as a First In Last Out data structure (First In Last Out), a linear table with limited operations...

With the void pointer and function pointer in C language, we can implement a chain universal stack:

/* stack.h */#ifndef _STACK_H_#define _STACK_H_ typedef struct stackNode { void *value; struct stackNode *next;} stackNode; typedef struct stack { stackNode *top; void (*free)(void *ptr); unsigned long size;} stack;  /* Functions implemented as macros */#define stackTop(s) ((s)->top)#define stackSize(s) ((s)->size) #define stackSetFreeMethod(s, m) ((s)->free = (m))#define stackGetFreeMethod(s) ((s)->free) stack *stackCreate(void);stack *stackPush(stack *stack, void *value);stackNode *stackPop(stack *stack);void stackClear(stack *stack); #endif /* _STACK_H_ */  /* stack.c */#include 
 
  #include "stack.h"  stack *stackCreate(void){ struct stack *stack;  if ((stack = (struct stack *)malloc(sizeof(struct stack))) == NULL) return NULL; stack->top = NULL; stack->free = NULL; stack->size = 0; return stack;} stack *stackPush(stack *stack, void *value){ stackNode *node;  if ((node = (stackNode *)malloc(sizeof(stackNode))) == NULL) return NULL; node->value = value; node->next = (stack->size == 0) ? NULL : stack->top; stack->top = node; stack->size++; return stack;} stackNode *stackPop(stack *stack){ stackNode *node;  node = stack->top; if (stack->size != 0) { stack->top = node->next; stack->size--; } return node;} void stackClear(stack *stack){ unsigned long size; stackNode *current, *next;  current = stack->top; size = stack->size; while (size--) { next = current->next; if (stack->free) stack->free(current->value); free(current); current = next; } free(stack);}
 

The implementation includes a header node, which is mainly used to register functions related to stack node operations. We have stored the stack size information so that we can get the current stack size in the O (1) time!

Python implementation

In Python, list can be directly used as a stack, if you operate only at one end of it. Of course, we can also encapsulate it as follows:

class Stack(object):  """A stack encapsulation based on list."""  def __init__(self): self.items = []  def empty(self): return self.items == []  def clear(self): del self.items[:]  @property def size(self): return len(self.items)  def push(self, item): """Add a new item to the top of the stack.""" self.items.insert(0, item)  def pop(self): """Remove the top item from the stack.""" return self.items.pop(0)  def top(self): """Return the top item from the stack but not remove it. """ return self.items[0]  def __iter__(self): return iter(self.items)  def __next__(self): return self.pop()

Application

The following describes the typical applications of several stacks.

Matching Brackets

I will give you an arithmetic expression or a piece of C code. how can I write a program to verify that the parentheses in it match? Stack can be easily implemented. The algorithm flow is as follows:

Traversal characters:

1. if it is left parentheses, push the data into the stack;

2. if the right parenthesis is used, if the stack is empty at this time, it indicates that it does not match. if the stack is not empty and the left parenthesis of the pop-out stack is different from that of the right brace, it indicates that it does not match;

If the stack is not empty after the traversal ends, it indicates that the stack does not match.

def check_pares(exp): """Check if parentheses match in a expression.""" stack = Stack() pares = {')': '(', ']': '[', '}': '{'} for x in exp: if x in '([{': stack.push(x) elif x in ')]}': if stack.empty() or pares[x] != stack.pop(): return False return True if stack.empty() else False

Number Conversion

Take decimal to binary as an example:

def dec2bin(dec): """Converting decimal number to binary string.""" if dec == 0: return '0' stack = Stack() while dec: r = dec % 2 stack.push(r) dec = dec // 2 return ''.join(str(digit) for digit in stack)

Simulate recursion

Traversing a binary tree is a classic recursive application. Let's take the first-order traversal as an example. recursive version code is easy to write:

def preorder_traversal(root): """ 1 / \ 2 3 / \ \ 4 5 6 """ if not root: return print(root.val) preorder_traversal(root.lchild) preorder_traversal(root.rchild)

The following is a non-recursive version:

def preorder_traversal(root) s = Stack() while s.size or root: if root: print(root.val) s.push(root) root = root.lchild else: root = s.pop().rchild

Summary

The above describes how to use C and Python to implement the entire stack and typical applications. I hope it will help you learn and continue to support PHP.

For more information about how to use C language and Python to implement stacks and typical applications, see The PHP Chinese network!