16-栈的几种用法_案例代码

最新推荐文章于 2022-06-11 21:25:12 发布
最新推荐文章于 2022-06-11 21:25:12 发布
阅读量203 收藏
点赞数
分类专栏： C 语言 文章标签： 栈 struct typedef
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/akpar00/article/details/54847024
版权

栈:

代码 1 : stack

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

//类型
typedef struct node{
    int *data;
    int top;
    int size;
}stacks_t;

//创建
stacks_t * create_stack(int size)
{
    if(size<0||size>1024)
        return NULL;

    stacks_t* stack=malloc(sizeof(stacks_t));

    stack->size=size;
    stack->top=-1;

    stack->data=malloc(sizeof(int)*size);

    return stack;

}

//判空
int isempty(stacks_t* stack)
{
    if(stack==NULL)
        return 0;

    return stack->top==-1;
}

//判满
int isfull(stacks_t* stack)
{
    if(stack==NULL)
        return 0;

    return stack->top==stack->size-1;
}

//入栈  push
int push_stack(stacks_t* stack,int data)
{
    if(stack==NULL||isfull(stack))
        return -1;

    stack->top++;

    stack->data[stack->top]=data;

    return 0;
}

//出栈
//不使用  返回值的情况下，把栈顶元素拿出来 放到某个变量里面去
//指针
int pop_stack(stacks_t* stack,int *data)//  int *  双向传参  可读可写   const  只读
{
    if(stack==NULL||isempty(stack)||data==NULL)
        return -1;

    *data=stack->data[stack->top--];

    return 0;
}

//打印  （假打印）
int print_stack_notreal(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return -1;

    int i;
    for(i=stack->top;i>=0;i--)
    {
        printf("%3d ",stack->data[i]);

    }
    printf("\n");

    return 0;
}

//看一眼  查看栈顶元素
int view_stack(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return -1;

    printf("%3d ",stack->data[stack->top]);

    return 0;

}

//清空
int clear_stack(stacks_t* stack)
{
    if(NULL==stack)
        return -1;

    stack->top=-1;

    return 0;
}

//销毁
int destroy_stack(stacks_t* stack)
{
    if(stack==NULL)
        return -1;

    free(stack->data);
    free(stack);
    return 0;
}

//长度
int length_stack(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return 0;

    return stack->top+1;
}

//真打印
int print_stack_real(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return -1;

    stacks_t* temp=create_stack(length_stack(stack));

    int data;
    while(!isempty(stack))
    {
        view_stack(stack);

        pop_stack(stack,&data);

        push_stack(temp,data);
    }
    printf("\n");

    while(!isempty(temp))
    {
        pop_stack(temp,&data);

        push_stack(stack,data);
    }

    destroy_stack(temp);

    return 0;
}


//真逆打印
int reprint_stack_real(stacks_t* stack)
{
    if(stack==NULL||isempty(stack))
        return -1;

    stacks_t* temp=create_stack(length_stack(stack));

    int data;
    while(!isempty(stack))
    {
        pop_stack(stack,&data);

        push_stack(temp,data);
    }

    while(!isempty(temp))
    {
        view_stack(temp);

        pop_stack(temp,&data);

        push_stack(stack,data);
    }
    printf("\n");

    destroy_stack(temp);

    return 0;
}


int main(int argc, const char *argv[])
{
    stacks_t* stack=create_stack(30);

    int i;

    for(i=1;i<=15;i++)
    {
        push_stack(stack,i);
        print_stack_notreal(stack);

    }

    print_stack_real(stack);
    reprint_stack_real(stack);
    print_stack_notreal(stack);

    return 0;
}

代码 2 : linkstack

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

typedef struct node{
    int data;
    struct node * next;
}linkstack_t;

//创建
linkstack_t* create_stack()
{
    linkstack_t* stack=malloc(sizeof(linkstack_t));
    stack->next=NULL;
    return stack;
}

//判空
int isempty_stack(linkstack_t* stack)
{
    if(stack==NULL)
        return 0;

    return stack->next==NULL;
}

//入栈
int push_stack(linkstack_t* stack,int data)
{
    if(stack==NULL)
        return -1;

    linkstack_t* newnode=create_stack();
    newnode->data=data;
    newnode->next=stack->next;
    stack->next=newnode;

    return 0;
}

//出栈
int pop_stack(linkstack_t* stack,int *data)
{
    if(stack==NULL||isempty_stack(stack))
        return -1;


    linkstack_t* temp=stack->next;

    *data=temp->data;

    stack->next=temp->next;

    free(temp);

    return 0;
}

//假打印
int print_stack_notreal(linkstack_t* stack)
{
    if(stack==NULL||isempty_stack(stack))
        return -1;

    while(stack->next!=NULL)
    {
        printf("%3d ",stack->next->data);

        stack=stack->next;

    }
    printf("\n");

    return 0;
}

//清空
int clear_stack(linkstack_t* stack)
{
    if(stack==NULL)
        return -1;

    int data;
    while(!isempty_stack(stack))
    {
        pop_stack(stack,&data);
    }

    return 0;
}

//销毁
int destroy_stack(linkstack_t* stack)
{
    if(NULL==stack)
        return -1;

    if(!isempty_stack(stack))
        clear_stack(stack);

    free(stack);

    return 0;
}

//真打印
int print_stack_real(linkstack_t* stack)
{
    if(stack==NULL||isempty_stack(stack))
        return -1;

    int data;

    linkstack_t* temp=create_stack();

    while(!isempty_stack(stack))
    {
        pop_stack(stack,&data);

        printf("%3d ",data);

        push_stack(temp,data);
    }
    printf("\n");

    while(!isempty_stack(temp))
    {
        pop_stack(temp,&data);

        push_stack(stack,data);
    }

    destroy_stack(temp);

    return 0;
}

//真逆打印
int reprint_stack_real(linkstack_t* stack)
{
    if(stack==NULL||isempty_stack(stack))
        return -1;

    int data;

    linkstack_t* temp=create_stack();

    while(!isempty_stack(stack))
    {
        pop_stack(stack,&data);

        push_stack(temp,data);
    }

    while(!isempty_stack(temp))
    {
        pop_stack(temp,&data);

        printf("%3d ",data);

        push_stack(stack,data);
    }
    printf("\n");

    destroy_stack(temp);

    return 0;
}

int main(int argc, const char *argv[])
{

    linkstack_t* stack=create_stack();

    int i;

    for(i=1;i<=20;i++)
    {
        push_stack(stack,i);
        print_stack_real(stack);
    }

    int data;
    for(i=1;i<=20;i++)
    {
        pop_stack(stack,&data);

        reprint_stack_real(stack);
    }

    return 0;
}

代码 3 : linkqueue

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

typedef struct node{
    int data;
    struct node* next;
}list_t;


typedef struct queuenode{

    list_t* head;
    list_t* tail;

}queue_t;

//创建
queue_t* create_queue()
{
    queue_t* queue=malloc(sizeof(queue_t));

    queue->head=malloc(sizeof(list_t));
    queue->head->next=NULL;

    queue->tail=queue->head;

    return queue;

}

//判空
int isempty(queue_t* queue)
{
    if(queue==NULL)
        return 0;

    return queue->head->next==NULL;

}

//入队
int push_queue(queue_t* queue,int data)
{
    if(queue==NULL)
        return -1;

    list_t* newnode=malloc(sizeof(list_t));
    newnode->next=NULL;
    newnode->data=data;

    queue->tail->next=newnode;

    queue->tail=newnode;

    return 0;
}

//出队
int pop_queue(queue_t* queue,int *data)
{
    //尝试 全部取出数据，再放入几个数据，再打印看一下，删除真的没问题么？？？？
    //坑？？？？:
    if(queue==NULL||isempty(queue))
        return -1;

    list_t* temp=queue->head->next;

    if(temp==queue->tail)
        queue->tail=queue->head;

    *data=temp->data;

    queue->head->next=temp->next;

    free(temp);

    return 0;

}

//长度
int length_queue(queue_t* queue)
{

    if(queue==NULL||isempty(queue))
        return 0;

    list_t* temp=queue->head;

    int sum=0;
    while(temp->next!=NULL)
    {
        sum++;
        temp=temp->next;
    }

    return sum;
}

//假打印
int print_queue_notreal(queue_t* queue)
{
    if(queue==NULL||isempty(queue))
        return -1;

    list_t* temp=queue->head;

    while(temp->next!=NULL)
    {
        printf("%3d ",temp->next->data);
        temp=temp->next;
    }
    printf("\n");

    return 0;
}

//清空
int clear_queue(queue_t* queue)
{
    if(queue==NULL||isempty(queue))
        return -1;

    int data;

    while(!isempty(queue))
    {
        pop_queue(queue,&data);

    }
    return 0;
}

//销毁
int destroy_queue(queue_t* queue)
{
    if(queue==NULL)
        return -1;

    if(!isempty(queue))
        clear_queue(queue);

    free(queue->head);
    free(queue);

    return 0;
}

//真正打印1
int print_queue_real(queue_t* queue)
{
    if(queue==NULL||isempty(queue))
        return -1;

    queue_t* temp=create_queue();

    int data;
    while(!isempty(queue))
    {
        pop_queue(queue,&data);

        printf("%3d ",data);

        push_queue(temp,data);
    }
    printf("\n");

    while(!isempty(temp))
    {
        pop_queue(temp,&data);

        push_queue(queue,data);
    }
    destroy_queue(temp) ;

    return 0;
}

//真正打印2
int print_queue_real2(queue_t* queue)
{
    if(queue==NULL||isempty(queue))
        return -1;

    int *stack1=malloc(sizeof(int)*length_queue(queue));

    int top1=-1;

    int *stack2=malloc(sizeof(int)*length_queue(queue));

    int top2=-1;

    int data;
    while(!isempty(queue))
    {
        pop_queue(queue,&data);
        printf("%3d ",data);

        stack1[++top1]=data;
    }

    while(top1!=-1)
    {
        data=stack1[top1--];

        stack2[++top2]=data;
    }

    while(top2!=-1)
    {
        data=stack2[top2--];

        push_queue(queue,data);
    }

    printf("\n");

    free(stack1);
    free(stack2);

    return 0;
}

//真逆打印
int reprint_queue_real(queue_t* queue)//经典面试题：两个栈实现一个队列功能
{
    if(queue==NULL||isempty(queue))
        return -1;

    int *stack1=malloc(sizeof(int)*length_queue(queue));

    int top1=-1;

    int *stack2=malloc(sizeof(int)*length_queue(queue));

    int top2=-1;

    int data;
    while(!isempty(queue))
    {
        pop_queue(queue,&data);

        stack1[++top1]=data;
    }

    while(top1!=-1)
    {
        data=stack1[top1--];

        printf("%3d ",data);

        stack2[++top2]=data;
    }

    while(top2!=-1)
    {
        data=stack2[top2--];

        push_queue(queue,data);
    }

    printf("\n");

    free(stack1);
    free(stack2);

    return 0;
}

int main(int argc, const char *argv[])
{
    queue_t* queue=create_queue();

    int i;
    for(i=1;i<=15;i++)
    {
        push_queue(queue,i*2);
        print_queue_real(queue);
    }

    reprint_queue_real(queue);

    print_queue_real2(queue);
    print_queue_real(queue);
    print_queue_notreal(queue);

    return 0;
}
ibbo
关注
专栏目录
string-reverse2.rar_string rever_string reverse
09-21
在C语言中，有几种常见的字符串反转方法： 1. **双指针法**：这是最常见的字符串反转方法，通过两个指针，一个从字符串开头，一个从结尾开始，逐步交换它们所指向的字符，直到两个指针相遇。这种方法简单直观，代码...
C++ Primer Plus 第六版 第十章课后编程练习答案
是鲤鱼啊
03-19 389
1. bank.h #include <string> using namespace std; class BankAccount { string name; string acctnum; double balance; public: BankAccount(string & client, string & num,...
判断Stack为空的方法之empty()与isEmpty()
xl132598798的博客
05-04 8931
今天写算法时，无意间看到了判断栈是否为空的两个方法，之前一直用isEmpty()，从未用过empty()，却不曾想两者均可判断一个栈是否为空，所以深入源码探究了一番： java.util.Vector： /** * Tests if this vector has no components. * * @return {@code true} if and only...
原创 数据结构习题解析与实验指导第三章(栈和队列)课后算法设计题
学者的博客
08-28 1705
1.将编号0和1两个栈存放于一个数组空间V[m]中，栈底分别位于数组的两端。当0号栈的栈顶指针top[0] = -1时该栈为空，当1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长（见图3.2）。试编写双线初始化、栈空、栈满、进栈、出栈等算法的函数。双栈数据结构的定义如下。 typedef struct { int top[2], bot[2]; SElemType* V; int m; } DblStack; #include <iostream> #incl
java数据结构与算法之栈（Stack）设计与实现
zejian的博客
11-28 5700
【版权申明】转载请注明出处（请尊重原创，博主保留追究权！） http://blog.csdn.net/javazejian/article/details/53362993 出自【zejian的博客】 关联文章:java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayLi...
Stack栈的实现
iEucliwood的博客
06-11 246
栈的基本概念及讨论栈只允许在固定的一端插入或者删除数据，这一端叫作栈顶，相对的另外一端就是栈底，对栈顶位的插入叫作入栈或压栈，删除叫作出栈。这样的数据结构有一个特点即后进先出LIFO(last in first off），也可以是先进后出，栈可以由数组表或者链表实现，当用数组实现时用数组的尾端作为栈顶，因为在数组尾的插入删除只需要O(1)的时间，同样若用单链表实现时，将链表头部的一端作为栈顶，也是由于O(1)的插入删除操作。栈的应用例子有很多，例如可以用于编译器判断符号是否平衡，函数调用。平衡符号若从左到右
IrDA-MFC.rar_irda_红外
09-21
4. 文档：可能有教程、API参考或设计文档，解释了代码的工作原理和使用方法。 总的来说，这个压缩包提供了使用MFC和IrDA技术进行无线数据传输的实践案例，对于理解 IrDA 协议以及如何在C++环境中实现红外通信非常有...
C#项目案例源代码供学习
最新发布
03-01
3. **集合与数据结构**：如数组、列表、队列、栈等，这些都是处理数据的基本工具，了解它们的用法和特性对编写高效代码至关重要。 4. **异常处理**：学习如何使用try-catch块捕获和处理程序运行时可能出现的错误，...
20151910042-刘鹏-DSA实验06-栈与队列实验1
08-08
在本实验中，主题是关于数据结构与算法的实践，特别是关注栈和队列这两种基本数据结构。实验目的是为了让学生熟悉栈和队列的相关概念，以及如何在Python中实现这些数据结构。实验内容包括设计线性表的数据结构，调试...
java中Stack的empty() 方法和isEmpty()方法
热门推荐
qq_33915826的博客
03-31 3万+
看Java的API结构中： java.util 类 Stack java.lang.Object java.util.AbstractCollection java.util.AbstractList java.util.Vector java.util.Stack Stack 继...
栈的用法
u011762235的专栏
09-08 682
堆栈只提供入栈，出栈，栈顶元素访问和判断是否为空这几种方法。 采用push()方法将元素入栈；采用pop()方法出栈；采用empty()方法判断栈堆是否为空，如果是空的，则返回逻辑真，否则返回逻辑假。采用size()方法返回当前栈堆中有几个元素。 #include #include using namespace std; int main() {     stacks;  
链表实现队列-栈
qisefengzheng的专栏 总有一天你将破蛹而出
01-23 572
#include #include typedef int data_t; typedef struct link{ data_t data; struct link *next; }link_t; typedef struct { link_t *head; link_t *tail; }link_queue_t; link_queue_t *creat
PTA 栈和队列练习
qq_30445397的博客
11-15 746
PTA 栈和队列练习 7-1 堆栈模拟队列 (50分) 题目描述 设已知有两个堆栈S1和S2，请用这两个堆栈模拟出一个队列Q。 所谓用堆栈模拟队列，实际上就是通过调用堆栈的下列操作函数: int IsFull(Stack S)：判断堆栈S是否已满，返回1或0； int IsEmpty (Stack S)：判断堆栈S是否为空，返回1或0； void Push(Stack S, ElementType item)：将元素item压入堆栈S； ElementType Pop(Stack S)：删除并返回S的栈顶
链表（4）----反转链表
录事参军
12-11 1598
1、链表结构定义 typedef struct ListElement_t_ {     void *data;     struct ListElement_t_ *next; } ListElement_t; typedef struct List_t_{     int size;     int capacity;     ListEleme
栈的各种操作
GodBMW的博客
06-16 932
栈（stack）又名堆栈，是仅允许在表的一端进行插入和删除运算。表尾一端被称为栈顶，相对地，表头称为栈底。Push：向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素。Pop：从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 流程如下 初始化 初始化一个栈的大小为STACK_SIZE，并且将容量size设置为ST
【c++程序】栈的基本用法
平凡的世界
06-06 2864
#include #include using namespace std; typedef std::string T; class stack { T a[5]; int cur; public: stack():cur(0){} //数据入栈成为栈顶 void push(const T& d)/*throw(const char*)*/; //栈顶数据出栈 T pop()
栈的应用实例———一个超长的栈代码，加详解
mafucan的博客
07-08 612
<!--栈的应用实例--> <?php $tracks=array();//定义一个全局栈，以存放状态 //进入时，记录状态 function enter_track($name) { global $tracks;//str_repeat() 函数把字符串重复指定的次数。 echo str_repeat("&nbsp;",count($tracks...
基于栈的简单计算器应用
栈是一种后进先出（LIFO, Last In First Out）的数据结构，它只允许在表的一端进行插入和删除操作。在栈中，最后进入的元素将会最先被取出，这种特性使得栈非常适合用于解决特定类型的计算问题和算法问题。 二、栈...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值