Stack of C language source

1. Introduction (Why use stacks?) ）

In general, it is important to decide how to store data in such a way that data is automatically given in a specified order when it is retrieved. Stacks and queues are a common data structure for retrieving data. Stacks and queues are two very important data structures, and the stack and queue are also linear tables in terms of data structure. is a linear table with limited operation, the stack can only be inserted and deleted at one end (the top of the stack), and the queue can only be inserted at one end (the tail of the team) at the other end (team header) for deletion. However, from the data type, stacks and queues are two kinds of important abstract data types that are not very similar to linear tables. Here, the first focus on the stack, and the stack of the first-off operation of the C language implementation. Stacks are efficient data structures that store and retrieve data in last-in, first-out (LIFO) order. It retrieves the order of the elements in the opposite order of the stored elements. One of the most commonly used stacks is the C function call, which is an important part of modular programming when a function is called in a C program, an activity record containing the call information is pressed into the stack, which is called the program stack. When the calling function returns, its activity record pops up from the program stack. The stack is the perfect model for recording the function call procedure and the return process, because the function's call procedure is the opposite of the function's return process, which is exactly the last-in-first-out feature of the stack. One notable feature of the stack is that it stores and deletes elements in a last-in, first-out (LIFO) manner. This means that the last element in the stack will be deleted the first one. In the computer, put elements into the stack, to the stack into the "element, to delete the elements in the stack, it is necessary to" eject "the element. You can get information about the top element of the stack by checking the top element of the stack (note that this is not deleting it, just retrieving the top of the stack).

2. Stack definition (what is stack?) ）

Stack is a linear table that restricts insertions and deletions only at the end of a table. Therefore, for the stack, the end of the table has its special meaning, called the top of the stack (top) corresponding, the table head end is called the bottom of the stack (bottom), without any element of the empty table, called the empty stack.

3. Stack characteristics (why use stacks?) ）

Stacks are data structures that store and retrieve data in last-in, first-out order. It retrieves the order of elements in the opposite order of the stored elements. This feature makes the stack a very useful tool for programming. As mentioned above, C function calls and returns, bracket matching detection, etc. as long as the data has the characteristics of last-in-first-out can use the stack.

4. Stack definition and implementation (how to use the programming language (here, c as an example) to implement the stack? ）

A stack is a data structure with a linear relationship. As with linear tables, the physical storage structure of stacks in a computer can be divided into two types: sequential storage (sequential stacks) chained storage (chain stacks) Here is an example of a sequential stack. Sequential stack, the sequential storage structure of the stack is also the use of a set of contiguous memory units from the stack to the top of the stack of data elements at the same time, set up a pointer top to indicate the position of the stack top elements in the sequence stack, the usual practice is to use top = 0 for the empty stack, but in C, the array subscript Convention is When using C language design, it will bring great inconvenience. On the other hand, since the maximum space required by the stack during use is difficult to estimate, in general, the maximum capacity of the stack should not be limited when initializing the empty stack. A more reasonable way is: first to allocate a basic capacity of the stack of memory space, and then in the process of use, when the stack of space is not enough to use, and then expand by paragraph. To do this, you can set two constants: Stack_init_size (the initial allocation capacity of the storage space), and stackincrement (storage space allocation increment), so that we can define the sequence stack in the following types.

typedef struct SQSTACK{DATATYPE *base;//points to the stack base element DataType *top;//stack top element pointer int stack_size;//maximum storage capacity}sqstack;

Where stacksize indicates the maximum memory capacity of the stack currently available, and when a data element is pressed into the stack, the stacksize-1 is stacksize+1 when a data element is popped from the stack. The initial operation of the stack is: the initial allocated memory capacity (Stack_init_size) for the first storage allocation, base can be called the bottom of the stack pointer, in the sequential stack, it always points to the bottom of the stack, if the base = = NULL, it indicates that the stack structure does not exist, top is called the top of the stack pointer, Its initial value points to the bottom of the stack. That is, top = base = NULL, and whenever a new stack top element is inserted, the pointer top+1; the current free space stacksize-1; When the top element of the stack is deleted, the pointer top-1, the current free space stacksize+1; The top pointer in a non-empty stack is always at the next position on the top element of the stack.

</pre><p></p><pre name= "code" class= "HTML" >//sqstack.h#ifndef sqstack_h#define SQSTACK_H// The structure of the sequential storage structure of the--------stack ————————//#define STACK_INIT_SIZE 5//The initial allocation of memory space for the sequential stack # define Stackincrement 2//macros, when memory space is insufficient, The memory space of each growth typedef int DATATYPE;//abstracts the data types in the stack to make them suitable for any type. typedef struct SQSTACK{DATATYPE *base;//pointer to the stack base element DataType *top;//stack top element pointers int stack_size;//maximum storage capacity}sqstack;//-------- The data prototype of the function of the basic operation of the stack ——————////initialization stack: Constructs an empty stack stack, which is the base bool Init_stack (sqstack* stack) for other operations of the stack;//Determines whether the stack is empty bool Stack_is_empty ( Const SQSTACK * const stack);//press a data *data into the stack to make it a new stack top element bool Stack_push (sqstack *stack,const DataType * const data); Not NULL, return the stack top element with data and return true, otherwise return Falsebool stack_top (const sqstack * const STACK,DATATYPE *data);//Returns the number of elements in the stack stack, That is, the length of the stack int stack_length (const sqstack *const stack),//from the stack bottom to the top of the stack to traverse the stack elements, and output the stack of each element value. BOOL Stack_traverse (const SQSTACK * const stack);//If the stack is not empty, remove the top element from the stack and return the bool Stack_pop with data (Sqstack *stack, DataType *dat a);//Clear stack elements: After doing this, stack stack is empty stack bool Clear_stack (sqstack* StACK);//Destroy Stack: After doing this, the stack stack no longer exists, and no other operations on the stack can be performed unless the init_stack (stack) is called to regenerate a new stack of bool Destroy_stack (sqstack* stack); #endif 

-----------stack.cpp Algorithm Description of basic operation of---------sequence stack--------//#include "stack.h" #include <stdlib.h> #include < stdio.h>//initialization stack: Constructs an empty stack stack, is the base of the other operations of the stack//return value: The construction succeeds return True (1), the construction failure returns false (0);//parameter: Stack//time complexity that has been declared but not initialized O (1) bool Init_stack (sqstack* stack) {//Allocates memory space//allocates memory size of initial allocated amount (Stack_initsize) data to the sequential stack//and assigns the starting address of the memory to the bottom pointer Stack->baseif ( stack = = null)//When the parameter is passed in as a pointer, it must be empty, the parameter passed in exception, returned to the system value -1;exit ( -1); stack->base = (datatype*) malloc (stack_init_size * sizeof ( DataType)); if (stack->base = = NULL)//memory allocation fails, program exits exit (-1) abnormally;//Assign initial value to data element stack->top = stack->base;// stack initialized to empty stack stack->stack_size = stack_init_size;//Initialize usable capacity for Stack_init_sizereturn true;//successfully initialized stack stack}//destroy stack: After doing this, Stack stack no longer exists, other operations on the stack cannot be performed unless the call to Init_stack (stack) regenerates a new stack//return value: Destroy succeeded returns True (1), Destroy failed return False (0)//Parameter description: Stack! = null;// Time complexity O (1)//The memory space of the sequential stack is allocated by malloc in the heap, so how can free () release the memory space it holds?    BOOL Destroy_stack (sqstack* stack) {if (stack = = NULL)//parameter is a pointer, must be sentenced to exit (-1); Exception, exit free (stack->base);//Call the "function" to release the memory space allocated by malloc () Stack->base = NUll;//the pointer blank to prevent the wild pointer stack->top = null;//The pointer is empty, to prevent the wild pointer stack->stack_size = 0;//stack has been destroyed, the usable storage space must be 0 return true;} Clear stack elements: After doing this, stack stack is empty stack//return value: True (1) stack empty, False (0) empty exception//parameter: stack must have initialized//time complexity: O (1) bool Clear_stack (sqstack* Stack) {if (stack = = null)//When the parameter is a pointer, be sure to empty it, exit (-1);//Program Exception exit if (Stack->base = = NULL)//stack uninitialized, unable to perform this operation return false; Stack-top = stack->base;//order stack empty condition return true;} Determines whether the stack is empty//return value: True (1), stack is empty, False (0), stack is not empty//parameter: Stack stack must initialize//time complexity: O (1); bool Stack_is_empty (const SQSTACK * const Stack) {if (stack = = NULL)//pointer as parameter must be empty exit ( -1); if (stack->base! = stack->top) return False;elsereturn true;} Returns the number of elements in the stack stack, that is, the length of the stack//return value: Stack length//Parameter description: Stack must already initialize//time complexity: O (1) int stack_length (const sqstack * Const stack) {if (stack = = NULL)//The pointer must be empty for exit ( -1); int length = (stack->top-stack->base);//stack has used space for (top- Base) The same type of pointer in contiguous memory is subtracted from the number of elements between two pointers return length;} If the stack is not empty, return the stack top element with data and return true, otherwise return the false//return value: True (1) The top element of the stack is successfully obtained, FALSE (0) gets the stack top element failed//Parameter description: Stack for the initialized stack pointer, Data is used to store the top element of the stack BooL stack_top (const sqstack * Const Stack,datatype *data) {if (stack = = NULL | | data = NULL)//When the pointer is passed in, you must empty exit ( -1); if (STA Ck->base = = stack->top)//Stack is empty, there is no stack top element return false;*data = * (stack->top-1),//stack top element, because the stack top pointer refers to the top of the upper stack element of the next position, return true;} Pushes a data *data into the stack, making it a new top-of-stack element//return value: The data is successfully pressed into the stack, returning True (1), otherwise false (0)//Parameter description: Stack point is initialized, data is the element to be pressed in// Time complexity: O (1)//test case selection {stack empty, stack dissatisfaction, stack full}bool stack_push (sqstack *stack, const DataType *const data) {if (stack = = NULL | | data = NU LL)//Pointer to empty exit (-1);//The stack full, if full, in the original memory space after the allocation of Incrementif ((stack->top-stack->base) >= stack->stack_size)// If the number of elements in the top and bottom pointer base of the stack is already greater than or equal to the maximum capacity, {//must add memory in the original memory space stack->base = (Data type*) ReAlloc (Stack->base, (stack->stack_size + stackincrement) * sizeof (DataType)); if (stack->base = = NULL)/ /Memory allocation exception exit ( -1); stack->top = Stack->base + stack->stack_size;//is the top of the stack pointer back to the previous stack top element stack->stack_size + = stackincrement;//the maximum memory capacity of the stack after re-allocating memory}*stack->top = *data;//data is pressed into the stack top ++stack->top; return true;} If the stack is not empty, delete the stack top and return it with data//return value: Delete succeeds return True (1), delete failure returns False (0)//Parameter description: Stack initialized, data for deleted stack top element//Time complexity: O (1);//test Case {  Stack empty, stack has only one element, stack has multiple elements, stack full}bool stack_pop (Sqstack *stack, DataType *data) {if (stack = = NULL | | data = = NULL)//incoming pointer must be empty return False;if (stack->base = = NULL)//stack is not initialized, can not delete the top element of the stack return false;if (stack->base = = stack->top)//stack empty, cannot delete the top element of the stack { return false;} else//stack non-null {--stack->top; *data = *stack->top;//fetch stack top element}return true;//delete successfully}//Access data referred to by the database and display it on the screen//return value: Access Success Returns True (1), Access failure returns False (0)//Parameter description: Pointer to data element//Time complexity: O (1) BOOL Visit (const datatype* const data) {if (data = = NULL)/        /pointer as a parameter to pay attention to the empty return false; printf ("%d,", *data);//Note Here I define datatye is int so format control with%dreturn true;} Iterate through the elements in the stack from the bottom of the stack to the top of the stack, and output each element value in the stack. Traversal succeeded returns True (1), traversal failed, return False (0)//Parameter description: Stack is initialized, function pointer bool (*VISIT) () is a function pointer,// The function visit () is called from the stack to the top of each element in the stack to be displayed on the screen,//This is because you do not add the Echo function//time complexity to the function: O (n)//test Case {stack uninitialized, stack empty, stack has only one data element, stack has multiple data elements, stack is full stack} BOOL Stack_traverse (Const SQSTACK * Const stack) {if (stack = = NULL)//If the incoming parameter is a pointer, you must determine whether it is empty return false;if (stack->base = = stack->top) Stack empty return false;else{datatype* pdata = stack->base;//set a temporary pointer variable to the element to traverse the entire stack while ((pdata! = stack->top)) { Visit (pdata);//show Current data ++pdata;//point to Next data element}return true;} Access the stack-bottom pointer base to the top of the stack (including the bottom of the stack pointer base, excluding the top of the stack pointer) of the DATA element}

------------main.cpp---------------test file--------------////Test principle: To make every statement in the program to//test steps: Define the stack, initialize the stack, empty the stack, press the data element into the stack { 0,1,2, Multi, Stack_init_size (full), stack_init_size+1}, Stack traversal {uninitialized, initialized, 0,1,2, multiple},//Stack length {empty, 1, 2, multiple} pops the element from the stack {multiple, 2,1,0, uninitialized}, Destroy stack (empty stack, other stack) #include "stack.h" #include <stdio.h> #include <stdlib.h>int main (void) {Sqstack stack;//declares a stack, But is not initialized, at this time the stack can not be used sqstack *PSTACK1 = &stack;//Declare a stack pointer, point to stacksqstack *pstack2 = null;//used to test the non-existent stack//---------------- -------------------------------------Test---------------------------------------------------------////----------- -----Initialization stack: Constructs an empty stack stack, which is the basis for other operations on the stack------------------------------------////bool init_stack (sqstack* stack); bool Is_ init = False;is_init =init_stack (pstack1);p rintf ("is stack init:%d\n", is_init);//initialization succeeded Is_init = = 1//is_init =init_stac K (pstack2);//When the incoming pointer parameter is NULL the system exits the program and displays in the compiler's output window: Native "exited with a return value of-1 (0xFFFFFFFF). printf ("\ n");//newline, in order to display more clearly in the screen//------------------------------- Determine if the stack is empty-----------------------------------------------------////bool sTack_is_empty (const sqstack * const stack); BOOL Is_empty = false;//defines a bool amount to determine whether the stack is empty, is true (1), the stack is not empty to False (0) Is_empty = Stack_is_empty (PSTACK1),//Because the stack is simply initialized, No elements have been pressed into the stack, so the stack is empty for printf ("is stack empty:%d\n", is_empty);//return value 1//is_empty = Stack_is_empty (PSTACK2);//When the incoming pointer argument is NULL The system exits the program and displays in the Output window of the compiler: native "exited with a return value of-1 (0xFFFFFFFF). The stack non-empty test is left to the back of the stack when you press an element into the test//---------------------------------------returns the number of elements in the stack stack, That is, the length of the stack------------------------------////int stack_length (const sqstack *const stack); int length; length = Stack_ Length (pstack1);//define an int variable to record the length of the current stack, which is the number of elements in the stack printf ("Stack current length:%d\n", length);p rintf ("\ n");//--------------------- --------pushes a data *data into the stack, making it the new top element of the stack------------------------////bool stack_push (sqstack *stack,const DataType * const data);//test case: Push into the stack the elements {0,1,2, many, stack_init_size (full), stack_init_size+1}//To test the convenience of stack_init_size = = 5,stackincrement = 2, that is, the initial capacity of 5 elements, again allocated 2//test Case {empty, 1,2,3,4,5,6,7}//if the stack is not empty, with data to return the stack top element of the stack and display on the screen, and return True, otherwise return falsebool Is_push = false;//define a variable to determine whether the success of the ChangPressed into an element, the press-in succeeds returns True (1), the press-in failure returns False (0) DataType data[] ={1,2,3,4,5,6,7};//defines a variable to store the top element of the stack//stack_push (pstack2,& DATA[0]);//When the incoming pointer parameter is NULL the system exits the program and displays in the compiler's output window: Native "exited with a return value of-1 (0xFFFFFFFF). Stack_push (pstack1,&data[0]);//Push the data element 1 into the stack and act as the top element of the stack datatype top_data;//Declare a data_type variable top_data, The Data stack_top (pstack1,&top_data) used to display the push-in stack and pop-up stack;p rintf ("The element in the stack this time is:%d\n", top_data); length = Stack_length (PSTACK1) ;//define an int variable to record the length of the current stack, which is the number of elements in the stack printf ("Stack current length:%d\n", length);p rintf ("\ n"); Stack_push (pstack1,&data[1]);// Press the data element 2 into the stack, and act as the top element of the stack stack_top (pstack1,&top_data);p rintf ("the element in this push-down stack is:%d\n", top_data); length = Stack_length ( PSTACK1);//define an int variable to record the length of the current stack, which is the number of elements in the stack printf ("Stack current length:%d\n", length);p rintf ("\ n"); Stack_push (pstack1,&data[2 ]),//press the data element 3 into the stack, and act as the top element of the stack stack_top (pstack1,&top_data);p rintf ("the element in this push-down stack is:%d\n", top_data); length = Stack_ Length (pstack1);//define an int variable to record the length of the current stack, which is the number of elements in the stack printf ("Stack current length:%d\n", length);p rintf ("\ n"); Stack_push (Pstack1, &AMP;DATA[3]),//press the data element 4 into the stack and act as the top element of the stack stack_top (pstack1,&tOp_data);p rintf ("the element in this push-down stack is:%d\n", top_data); length = Stack_length (PSTACK1);//define an int variable to record the length of the current stack that is the number of elements in the stack printf (" The current length of the stack is:%d\n ", length);p rintf (" \ n "), Stack_push (Pstack1,&data[4]),//press the data element 5 into the stack, and as the top element of the stack, Stack_top (Pstack1, &top_data);p rintf ("the element in this push-down stack is:%d\n", top_data); length = Stack_length (PSTACK1);//define an int variable to record The length of the current stack is the number of elements in the stack printf ("Stack current length:%d\n", length);p rintf ("\ n"), Stack_push (pstack1,&data[5]);//Press the data element 6 into the stack, And as the top element of the stack, at this time the stack initial allocation capacity Stack_init_size ==5 has run out, is the re-allocated memory increment stackincrement ==2stack_top (pstack1,&top_data);p rintf (" The elements of this push-in stack are:%d\n ", top_data); length = Stack_length (PSTACK1);//define an int variable to record the length of the current stack, which is the number of elements in the stack printf (" Stack current length:%d\n ", Length);p rintf ("\ n"), Stack_push (Pstack1,&data[6]),//pushes the data element 7 into the stack and acts as the top element of the stack, at which time the stack is full stack_top (pstack1,&top_ Data);p rintf ("the element in this push-down stack is:%d\n", top_data); length = Stack_length (PSTACK1);//define an int variable to record the length of the current stack that is the number of elements in the stack printf (" The current length of the stack is:%d\n ", length);p rintf (" \ n "), Stack_push (Pstack1,&data[0]),//Allocate memory stackincrement and push element 1 into the stack, the capacity of the sequential stack is Stack_init_size (5) +stackincrement (2) + stackincrement (2) = = 9, used memory space is 8, stack is not full stack_top (pstack1,&top_data);p rintf ("This time the stack element is:%d\n", top_data); Length = Stack_length (PSTACK1);//define an int variable to record the length of the current stack, which is the number of elements in the stack printf ("Stack current length:%d\n", length);p rintf ("\ n");//-------- -----------------------determine if the stack is empty-----------------------------------------------------////bool stack_is_empty ( Const SQSTACK * const stack); is_empty = Stack_is_empty (PSTACK1);//Because the stack is already initialized and the element is pressed into the stack, the stack is not empty printf ("is stack empty:%d\n" , is_empty);//The return value is false, that is, 0//---------------------------to traverse the stack from the bottom of the stack to the top, and output each element value in the stack. -----------------////bool stack_traverse (const sqstack * const stack); bool Is_traverse = false;//declares a bool volume is_traverse Used to determine whether to traverse the entire stack of elements, printf ("Stack elements:"); is_traverse = Stack_traverse (PSTACK1);//return value is true (1), traversal succeeds, False (0) traversal failed printf (" Traversal succeeded:%d\n ", Is_traverse);p rintf (" \ n ");//-------------------------------If the stack is not empty, remove the top element from the stack and use the data Returns---------------------////bool stack_pop (sqstack *stack, DataType *data); bool Is_pop = false;//defines a bool variable Is_pop Used to determine if the top element of the stack is successfully ejected datatype pOp_top;//define a datatype type variable, pop_top, to hold the top element of the popup, we can find that the data of the pop-up stack is exactly the opposite of the press-in order. Is_pop = Stack_pop (pstack1,&pop_top);//Successful Popup Returns True (1), eject failure returns false (0) printf ("Successfully deleted:%d\n", Is_pop);p rintf (" Deleted stack top element:%d\n ", pop_top); is_pop = Stack_pop (pstack1,&pop_top);//Success Popup Returns True (1), Popup failure returns False (0) printf (" Successfully deleted:%d\n ", Is_pop);p rintf (" deleted stack top element:%d\n ", pop_top); is_pop = Stack_pop (pstack1,&pop_top);//Successful Popup Returns True (1), Pop-up Failure returns False (0) printf ("Successfully deleted:%d\n", Is_pop);p rintf ("deleted stack top element:%d\n", pop_top); is_pop = Stack_pop (pstack1,&pop_top );//Success Popup Returns True (1), the popup failed to return False (0) printf ("Successfully deleted:%d\n", Is_pop);p rintf ("deleted stack top element:%d\n", Pop_top);p rintf ("\ n");//---- -----------------------------Clear stack elements: After doing this, the stack stack is empty stack--------------------------------------////bool clear_stack ( sqstack* stack); bool is_clear = false; Defines a bool amount is_clear is used to determine if the stack is emptied is_clear = Clear_stack (PSTACK1);//When the return value is true (1) the stack has been emptied printf ("is the stack emptied?"). %d \ n ", is_clear);//When Empty returns True (1), does not empty, returns False (0) printf (" is empty stack:%d\n ", Stack_is_empty (PSTACK1));//Determine if empty after empty// Here the test removes the empty stack is_pop = Stack_pop (PStack1,&pop_top);//Successful Popup Returns True (1), the popup fails to return False (0) printf ("Successfully deleted:%d\n", Is_pop);p rintf ("\ n");//-------------- Destroy stack: After you do this, the stack stack no longer exists, and no other operations on the stack can be performed unless you call Init_stack (stack) to regenerate a new stack-----------////bool destroy_stack (sqstack* stack) ; bool Is_destroy = False;is_destroy =destroy_stack (pstack1); if (Is_destroy = = 1) printf ("Did you build it?") The stack has been destroyed! Don't do anything to me! !!! "); Pstack1 = null;//Destroy the stack, to the pointer to the stack empty, to prevent the wild pointer//stack_push (pstack1,&data[2]);//Do not believe that the test: An exception is returned to the system: Native "has exited, the return value is-1 ( 0xFFFFFFFF). return 0;}

6. Results and conclusions:

A stack is a single-ended linear table that can only be inserted and deleted at one end. The logical structure of data structures is a one-to-two relationship, but also because it can only be inserted and deleted at one end, which determines the characteristics of the stack, LIFO
In the process of learning data structure, we must bear in mind the structural decision nature, the nature determines the use. So it is possible to describe a stack structure that satisfies a last-in-first-out nature, such as a function call procedure in C and a return
The process saving function state information is used by the stack. There is another very important aspect of data structure, that is, the physical structure, we know that in the computer to store data elements collection, there are generally two methods, sequential storage: the use of large
A contiguous storage unit for storage, which is logically adjacent to the physical location in memory. Another way is to use pointers to encapsulate the data and pointers to the data as nodes, and the data field stores the elements themselves to store the relationship between the data. The advantage of sequential storage structure is that (1) Support random access: that is, if you know the location of the element, the time complexity for finding the element is O (1) (2) The storage space required to store the same dataset is less than the chain storage space: Because the chain storage structure must use pointers to represent the relationship between data, Sequential storage structures are not required. The disadvantages of the sequential structure are: (1) Insert and delete to move a large number of data elements, the worst time complexity is O (n) (2) when inserting to the table header, when the dataset does not know the size, it cannot allocate reasonable memory space. Of course, in this case, the stack is a linear table that is inserted and deleted only at one end (footer) of the table, while the time complexity for inserting and deleting at the end of the table is O (1), and when the stack space is low, it can be allocated with the realloc () function. In order to save memory space, the sequential storage structure can be used to implement the stack, which is the abstract data type of the stack defined by the above code. In the next blog post, a chain structure is used to define the abstract data type of a stack. Can compare the pros and cons of these two, of course, because the stack is a linear table, is a kind of special-use linear table, if you learn object-oriented programming students, you can also inherit the linear table to define the abstract data type of the stack.

The test results are as follows:

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

Stack of C language source