数据结构 - 栈

1.栈

https://blog.csdn.net/CSDN___CSDN/article/details/82918436

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

typedef struct link_node
{
    int info;
    struct link_node *next;
}N;
 
/*创建一个空的链式栈*/
N *init()
{
    return NULL;
}
 
/*对链式栈进行初始化*/
N *creat(N *top)
{
    int x;
    N *p;
    printf("以输入-1为结束\n");
    scanf("%d",&x);
    while(x!=-1)
    {
        p=(N*)malloc(sizeof(N));
        p->info=x;
        p->next=top;
        top=p;
        scanf("%d",&x);
    }
    return top;
}
 
/*取得链式栈的栈顶结点值*/
int read(N *top)
{
    if(!top)
    {
        printf("\n该链式栈是空的\n");
    }
    return top->info;
} 
 
/*输出链式栈中各结点的值*/
void display(N *top)
{
    N *p=top;
    if(!top)
    {
        printf("该链式栈是空的\n");
    }
    else
    {
        while(p)
        {
            printf("%d  ",p->info);
            p=p->next;
        }
        printf("\n");
    }
}
 
/*链式栈的插入操作*/
N *insert(N *top,int x)
{
    N *q=top,*p;
    p=(N*)malloc(sizeof(N));
    p->info=x;
    p->next=top;
    top=p;
    return top;
}
 
/*链式栈的删除操作*/
N *dele(N *top)
{
    N *p=top;
    if(!top)
    {
        printf("\n该链式栈是空的，无法进行删除\n");return NULL; 
    }
    top=top->next;
    free(p);
    return top; 
} 

int main()
{
    N* top = init();
    top = creat(top);
    display(top);
    int i = read(top);
    printf("%d\n",i);
    top = insert(top,5);
    display(top);
    top = dele(top);
    display(top);
    
    return 0;
}

 

2.栈c++实现

https://blog.csdn.net/zichen_ziqi/article/details/80807989

#include <iostream>
using namespace std;

template <class T>
class stack{
private:
    struct Node{
        T data;
        struct Node *next;
    };
    Node *head;
    int len;
public:
    stack()
    {
        head = NULL;
        len = 0;
    }
    //创建一个栈
    void create()
    {
        int x;
        Node *p;
        cout << "以输入-1为结束" << endl;
        cin >> x ;
        while(x!=-1)
        {
           p=new Node;
           p->data=x;
           p->next=head;
           head=p;
           cin >> x ;
           len++;
        }
    }
    //入栈
    void push(T x)
    {
        Node *q = new Node;
        q->data = x;
        q->next = head;
        len++;
    }
    //出栈
    T top()
    {
        Node *p;
        T data;
        data = head->data;
        p = head;
        head = head->next;
        delete(p);
        len--;
        return data;
    }
    //返回栈内元素的个数
    int size()
    {
        return len;
    }
};

int main() 
{
    stack<int> s;
    s.create();
    s.push(7);
    cout << s.size() << endl;
    cout << s.top() << endl;
    cout << s.size() << endl;
    
    return 0;
}

 

3.用两个栈实现队列的功能

https://blog.csdn.net/weixin_40671425/article/details/83006485

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

#define STACK_INIT_SIZE 10
 
typedef struct stack{
    int *base;
    int *top;
    int stacksize;
}stack;
 
int initStack(stack *s)//构造一个空栈
{
    s->base = (int *)malloc(sizeof(stack)*STACK_INIT_SIZE);
    if(s->base == NULL)
        exit(-1);
    s->top = s->base;
    s->stacksize = STACK_INIT_SIZE;
    return 1;
}
 
void push(stack *s,int num)//压栈
{
    *s->top++ = num;//注意 优先级
}
 
int pop(stack *s)//弹栈
{
    if(s->base == s->top)//空栈，无栈可弹
        return -1;
    return *(--s->top);
}

int main()
{
    stack s1,s2;
    initStack(&s1);
    initStack(&s2);
    int nums[] = {1,2,3,4,5,6};
    printf("压入栈 1\n");
    for(int i=0;i<6;i++)
    {
        push(&s1,*(nums + i));
    }
    printf("出队的顺序为:\n");
    for(int i=0;i<6;i++)
    {
        push(&s2,pop(&s1));
    }
    for(int i=0;i<6;i++)
    {
        printf("%d \t",pop(&s2));
    }
    return 0;
}

 

4.栈的最小的值

https://blog.csdn.net/ltc0106/article/details/105779396

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

#define STACK_TYPE int
 
typedef struct STACK_NODE
{
    STACK_TYPE value;
    struct STACK_NODE *next;
    struct STACK_NODE *next_min;
}Stack_Node;
 
//data栈
static Stack_Node *stack;
//只指向最小数的栈
static Stack_Node *stack_min;

void create_stack()
{
    stack = NULL;
    stack_min = NULL;
}

void push(int value)
{
    Stack_Node *new_node;
    new_node = (Stack_Node *)malloc(sizeof(Stack_Node));
    //更新data栈
    new_node->value = value;
    new_node->next = stack; //单向循环链表
    stack = new_node;
    //更新min栈
    if(stack_min == NULL ||value < stack_min->value )
    {
        new_node->next_min = stack_min;
        stack_min = new_node;
    }
    else
    {
        new_node->next_min = NULL;
    }
}

int pop()
{
    STACK_TYPE value;
    Stack_Node *first_node;
 
    if(stack_min == stack)
        stack_min = stack->next_min;
        
    first_node = stack;
    stack = first_node->next;
    value = first_node->value;
 
    free(first_node);
    return value;
}

int top()
{
    return stack->value;
}
 
 
int min()
{
    return stack_min->value;
}

int main()
{
    create_stack();
    push(5);
    printf("min:%d\n",min());
    push(4);
    printf("min:%d\n",min());
    push(3);
    printf("min:%d\n",min());
    push(5);
    printf("min:%d\n",min());
    push(1);
    printf("min:%d\n",min());
    push(90);
 
    printf("min:%d\n",min());
    printf("pop:%d\n",pop());
    printf("min:%d\n",min());
    printf("pop:%d\n",pop());
    printf("min:%d\n",min());
    printf("pop:%d\n",pop());
    printf("min:%d\n",min());
    printf("pop:%d\n",pop());
    printf("min:%d\n",min());
    printf("pop:%d\n",pop());
    printf("min:%d\n",min());
    printf("pop:%d\n",pop());
 
    return 0;
}