基础数据结构和算法——4、栈

基础数据结构和算法——4、栈

在线性表中，顺序表和链表可以访问任意位置结点，在任意位置插入和删除结点。栈和队列是对上述操作加以限制。

1. 在线性表的一端插入、删除、访问结点。
2. 在线性表的一端插入结点、另一端删除、访问结点。

1. 栈是什么？

栈是一种只能从表的一端存取数据且遵循 LIFO(先进后出)原则的线性存储结构。

栈的开口端被称为栈顶
封口端被称为栈底。

通常只会对栈执行以下两种操作：

1. 向栈中添加元素，此过程被称为"进栈"（入栈或压栈）；
2. 从栈中提取出指定元素，此过程被称为"出栈"（或弹栈）；

2. 栈怎么用？

栈一般用来处理逆序和回退相关的处理。

3. 栈怎么实现？

栈是操作受限制的线性表，根据不同的存储结构可分成顺序栈和链式栈。

• 在顺序栈中，可以将顺序表的有效长度作为栈顶指针，在顺序表的末尾删除和插入节点。
• 在链式栈中，可以将链表的头结点作为栈顶指针，入栈采用头插法。

下面是顺序栈的实现。

3.1 定义结构

typedef int StackType; //存储单元类型

typedef struct stackNode {
    StackType *element; //存储空间基地址
    int size; //当前长度
    int capacity; //当前分配的存储容量
}Stack;

3.2 定义操作

1. 初始化栈

Stack stack_init(int size);

2. 入栈

void stack_push(Stack* stack,StackType element);

3. 访问栈顶元素

StackType* stack_top(Stack* stack);

4. 出栈

StackType stack_pop(Stack* stack);

• 完整代码

#include "stack.h"
#include <stdlib.h>
#include <assert.h>



//创建
Stack stack_create(){
	Stack s = {NULL,0};
	return s;
}

//销毁
void stack_destroy(Stack* s){
	free(s->data);
	s->data = NULL;
	s->size = 0;
}

//入栈
void stack_push(Stack* s,StackType val){
	assert(NULL!=s);
	s->size++;
	s->data = realloc(s->data,s->size*sizeof(StackType));
	s->data[s->size-1] = val;
}

//出栈
void stack_pop(Stack* s){
	assert(NULL!=s);
	assert(s->size>0);
	s->size--;
}

//栈顶
StackType stack_top(Stack* s){
	assert(NULL!=s);
	assert(s->size>0);
	return s->data[s->size-1];
}

练习

• 完成括号匹配-百度2018秋
• 牛牛的括号匹配-京东2018秋
• 155.最小栈
  

class MinStack {
    stack<int> x_stack;
    stack<int> min_stack;
public:
    MinStack() {
        min_stack.push(INT_MAX);
    }
    
    void push(int x) {
        x_stack.push(x);
        min_stack.push(min(min_stack.top(), x));
    }
    
    void pop() {
        x_stack.pop();
        min_stack.pop();
    }
    
    int top() {
        return x_stack.top();
    }
    
    int getMin() {
        return min_stack.top();
    }
};

• 双栈排序
  

#include <stdio.h>
#include <algorithm>
using namespace std;
void bubblesort(int buf [],int n){
int tmp;
        for(int i=0;i<n;++i)
        {
            for(int j=0;j<n-i-1;++j)
            {
                if(buf[j]>buf[j+1])
                {
                    tmp=buf[j+1];
                    buf[j+1]=buf[j];
                    buf[j]=tmp;
                }
            }   
        }
        return;
}
void selectsort(int buf [],int n){
int m=0,t;
        for(int i=0;i<n;++i)
        {
            m=n-i-1;
            for(int j=0;j<n-i;++j)
            {
                if(buf[j]>buf[m])
                {
                    m=j;
                }
            }   
            t=buf[n-1-i];
            buf[n-1-i]=buf[m];
            buf[m]=t;
        }
        return;
}
void qsort(int a[],int low,int high)
{
    if(low>=high)return;
    int pivot=a[low],l=low,h=high;
    while(l<h)
    {
        while(l<h&&pivot<=a[h])
            --h;
        a[l]=a[h];
        while(l<h&&pivot>=a[l])
            ++l;
        a[h]=a[l];
    }
    a[l]=pivot;
    qsort(a,low,l-1);
    qsort(a,l+1,high);
}
int main()
    {
        int n;
        int buf[100];
        while(scanf("%d",&n)!=EOF)
        {
            for(int i=0;i<n;++i)
            {
                scanf("%d",&buf[i]);
            }
        //sort(buf,buf+n);内置快排函数
        //bubblesort(buf,n);冒泡排序
        //selectsort(buf,n);选择排序
        qsort(buf,0,n-1);手动快排函数
        for(int i=0;i<n;++i)
            printf("%d ",buf[i]);
        printf("\n");
        }
            return 0;
    }