《数据结构（C语言版）第二版》第三章-栈和队列（3.1-3.4）

已于 2024-05-08 17:40:54 修改
阅读量349 收藏 9
点赞数 4
分类专栏： 《严蔚敏 数据结构（C语言版）第二版》 文章标签： 数据结构 c语言版 c语言
于 2024-04-28 21:12:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44883214/article/details/138291460
版权

3.1 栈和队列的定义和特点

对于输入：先输入表头a1，最后输入表尾an.

栈：后进先出（Last In First Out， LIFO）线性表
表尾在栈顶（入、出），表头在栈底。
在这里插入图片描述
队列：先进先出（First In First Out，FIFO）线性表
表尾在队尾(入)，表头在队头(出)。
在这里插入图片描述

3.3 栈的表示和操作的实现

3.3.1 顺序栈的表示和实现

数据结构—c语言实现顺序栈的入栈，出栈，清空，销毁等操作—Chris-Chang

/*
顺序栈
栈的抽象数据类型
ADT 栈(stack)
Data
    同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系
Operation
    InitStack(*S)：初始化操作，建立一个空栈S
    ClearStack(*S):将栈清空
    StackEmpty(S):若栈为空，返回true,否则返回false
    GetTop(*S,*e):若栈存在且非空，用e返回S的栈顶元素
    Push(*S,e):若栈存在，插入新元素e到栈S中并成为栈顶元素
    Pop(*S,*e):删除栈S中栈顶元素，并用e返回其值
    StackTraverse(*S):遍历栈中所有元素
    StackLength(S):返回栈S的元素个数
endADT
 */

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

#define OVERFLOW        -1
#define STACK_INIT_SIZE 10
#define STACKINCREMENT   2
#define OK               1
#define ERROR            0
#define TRUE             1
#define FALSE            0

#define MAXSIZE          100    /*设定栈最大值*/

typedef int SElemType;  /*SElemType类型根据实际情况而定，这里假设为int*/
typedef int Status;

/*当栈存在一个元素时，top等于0,因此通常把空栈的条件定位top等于-1*/
/*栈的结构定义*/
typedef struct
{
    SElemType data[MAXSIZE];
    int top;  //数组data的下标
}SqStack;

/*算法3.1 初始化顺序栈*/
Status InitStack(SqStack* S)
{
    S->top = -1;
    return OK;
}

/*算法3.2 顺序栈的入栈，插入元素e为新的栈顶元素*/
Status Push(SqStack* S, SElemType e)
{
    if (S->top == MAXSIZE - 1)/*栈满*/
    {
        return ERROR;
    }
    S->top++;   /*栈顶指针增加一*/
    S->data[S->top] = e;  /*将新插入元素赋值给栈顶空间*/
    return OK;
}

/*算法3.3 顺序栈的出栈,若栈不为空，则删除s的栈顶元素，用e返回其值，并返回OK,否则返回ERROR*/
Status Pop(SqStack* S, SElemType* e)
{
    if (S->top == -1)
        return ERROR;   /*栈空*/
    *e = S->data[S->top];   /*将要删除的栈顶元素赋值给e*/
    S->top--;   /*栈顶指针减一*/
    return OK;
}

/*算法3.4 若栈非空，返回栈顶元素*/
Status GetTop(SqStack* S, SElemType* e)
{
    if (S->top == -1)return ERROR;
    else *e = S->data[S->top];
    return OK;
}

/*遍历栈中所有元素*/
Status StackTraverse(SqStack* S)
{
    int n, i;
    n = S->top;
    for (i = n; i >= 0; i--) {
        printf("%d ",(S->data[i]));
    }
    printf("\n");
    return OK;
}

/*返回栈S的元素个数*/
int StackLength(SqStack* S)
{
    return S->top + 1;
}

/*清空栈*/
Status ClearStack(SqStack* S)
{
    S->top = -1;
    return OK;
}

/*判断栈是否为空,-1为空*/
Status StackEmpty(SqStack* S)
{
    if (S->top == -1)
        return TRUE;
    else
        return FALSE;
}


int main()
{
    SqStack s;
    int e;
    printf("InitStack初始化栈并将1--12压入栈\n");
    if (InitStack(&s))
        for (e = 1; e <= 12; e++)
        {
            Push(&s, e);
        }
    printf("StackTraverse栈中元素从栈顶依次为:\n");
    StackTraverse(&s);
    Pop(&s, &e);
    printf("Pop弹出的元素为:%d\n", e);
    Pop(&s, &e);
    printf("Pop又弹出的元素为:%d\n", e);
    printf("Push将刚刚弹出的元素%d再次压入\n", e);
    Push(&s, e);
    printf("StackEmpty判断栈是否为空:%d(1:是 0:不是)\n", StackEmpty(&s));
    GetTop(&s, &e);
    printf("GetTop当前栈顶元素为:%d\n", e);
    printf("StackLength:当前栈长度为%d \n", StackLength(&s));
    ClearStack(&s);
    printf("ClearStack栈清空后，StackEmpty栈是否为空%d(1:是 0:不是)\n", StackEmpty(&s));
    return 0;
}

在这里插入图片描述

顺序栈—基本操作的实现及简单应用(C语言)（一）——阿里云开发者社区

malloc.h头文件和malloc函数详解 小马哥丶

malloc.h和stdlib.h的区别

c语言windows.h头文件详解 viafcccy

【C++】为何引入“引用“? 指针和引用有何区别?

3.3.1.1 顺序栈的初始化

#include<stdio.h>
#include<stdlib.h>
//#include<malloc.h>  //去掉
#include<windows.h>  //exit函数

#define OK       1     //出现OK相当于出现了1 
#define ERROR    0     //出现ERROR相当于出现了0
#define INFEASIBLE    -1 //不可行的
#define OVERFLOW      -2  //overflow一般用于exit的参数中

typedef int Status;
typedef int SElemType;

#define STACK_INIT_SIZE    10     //栈的储空间的初始分配量 
#define STACKINCREMENT     5      //栈的存储空间的分配增量

typedef struct {
    SElemType* top;        //栈顶指针 
    SElemType* base;       //栈底指针，在构造栈时和销毁栈时均为NULL 
    int stacksize;         //当前已经分配的存储空间 
}SqStack;

Status InitStack(SqStack& S);  //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。、

int main()
{
    //SElemType a[] = { 10 };
    //SElemType b = 20;
    //SElemType* pa = a;
    //SElemType* pb = &b;
    //SqStack N = { N.base = pa,N.top = pb,N.stacksize = 10 };

    SqStack N = { N.base = NULL,N.top = NULL,N.stacksize = 0 };  //必须初始化为空，而不能是其它实际值

    InitStack(N);
    return 0;
}

//构造一个空的顺序栈 
Status InitStack(SqStack& S)
{
    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));      
    //开辟一块连续的空间 
    //此处的S.base为一元数组SElemType S.base[STACK_INIT_SIZE]的基地址（首个元素的地址）。参见2.4.1 线性表的顺序存储表示

    if (!S.base)                //如果存储空间分配失败 
        exit(OVERFLOW);

    S.top = S.base;            //当栈为空栈时栈底和栈顶指针位置相同
    S.stacksize = STACK_INIT_SIZE;      //更新栈的空间大小
    return OK;
}

在这里插入图片描述

3.3.1.2 顺序栈的入栈

#include<stdio.h>
#include<stdlib.h>
//#include<malloc.h>  //去掉
#include<windows.h>  //exit函数

#define OK       1     //出现OK相当于出现了1 
#define ERROR    0     //出现ERROR相当于出现了0
#define INFEASIBLE    -1 //不可行的
#define OVERFLOW      -2  //overflow一般用于exit的参数中

typedef int Status;
typedef int SElemType;

#define STACK_INIT_SIZE    10     //栈的储空间的初始分配量 
#define STACKINCREMENT     5      //栈的存储空间的分配增量

typedef struct {
    SElemType* top;        //栈顶指针 
    SElemType* base;       //栈底指针，在构造栈时和销毁栈时均为NULL 
    int stacksize;         //当前已经分配的存储空间 
}SqStack;

Status InitStack(SqStack& S);  //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status ValueStack(SqStack& S, int Num);  //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status Push(SqStack& S, SElemType e); //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status PrintStack(SqStack S);

int main()
{
    //SElemType a[] = { 10 };
    //SElemType b = 20;
    //SElemType* pa = a;
    //SElemType* pb = &b;
    //SqStack N = { N.base = pa,N.top = pb,N.stacksize = 10 };

    SqStack N = { N.base = NULL,N.top = NULL,N.stacksize = 0 };  //必须初始化为空，而不能是其它实际值

    InitStack(N);
    ValueStack(N, 13);
    PrintStack(N);

    Push(N, 999);
    PrintStack(N);
    return 0;
}


//构造一个空的顺序栈 
Status InitStack(SqStack& S)
{
    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));      
    //开辟一块连续的空间 
    //此处的S.base为一元数组SElemType S.base[STACK_INIT_SIZE]的基地址（首个元素的地址）。参见2.4.1 线性表的顺序存储表示

    if (!S.base)                //如果存储空间分配失败 
        exit(OVERFLOW);

    S.top = S.base;            //当栈为空栈时栈底和栈顶指针位置相同
    S.stacksize = STACK_INIT_SIZE;      //更新栈的空间大小
    return OK;
}

//批量元素（从栈顶）入栈
Status ValueStack(SqStack& S, int Num)
{
    SElemType* Newbase = NULL;
	int length = 0;
	
    if (!S.base) {               //如果栈不存在 
        printf("栈不存在，元素无法入栈\n");
        return ERROR;
    }

    //判断传来的顺序栈中是否为空栈
    if (S.base != S.top) {         //如果不是空栈
    
		length = S.top - S.base;
		
        if (Num >= S.stacksize) {         //如果要入栈的元素数量大于栈的空间大小 
            //Num包括了原来已存在在栈的元素的个数，但是重新输入时，不用再输入已存在的数值。
            Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

            if (!Newbase) {         //如果存储空间分配失败 
                printf("存储空间分配失败\n");
                exit(OVERFLOW);
            }

            S.base = Newbase;
            /* 更新基地址base，看Newbase所在的位置还有没有足够的连续内存空间。
             ①如果有的话，分配更多的空间，（即使没有赋值那一步）返回的地址Newbase和原来的S.base相同；
             ②如果没有的话，在更大的空间内查找，如果找到(S.stacksize + STACKINCREMENT) * sizeof(SElemType)大小的空间，
             将旧的内容拷贝到新的内存中，把旧的内存释放掉，则返回新地址Newbase，如果分配内存失败则返回NULL.
             通过赋值语句将S.base指针也指到该Newbase处。*/
             
			S.top = S.base+ length;
            S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小 
        }


        int temp[] = { 0 };                  //定义一个辅助数组，方括号和花括号都不能少 

        for (int i = 1; i <= Num; i++) {
            printf("请输入第%d个元素的值：", i);
            scanf_s("%d", &temp[i - 1]);       //将之后输入的值暂时存储在临时数组中 
        }

        for (int j = 1; j <= Num; j++) {
            *S.top = temp[j - 1];
            //不能是S.top = &(temp[j - 1])，因为上面已经为S.base分配了连续的存储空间，要为该存储空间中依次存入值。而非更改指针S.top到其它的连续存储空间
            S.top++;
        }

        printf("%d个元素入栈成功\n", Num);
    }
    else 
    {
        if (Num >= S.stacksize) {    
            Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

            if (!Newbase) {        
                printf("存储空间分配失败\n");
                exit(OVERFLOW);
            }

            S.base = Newbase;
            S.top = Newbase;
            S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小 
        }
        
        for (int i = 1; i <= Num; i++) {
            printf("请输入第%d个值：", i);
            scanf_s("%d", &S.base[i - 1]); 
      		//或者用scanf_s("%d", S.top); 
            S.top++;
        }
        printf("%d个元素已入栈\n", Num);
    }

    //这条语句的目的是为了检测栈顶指针的位置是否在栈顶元素的下一个位置
    //如果输出的值等于输入元素的个数，则说明此时栈顶指针和栈底指针的位置都在正确的位置 
    printf("S.top - S.base = %d\n", S.top - S.base);
    return OK;
}

//插入新的栈顶元素并返回其值 
Status Push(SqStack& S, SElemType e)
{
    SElemType* Newbase = NULL;

    if (!S.base) {
        printf("顺序栈不存在，无法插入新的栈顶元素\n");
        return ERROR;
    }
    else if (S.top - S.base == S.stacksize)      //此时顺序栈已满，追加存储空间
    {
        Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

        if (!Newbase) {         //如果存储空间分配失败 
            printf("存储空间分配失败\n");
            exit(OVERFLOW);
        }

        S.base = Newbase;
        S.top = S.base + S.stacksize;
        S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小
    }

    //最后再写入新的栈顶元素
    *S.top = e;
    S.top++;
    return e;               //返回新插入的栈顶元素的值 
}

//打印顺序栈
Status PrintStack(SqStack S)
{
    int i = 0;

    if (!S.base) {
        printf("顺序栈不存在，无法打印\n");
        return ERROR;
    }
    else if (S.base == S.top)
        printf("顺序栈为空栈\n");

    printf("当前顺序栈的元素为：");
    for (i = 0; i < (S.top - S.base); i++) {
        printf(" %d", S.base[i]);
    }
/*此处跳出for循环时，最后一次将i++执行完毕之后，再进行i < (S.top - S.base)的判断，
 但是并没有再接着执行for循环中的printf语句,，而是直接跳出了for循环。
 因此此时的i并不是数组中最后一个元素的下标，而是最后一个元素的下一个元素的下标，也正好就是真正的栈的长度。*/

    printf("\nStack_Length : %d\n", i);
    //所以此处的length可直接使用i，不需要再加1，或直接使用S.top - S.base

    return OK;
}

在这里插入图片描述

3.3.1.3 顺序栈的出栈

#include<stdio.h>
#include<stdlib.h>
//#include<malloc.h>  //去掉
#include<windows.h>  //exit函数

#define OK       1     //出现OK相当于出现了1 
#define ERROR    0     //出现ERROR相当于出现了0
#define INFEASIBLE    -1 //不可行的
#define OVERFLOW      -2  //overflow一般用于exit的参数中

typedef int Status;
typedef int SElemType;

#define STACK_INIT_SIZE    10     //栈的储空间的初始分配量 
#define STACKINCREMENT     5      //栈的存储空间的分配增量

typedef struct {
    SElemType* top;        //栈顶指针 
    SElemType* base;       //栈底指针，在构造栈时和销毁栈时均为NULL 
    int stacksize;         //当前已经分配的存储空间 
}SqStack;

Status InitStack(SqStack& S);  //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status ValueStack(SqStack& S, int Num);  //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status Push(SqStack& S, SElemType e); //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status PrintStack(SqStack S);
SElemType Pop(SqStack& S);


int main()
{
    //SElemType a[] = { 10 };
    //SElemType b = 20;
    //SElemType* pa = a;
    //SElemType* pb = &b;
    //SqStack N = { N.base = pa,N.top = pb,N.stacksize = 10 };

    SqStack N = { N.base = NULL,N.top = NULL,N.stacksize = 0 };  //必须初始化为空，而不能是其它实际值


    InitStack(N);
    ValueStack(N, 13);
    PrintStack(N);

    Push(N, 999);
    PrintStack(N);

    printf("\n删除的栈顶元素为：%d\n",Pop(N));
    PrintStack(N);
    return 0;
}



//构造一个空的顺序栈 
Status InitStack(SqStack& S)
{
    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    //开辟一块连续的空间 
    //此处的S.base为一元数组SElemType S.base[STACK_INIT_SIZE]的基地址（首个元素的地址）。参见2.4.1 线性表的顺序存储表示

    if (!S.base)                //如果存储空间分配失败 
        exit(OVERFLOW);

    S.top = S.base;            //当栈为空栈时栈底和栈顶指针位置相同
    S.stacksize = STACK_INIT_SIZE;      //更新栈的空间大小
    return OK;
}

//批量元素（从栈顶）入栈
Status ValueStack(SqStack& S, int Num)
{
    SElemType* Newbase = NULL;
	int length = 0;
	
    if (!S.base) {               //如果栈不存在 
        printf("栈不存在，元素无法入栈\n");
        return ERROR;
    }

    //判断传来的顺序栈中是否为空栈
    if (S.base != S.top) {         //如果不是空栈
    
		length = S.top - S.base;
		
        if (Num >= S.stacksize) {         //如果要入栈的元素数量大于栈的空间大小 
            //Num包括了原来已存在在栈的元素的个数，但是重新输入时，不用再输入已存在的数值。
            Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

            if (!Newbase) {         //如果存储空间分配失败 
                printf("存储空间分配失败\n");
                exit(OVERFLOW);
            }

            S.base = Newbase;
            /* 更新基地址base，看Newbase所在的位置还有没有足够的连续内存空间。
             ①如果有的话，分配更多的空间，（即使没有赋值那一步）返回的地址Newbase和原来的S.base相同；
             ②如果没有的话，在更大的空间内查找，如果找到(S.stacksize + STACKINCREMENT) * sizeof(SElemType)大小的空间，
             将旧的内容拷贝到新的内存中，把旧的内存释放掉，则返回新地址Newbase，如果分配内存失败则返回NULL.
             通过赋值语句将S.base指针也指到该Newbase处。*/
             
			S.top = S.base+ length;
            S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小 
        }

        int temp[] = { 0 };                  //定义一个辅助数组，方括号和花括号都不能少 

        for (int i = 1; i <= Num; i++) {
            printf("请输入第%d个元素的值：", i);
            scanf_s("%d", &temp[i - 1]);       //将之后输入的值暂时存储在临时数组中 
        }

        for (int j = 1; j <= Num; j++) {
            *S.top = temp[j - 1];
            //不能是S.top = &(temp[j - 1])，因为上面已经为S.base分配了连续的存储空间，要为该存储空间中依次存入值。而非更改指针S.top到其它的连续存储空间
            S.top++;
        }

        printf("%d个元素入栈成功\n", Num);
    }
    else 
    {
        if (Num >= S.stacksize) {    
            Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

            if (!Newbase) {        
                printf("存储空间分配失败\n");
                exit(OVERFLOW);
            }

            S.base = Newbase;
            S.top = Newbase;

            S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小 
        }
        
        for (int i = 1; i <= Num; i++) {
            printf("请输入第%d个值：", i);
            scanf_s("%d", &S.base[i - 1]);
            //或者用scanf_s("%d", S.top); 
            S.top++;
        }
        printf("%d个元素已入栈\n", Num);
    }

    //这条语句的目的是为了检测栈顶指针的位置是否在栈顶元素的下一个位置
    printf("S.top - S.base = %d\n", S.top - S.base);
    return OK;
}

//插入新的栈顶元素并返回其值 
Status Push(SqStack& S, SElemType e)
{
    SElemType* Newbase = NULL;

    if (!S.base) {
        printf("顺序栈不存在，无法插入新的栈顶元素\n");
        return ERROR;
    }
    else if (S.top - S.base == S.stacksize)      //此时顺序栈已满，追加存储空间
    {
        Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

        if (!Newbase) {         //如果存储空间分配失败 
            printf("存储空间分配失败\n");
            exit(OVERFLOW);
        }

        S.base = Newbase;
        S.top = S.base + S.stacksize;
        S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小
    }

    //最后再写入新的栈顶元素
    *S.top = e;
    S.top++;
    return e;               //返回新插入的栈顶元素的值 
}

//打印顺序栈
Status PrintStack(SqStack S)
{
    int i = 0;

    if (!S.base) {
        printf("顺序栈不存在，无法打印\n");
        return ERROR;
    }
    else if (S.base == S.top)
        printf("顺序栈为空栈\n");

    printf("当前顺序栈的元素为：");
    for (i = 0; i < (S.top - S.base); i++) {
        printf(" %d", S.base[i]);
    }
    printf("\nStack_Length : %d\n", i);
    //所以此处的length可直接使用i，不需要再加1，或直接使用S.top - S.base

    return OK;
}

SElemType Pop(SqStack& S)
{
	SElemType e;

	if (!S.base)
	{
		printf("删除栈顶元素时，栈不存在");
		return ERROR;
	}
	else if (S.base == S.top)
	{
		printf("删除栈顶元素时，栈为空");
	}

	e = *(S.top-1);
	S.top--;
	return e;
}

在这里插入图片描述

3.3.1.4 取顺序栈的栈顶元素

#include<stdio.h>
#include<stdlib.h>
//#include<malloc.h>  //去掉
#include<windows.h>  //exit函数

#define OK       1     //出现OK相当于出现了1 
#define ERROR    0     //出现ERROR相当于出现了0
#define INFEASIBLE    -1 //不可行的
#define OVERFLOW      -2  //overflow一般用于exit的参数中

typedef int Status;
typedef int SElemType;

#define STACK_INIT_SIZE    10     //栈的储空间的初始分配量 
#define STACKINCREMENT     5      //栈的存储空间的分配增量

typedef struct {
    SElemType* top;        //栈顶指针 
    SElemType* base;       //栈底指针，在构造栈时和销毁栈时均为NULL 
    int stacksize;         //当前已经分配的存储空间 
}SqStack;

Status InitStack(SqStack& S);  //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status ValueStack(SqStack& S, int Num);  //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status Push(SqStack& S, SElemType e); //必须使用c++中的引用传址机制，从而得以直接对所传入的对象进行修改。
Status PrintStack(SqStack S);
SElemType Pop(SqStack& S);
SElemType GetTop(SqStack S);

int main()
{
    //SElemType a[] = { 10 };
    //SElemType b = 20;
    //SElemType* pa = a;
    //SElemType* pb = &b;
    //SqStack N = { N.base = pa,N.top = pb,N.stacksize = 10 };

    SqStack N = { N.base = NULL,N.top = NULL,N.stacksize = 0 };  //必须初始化为空，而不能是其它实际值


    InitStack(N);
    ValueStack(N, 13);
    PrintStack(N);

    Push(N, 999);
    PrintStack(N);

    printf("\n删除的栈顶元素为：%d\n",Pop(N));
    PrintStack(N);
    printf("\n新的栈顶元素为：%d", GetTop(N));
    return 0;
}



//构造一个空的顺序栈 
Status InitStack(SqStack& S)
{
    S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    //开辟一块连续的空间 
    //此处的S.base为一元数组SElemType S.base[STACK_INIT_SIZE]的基地址（首个元素的地址）。参见2.4.1 线性表的顺序存储表示

    if (!S.base)                //如果存储空间分配失败 
        exit(OVERFLOW);

    S.top = S.base;            //当栈为空栈时栈底和栈顶指针位置相同
    S.stacksize = STACK_INIT_SIZE;      //更新栈的空间大小
    return OK;
}

//批量元素（从栈顶）入栈
Status ValueStack(SqStack& S, int Num)
{
    SElemType* Newbase = NULL;
	int length = 0;
	
    if (!S.base) {               //如果栈不存在 
        printf("栈不存在，元素无法入栈\n");
        return ERROR;
    }

    //判断传来的顺序栈中是否为空栈
    if (S.base != S.top) {         //如果不是空栈
    
		length = S.top - S.base;
		
        if (Num >= S.stacksize) {         //如果要入栈的元素数量大于栈的空间大小 
            //Num包括了原来已存在在栈的元素的个数，但是重新输入时，不用再输入已存在的数值。
            Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

            if (!Newbase) {         //如果存储空间分配失败 
                printf("存储空间分配失败\n");
                exit(OVERFLOW);
            }

            S.base = Newbase;
            /* 更新基地址base，看Newbase所在的位置还有没有足够的连续内存空间。
             ①如果有的话，分配更多的空间，（即使没有赋值那一步）返回的地址Newbase和原来的S.base相同；
             ②如果没有的话，在更大的空间内查找，如果找到(S.stacksize + STACKINCREMENT) * sizeof(SElemType)大小的空间，
             将旧的内容拷贝到新的内存中，把旧的内存释放掉，则返回新地址Newbase，如果分配内存失败则返回NULL.
             通过赋值语句将S.base指针也指到该Newbase处。*/
             
			S.top = S.base+ length;
            S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小 
        }

        int temp[] = { 0 };                  //定义一个辅助数组，方括号和花括号都不能少 

        for (int i = 1; i <= Num; i++) {
            printf("请输入第%d个元素的值：", i);
            scanf_s("%d", &temp[i - 1]);       //将之后输入的值暂时存储在临时数组中 
        }

        for (int j = 1; j <= Num; j++) {
            *S.top = temp[j - 1];
            //不能是S.top = &(temp[j - 1])，因为上面已经为S.base分配了连续的存储空间，要为该存储空间中依次存入值。而非更改指针S.top到其它的连续存储空间
            S.top++;
        }

        printf("%d个元素入栈成功\n", Num);
    }
    else 
    {
        if (Num >= S.stacksize) {    
            Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

            if (!Newbase) {        
                printf("存储空间分配失败\n");
                exit(OVERFLOW);
            }

            S.base = Newbase;
            S.top = Newbase;

            S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小 
        }
        
        for (int i = 1; i <= Num; i++) {
            printf("请输入第%d个值：", i);
            scanf_s("%d", &S.base[i - 1]);
            //或者用scanf_s("%d", S.top); 
            S.top++;
        }
        printf("%d个元素已入栈\n", Num);
    }

    //这条语句的目的是为了检测栈顶指针的位置是否在栈顶元素的下一个位置
    printf("S.top - S.base = %d\n", S.top - S.base);
    return OK;
}

//插入新的栈顶元素并返回其值 
Status Push(SqStack& S, SElemType e)
{
    SElemType* Newbase = NULL;

    if (!S.base) {
        printf("顺序栈不存在，无法插入新的栈顶元素\n");
        return ERROR;
    }
    else if (S.top - S.base == S.stacksize)      //此时顺序栈已满，追加存储空间
    {
        Newbase = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));

        if (!Newbase) {         //如果存储空间分配失败 
            printf("存储空间分配失败\n");
            exit(OVERFLOW);
        }

        S.base = Newbase;
        S.top = S.base + S.stacksize;
        S.stacksize = S.stacksize + STACKINCREMENT;         //更新栈的空间大小
    }

    //最后再写入新的栈顶元素
    *S.top = e;
    S.top++;
    return e;               //返回新插入的栈顶元素的值 
}

//打印顺序栈
Status PrintStack(SqStack S)
{
    int i = 0;

    if (!S.base) {
        printf("顺序栈不存在，无法打印\n");
        return ERROR;
    }
    else if (S.base == S.top)
        printf("顺序栈为空栈\n");

    printf("当前顺序栈的元素为：");
    for (i = 0; i < (S.top - S.base); i++) {
        printf(" %d", S.base[i]);
    }
    printf("\nStack_Length : %d\n", i);
    //所以此处的length可直接使用i，不需要再加1，或直接使用S.top - S.base

    return OK;
}

SElemType Pop(SqStack& S)
{
	SElemType e;

	if (!S.base)
	{
		printf("删除栈顶元素时，栈不存在");
		return ERROR;
	}
	else if (S.base == S.top)
	{
		printf("删除栈顶元素时，栈为空");
	}

	e = *(S.top-1);
	S.top--;
	return e;
}

//取顺序栈顶栈顶元素(栈顶指针不变)
SElemType GetTop(SqStack S)
{

    if (!S.base)
    {
        printf("取顺序栈栈顶元素时，栈不存在");
        return ERROR;
    }
    else if (S.base == S.top)
    {
        printf("取顺序栈栈顶元素时，栈为空");
    }

    return *(S.top - 1);
}

在这里插入图片描述

3.3.2 链栈的表示和实现

3.3.2.1 链栈的初始化

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

typedef struct StackNode
{
	int data;
	struct StackNode* next;
}*LinkStack;

void initStack(LinkStack &S);

int main()
{
	struct StackNode* N = NULL;
	initStack(N);
	return 0;
}

//算法3.5 链栈的初始化
void initStack(LinkStack& S)
{
	//S是链栈的栈顶指针
	S = NULL;
	printf("初始化链栈成功。\n");
}

在这里插入图片描述

3.3.2.2 链栈的入栈

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

typedef struct StackNode
{
	int data;
	struct StackNode* next;
}*LinkStack;

void initStack(LinkStack &S);
void ValueStack(LinkStack& S);
void Push(LinkStack& S, int e);
void printStack(LinkStack& S);

int main()
{
	struct StackNode* N = NULL;
	initStack(N);

	ValueStack(N);
	printStack(N);

	printf("\n");
	Push(N, 999);
	printStack(N);
	return 0;
}

//算法3.5 链栈的初始化
void initStack(LinkStack& S)
{
	//S是链栈的栈顶指针
	S = NULL;
	printf("初始化链栈成功。\n");
}

//批量元素从栈顶入栈
void ValueStack(LinkStack& S)
{
	int len = 0;
	int i = 0;
	int num = 0;

	printf("请输入链栈的长度：");
	scanf_s("%d", &len);

	for (i = 1; i <= len; i++)
	{
		printf("请输入第%d个元素的值：", i);
		scanf_s("%d", &num);

		struct StackNode* p = (struct StackNode*)malloc(sizeof(struct StackNode));
		p->data = num;
		p->next = S;
		S = p;
		printf("元素%d入栈成功。\n", num);
	}

	printf("%d个元素入栈成功。\n", i - 1);
}

//算法3.6 链栈的入栈
void Push(LinkStack& S, int e)
{
	//在栈顶插入元素e
	struct StackNode* p = (struct StackNode*)malloc(sizeof(struct StackNode));
	p->data = e;
	p->next = S;
	S = p;
	printf("元素%d入栈成功。\n", e);
}

//打印链栈
void printStack(LinkStack& S)
{
	struct StackNode* pMove = S;
	int i = 0;

	printf("链栈中的元素为：");
	while (pMove)
	{
		printf("%d ", pMove->data);
		pMove = pMove->next;
		i++;
	}

	printf("\nStack_Length : %d\n", i );
}

在这里插入图片描述

3.3.2.3 链栈的出栈

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

#define ERROR -2

typedef struct StackNode
{
	int data;
	struct StackNode* next;
}*LinkStack;

void initStack(LinkStack& S);
void ValueStack(LinkStack& S);
void Push(LinkStack& S, int e);
void printStack(LinkStack& S);
int Pop(LinkStack& S);

int main()
{
	struct StackNode* N = NULL;
	initStack(N);

	ValueStack(N);
	printStack(N);

	printf("\n");
	Push(N, 999);
	printStack(N);

	printf("删除的栈顶元素为：%d\n", Pop(N));
	printStack(N);
	return 0;
}

//算法3.5 链栈的初始化
void initStack(LinkStack& S)
{
	//S是链栈的栈顶指针
	S = NULL;
	printf("初始化链栈成功。\n");
}

//批量元素从栈顶入栈
void ValueStack(LinkStack& S)
{
	int len = 0;
	int i = 0;
	int num = 0;

	printf("请输入链栈的长度：");
	scanf_s("%d", &len);

	for (i = 1; i <= len; i++)
	{
		printf("请输入第%d个元素的值：", i);
		scanf_s("%d", &num);

		struct StackNode* p = (struct StackNode*)malloc(sizeof(struct StackNode));
		p->data = num;
		p->next = S;
		S = p;
		printf("元素%d入栈成功。\n", num);
	}

	printf("%d个元素入栈成功。\n", i - 1);
}

//算法3.6 链栈的入栈
void Push(LinkStack& S, int e)
{
	//在栈顶插入元素e
	struct StackNode* p = (struct StackNode*)malloc(sizeof(struct StackNode));
	p->data = e;
	p->next = S;
	S = p;
	printf("元素%d入栈成功。\n", e);
}

//打印链栈
void printStack(LinkStack& S)
{
	struct StackNode* pMove = S;
	int i = 0;

	printf("链栈中的元素为：");
	while (pMove)
	{
		printf("%d ", pMove->data);
		pMove = pMove->next;
		i++;
	}

	printf("\nStack_Length : %d\n", i);
}


//算法3.7 链栈的出栈
int Pop(LinkStack& S)
{
	int e = 0;

	if (S == NULL)
	{
		printf("删除栈顶元素时，栈为空。\n");
		return ERROR;
	}

	e = S->data;

	LinkStack p = S;
	S = S->next;
	free(p);
	return e;
}

在这里插入图片描述

3.3.2.4 取链栈的栈顶元素

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

#define ERROR -2

typedef struct StackNode
{
	int data;
	struct StackNode* next;
}*LinkStack;

void initStack(LinkStack& S);
void ValueStack(LinkStack& S);
void Push(LinkStack& S, int e);
void printStack(LinkStack& S);
int Pop(LinkStack& S);
int GetTop(LinkStack S);

int main()
{
	struct StackNode* N = NULL;
	initStack(N);

	ValueStack(N);
	printStack(N);

	printf("\n");
	Push(N, 999);
	printStack(N);

	printf("删除的栈顶元素为：%d\n", Pop(N));
	printStack(N);
	printf("新的栈顶元素为：%d\n", GetTop(N));
	return 0;
}

//算法3.5 链栈的初始化
void initStack(LinkStack& S)
{
	//S是链栈的栈顶指针
	S = NULL;
	printf("初始化链栈成功。\n");
}

//批量元素从栈顶入栈
void ValueStack(LinkStack& S)
{
	int len = 0;
	int i = 0;
	int num = 0;

	printf("请输入链栈的长度：");
	scanf_s("%d", &len);

	for (i = 1; i <= len; i++)
	{
		printf("请输入第%d个元素的值：", i);
		scanf_s("%d", &num);

		struct StackNode* p = (struct StackNode*)malloc(sizeof(struct StackNode));
		p->data = num;
		p->next = S;
		S = p;
		printf("元素%d入栈成功。\n", num);
	}

	printf("%d个元素入栈成功。\n", i - 1);
}

//算法3.6 链栈的入栈
void Push(LinkStack& S, int e)
{
	//在栈顶插入元素e
	struct StackNode* p = (struct StackNode*)malloc(sizeof(struct StackNode));
	p->data = e;
	p->next = S;
	S = p;
	printf("元素%d入栈成功。\n", e);
}

//打印链栈
void printStack(LinkStack& S)
{
	struct StackNode* pMove = S;
	int i = 0;

	printf("链栈中的元素为：");
	while (pMove)
	{
		printf("%d ", pMove->data);
		pMove = pMove->next;
		i++;
	}

	printf("\nStack_Length : %d\n", i);
}

//算法3.7 链栈的出栈
int Pop(LinkStack& S)
{
	int e = 0;

	if (S == NULL)
	{
		printf("删除栈顶元素时，栈为空。\n");
		return ERROR;
	}

	e = S->data;

	LinkStack p = S;
	S = S->next;
	free(p);
	return e;
}

//算法3.8 取链栈的栈顶元素
int GetTop(LinkStack S)  //因为没有对S中的元素进行更改，所以不需要使用引用
{
	if (S == NULL)
	{
		printf("取栈顶元素时，栈为空。\n");
	}

	return S->data;
}

在这里插入图片描述

3.4 栈与递归

Hanoi塔问题的的递归算法

汉诺塔——经典递归问题（c语言实现）——lucas_dd

此问题难点是：
先抽象出对象较大的每一步1、2、3，
对象较大的每一步（如1）中再抽象出由对象较小的构成的每一步（如1.1、1.2、1.3），
且由对象较小的构成的每一步1.1、1.2、1.3，要跟对象较大的步骤1、2、3是相同或类同的。

1.1还可以往下接着抽象出同样与1、2、3相同或类同的1.1.1、1.1.2、1.1.3.

【此问题中的实例：
问题：将a座上的n个盘子借助b座移向c座

  1. 将A座上的n-1个盘子借助C座移向B座
  2. 将A座上最后一个盘子移向C座
  3. 将B座上的n-1个盘子借助A座移向C座

将步骤“1. 将A座上的n-1个盘子借助C座移向B座”抽象出下面的步骤：

1.1 将A座上的n-2个盘子借助b座移向C座
1.2 将A座上最后一个盘子移向B座
1.3 将C座上的n-2个盘子借助A座移向B座

要求：1.1、1.2、1.3 与 1、2、3是相同或类同的。】

1.2、1.3也同样如此。2、3也同样如此。
如此往下不断细分。
【以上即为递归分解过程】

每一个分支都只有达到递归结束的条件，才能停止细分，执行递归结束的语句，并依次向一层返回结果。
【此类步骤即为递归求值过程】

//算法3.10 Hanoi塔问题的的递归算法
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

//将x座上最后一个盘子移向y座
void move(int x, int y)
{
	printf("%c->%c\n", x, y);
}

//将a座上的n个盘子借助b座移向c座
void hanoi(int n, char a, char b, char c)
{
	if (n == 1)
	{
		move(a, c);
	}
	else
	{
		hanoi(n - 1, a, c, b);//将A座上的n-1个盘子借助C座移向B座
		move(a, c);//将A座上最后一个盘子移向C座
		hanoi(n - 1, b, a, c);//将B座上的n-1个盘子借助A座移向C座
	}
}
//move中的实参与hanoi函数中的形参相对应，而hanoi函数中形参a，b，c所对应的值也是在有规律的变化


int main()
{
	int n = 0;
	scanf("%d", &n);
	hanoi(n, 'A', 'B', 'C');
	return 0;
}

在这里插入图片描述

Flerken101
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（c语言版） 第三章 栈和队列
qq_52418289的博客
08-21 551
数据结构（c语言版） 第三章 栈和队列 栈： 抽象数据栈的定义： 栈（stack）栈是限定仅在表尾进行插入或删除操作的线性表，因此表尾对栈有着特殊的含义，称为栈顶（top),相应表头成为栈底（bottom)，不含元素的空表称为空栈。 因为栈的进出都是从表尾进行插入和删除，于是又叫后进先出（last in first out)也能叫先进后出。 栈的表示和实现 线性表类似，对于栈来说，也有两种存储结构（1）顺序栈（2）链式栈 （1）顺序栈： 顺序栈的结构结构体单位我们一般有两个指针和一个整型数据，其中整
数据结构（C语言版）学习笔记（第三章：栈和队列）
Z_2nd的博客
09-29 485
数据结构学习笔记（第三章：栈和队列）栈栈的基本概念与定义 栈 栈的基本概念与定义
栈以及队列的实现与基本操作
一个计算机爱好者学习历程
12-02 1435
目录 一、栈 1.栈的基本概念 2.如何实现一个栈 1.>用数组实现一个可以动态增长的栈（建议） 2.>栈的链式存储 3.栈的基本操作 1.>栈的创建 2.>栈的初始化 3.>入栈操作 4.>出栈操作 5.>获取栈顶元素 6.>栈空的判断 7.>栈的销毁 二、队列 1.队列的基本概念 2.如何实现一个基本队列 1.>顺序队的实现 2.>链队的实现 3.>循环队列的实现 3.队列的基本操作（..
3.1 栈—栈的存储实现和运算实现
weixin_30865427的博客
04-20 327
由于栈是运算受限的线性表，因此线性表的存储结构对栈也是适用的，只是操作不同而已。 1． 顺序栈 利用顺序存储方式实现的栈称为顺序栈。类似于顺序表的定义，栈中的数据元素用一个预设的足够长度的一维数组来实现：datatype data[MAXSIZE]，栈底位置可以设置在数组的任一个端点，而栈顶是随着插入和删除而变化的，用一个int top 来作为栈顶的指针，指明当前栈顶的位置，同样将data 和...
栈的基本操作(C语言实现)
热门推荐
Brant_zero的博客
06-27 1万+
期末终于结束，接下来就会继续更新数据结构相关的内容了，本篇文章带来数据结构——栈，来实现它的基本功能。难度偏低，因为之前我们已经实现过顺序表了，栈不过是顺序表的一种特殊形式。接下来我们来看看我们栈的类型定义以及我们此次要实现的功能。...
数据结构学习——C语言对栈的基本操作
weixin_63586719的博客
07-28 5581
栈(Stack)是一种常用的数据结构，遵循先进后出(LIFO)的原则，对表尾进行操作，常用于临时存储和撤销等操作，其基本操作包括栈的创建、入栈(也叫压栈Push)、出栈(又称弹栈)、栈的遍历、栈的清空(clear)、栈的销毁(destroy)等。
编程珠玑 第二版 修订版
11-01
第3章　数据决定程序结构 21 3.1　一个调查程序 21 3.2　格式信函编程 23 3.3　一组示例 25 3.4　结构化数据 26 3.5　用于特殊数据的强大工具 27 3.6　原理 28 3.7　习题 29 3.8　深入阅读 30 第4章　编写正确的程序...
数据结构之并查集
我要学编程的博客
08-21 1179
并查集相关概念、模拟实现并查集、并查集的应用：省份的数量、等式方程的可满足行
【Java & 数据结构】初识二叉树
qq_42150700的博客
08-20 681
树是一种非线性的数据结构, 也就是说它和我们前面学习的顺序表链表之类的不太一样. 那些数据结构要求中间的元素都只有一个前驱和后继, 而树型结构的中间元素则允许有多个后继.例如下面这个就是一个树形结构为什么叫这种结构为树形结构呢?这是因为它的结构长的就像一颗倒过来的树, 最上面是树根, 最下面则是叶子.下面我们看几个例子, 来认识一下树形结构的注意点下面的这个结构, 就不是一个树形结构, 原因是其中间在同一层的节点, 是不可以相连的, 中间的节点只允许和上层节点和下层节点进行连接.
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 897
完全二叉堆：批量建堆
Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
2301_80689220的博客
08-21 229
【代码】Leetcode每日刷题之1658.将x减到0的最小操作数(C++)
二叉树(源码+lw+部署文档+讲解等)
lpw1012的博客
08-21 723
🌞博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序技术领域和毕业项目实战，以及程序定制化开发、全栈讲解、就业辅导✌🌞👇🏻精彩专栏 推荐订阅👇🏻2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅Java精品实战案例《500套》
【冒泡排序算法】输入n个数进行排序
最新发布
qq_64108165的博客
08-24 358
输入n个数进行排序，使用冒泡排序算法
数据结构-栈与队列-数组和链表的推广运用-第六天
qq_33867768的博客
08-24 410
总结： 1. 栈是一种先入后出的数据结构，类似于“铁饼堆叠游戏”。2. 队列是一种先入先出的数据结构，类似于“数据进入不能回头的管道”。
数据结构-堆(二叉树的特殊)-第四天
qq_33867768的博客
08-21 210
堆是一棵完全二叉树，根据成立条件可分为大顶堆和小顶堆。大（小）顶堆的堆顶元素是最大（小）的。堆（Heap）是一种特殊的完全二叉树数据结构，通常用于实现优先队列。它是一种完全二叉树，除了最后一层外，每一层都是完全填充的。最后一层的所有节点都尽可能地靠左排列。堆中的每个节点的值与其子节点的值之间有一定的关系，这取决于堆的类型。堆是一种高效的数据结构，通常用于实现优先队列和排序算法。
【数据结构-前缀异或和】1442. 形成两个异或相等数组的三元组数目
sjsjs11的博客
08-20 449
首先第一个哈希表cnt是用来在遍历k，计算k+1的前缀异或和的时候，是否有对应的 i 的前缀异或和一样。那么在遍历 k 的时候，就可以根据当前的前缀异或和来查找之前相同前缀异或和的个数cnt[s ^ val]。解释：满足题意的三元组分别是 (0,1,2), (0,2,2), (2,3,4) 以及 (2,4,4)输入：arr = [7,11,12,9,5,2,7,17,22]输入：arr = [2,3,1,6,7]输入：arr = [1,1,1,1,1]输入：arr = [1,3,5,7,9]
数据结构-树(二叉树)-第三天
qq_33867768的博客
08-21 327
二叉树（binary tree）是一种非线性数据结构，代表“祖先”与“后代”之间的派生关系，体现了“一分为二”的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含值、左子节点引用和右子节点引用。/* 二叉树节点结构体 */int val;// 节点值// 左子节点指针// 右子节点指针每个节点都有两个引用（指针），分别指向左子节点（left-child node）和右子节点（right-child node），该节点被称为这两个子节点的父节点（parent node）。
数据结构（Java）：揭开二叉搜索树删除机制的奥秘
2401_83595513的博客
08-19 2423
二叉搜索树的模拟实现
【数据结构篇】~双向链表（附源码）
旺小仔的博客
08-21 359
【数据结构篇】~双向链表（附源码）
C语言版《数据结构要点精析》第二版详解
"《数据结构要点精析--C语言版(第2版)》由侯风巍编著，杨永田主审，是一部专为计算机专业学生和考研考生设计的教材。本书详尽讲解了数据结构的基础概念，包括线性表、栈与队列、串、数组与广义表、树与二叉树、图、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值