数据结构C语言实现栈

头文件

#ifndef STACKHEAD_H_INCLUDED

#define STACKHEAD_H_INCLUDED


#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define STACK_INIT_SIZE 10
#define STACK_INCR_SIZE 3
typedef struct Sqstack
{
    int* Sbase ;
    int* Stop ;
    int StackSize ;
} Sqstack ;
//实现栈
int InitStack( Sqstack* s ) ;
int DestroyStack( Sqstack* s ) ;
int GetTop( Sqstack s , int* e ) ;
int GetLength( Sqstack s ) ;
int Push( Sqstack* s , int e ) ;
int Pop( Sqstack* s , int* e ) ;
int IsEmpty( Sqstack s ) ;
int ClearStack( Sqstack* s ) ;
int TraveserStack( Sqstack s ) ;


//栈的应用
int DataConvert( int data ) ;//数制转换

#endif // STACKHEAD_H_INCLUDED

栈的实现

#include "stackhead.h"




int InitStack( Sqstack* s )
{
    s->Sbase = ( int* )malloc( STACK_INIT_SIZE * sizeof( int ) ) ;
    if( !s->Sbase )
    {
        printf( " OVERFLOW !\n" ) ;
        exit( 1 ) ;
    }
    memset( s->Sbase , 0 , STACK_INIT_SIZE * sizeof( int ) ) ;
    s->Stop = s->Sbase ;
    s->StackSize = STACK_INIT_SIZE ;
    return 0 ;
}


int DestroyStack( Sqstack* s )
{
    int* p = --s->Stop ;
    while( s->Stop != s->Sbase )
    {
        s->Stop-- ;
        free( p-- ) ;
    }
    free( s->Sbase ) ;
    free( p ) ;
    return 0 ;
}


int Push( Sqstack* s , int e )
{
    if( s->Stop - s->Sbase >= s->StackSize )
    {
        s->Sbase = ( int* )realloc( s->Sbase , ( s->StackSize + STACK_INCR_SIZE ) * sizeof( int ) ) ;
        s->Stop = s->Sbase + STACK_INIT_SIZE ;
        s->StackSize += STACK_INCR_SIZE ;
        if( !s->Sbase )
        {
            printf( " OVERFLOW !\n" ) ;
            exit( 1 ) ;
        }
    }
    *s->Stop++ = e ;
    return 0 ;
}


int GetLength( Sqstack s )
{
    return s.Stop - s.Sbase ;
}


int GetTop( Sqstack s , int* e )
{
    if( s.Sbase == s.Stop )
    {
        printf( "ERROR!\n") ;
        exit( 1 ) ;
    }
    *e = *--s.Stop ;//为什么改成 e = --s.Stop ; 不行？
    return 0 ;
}
int Pop( Sqstack* s , int* e )
{
    if( s->Sbase == s->Stop )
    {
        printf( "the stack is empty !\n" ) ;
        exit( 1 ) ;
    }
    *e = *--s->Stop ;
    return 0 ;
}


int IsEmpty( Sqstack s )
{
    if( s.Sbase == s.Stop )
    {
        return 1 ;
    }
    return 0 ;
}


int ClearStack( Sqstack* s )
{
    memset( s->Sbase , 0 , s->StackSize * sizeof( int ) ) ;
    s->Stop = s->Sbase ;
    return 0 ;
}


int TraveserStack( Sqstack s )
{
    if( s.Stop == s.Sbase )
    {
        printf( "the stack is empty !\n" ) ;
        exit( 1 ) ;
    }
    int* p = s.Sbase ;
    while( p != s.Stop )
    {
        printf( "%d\t" , *p++ ) ;
    }
    printf( "\n" ) ;
    return 0 ;
}

栈的应用

#include "stackhead.h"


int DataConvert( int data )//十进制的数转换成八进制的数
{
    Sqstack datastack ;
    InitStack( &datastack ) ;
    while( data )
    {
        Push( &datastack ,  data % 8 ) ;
        data /= 8 ;
    }
    while( !IsEmpty( datastack ) )
    {
        int e ;
        Pop( &datastack , &e ) ;
        printf( "%d" , e ) ;
    }
    printf( "\n" ) ;
    return 0 ;
}