数据结构-栈和队列笔试题

最小栈(两种方法) 

①链表

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


typedef char StackType;

typedef struct Stack
{
    StackType data;
    struct Stack* next;
}Stack;


void StackInit(Stack** head);

void Stackdestory(Stack* node);

Stack* CreatNode(StackType value);

void StackPush(Stack** head,StackType value);

void StackPop(Stack** head);

int StackTop(Stack* head,StackType* value);

#include<stdio.h>
#include"minstack.h"

//初始化
void StackInit(Stack** head)
{
    if(head == NULL)
    {
        return;
    }
    *head = NULL;
    return;
}

//销毁节点
void Stackdestory(Stack* node)
{
    free(node);
    return;
}

//创建节点
Stack* CreatNode(StackType value)
{
    Stack* New_node = (Stack*)malloc(sizeof(Stack));
    New_node->data = value;
    New_node->next = NULL;
    return New_node;
}

//头插入栈
//1.如果链表为空，先将正常值头插，min值头插，元素相同
//2.先头插正常值，比较正常值值与上次min值大小，
//a.小于上次的min，将min作为新节点头插
//b.大于上次的min，将上次的头插新节点，且节点的值为min。
void StackPush(Stack** head,StackType value)
{
    if(head == NULL)
    {
        return;
    }
    static StackType min;
    if(*head == NULL)
    {
        Stack* Nornode = CreatNode(value);
        min = value;
        *head = Nornode;
        Stack* Minnode = CreatNode(min);
        Minnode->next = *head;
        *head = Minnode;
        min = value;
        return;
    }
    Stack* Nornode = CreatNode(value);
    Nornode->next = *head;
    *head = Nornode;
    if(min > value)
    {
        min = value;
    }
    Stack* Minnode = CreatNode(min);
    Minnode->next = *head;
    *head = Minnode;
    return;
}



//头删出栈
void StackPop(Stack** head)
{
    if(head == NULL)
    {
        return;
    }
    if(*head == NULL)
    {
        return;
    }
    *head = (*head)->next->next;
    return;
}

//取栈顶元素
int StackTop(Stack* head,StackType* value)
{
    if(head == NULL || value == NULL)
    {
        return -1;
    }
    printf("value is :%c\n",head->data);
    return 0;
}

//打印
void Print(Stack*head)
{
    if(head == NULL)
    {
        return;
    }
    Stack* cur = head;
    while(cur!= NULL)
    {
        printf("%c ",cur->data);
        cur = cur->next;
    }
    printf("\n");
    return;
}

②基于顺序栈

#include<stdio.h>
#include"seqstack.h"

typedef struct minstack
{
    SeqStack stack;
}minstack;


void minstackInit(minstack* min_stack)
{
    if(min_stack == NULL)
    {
        return;
    }
    Init(&min_stack->stack);
    return;
}


void minstackPush(minstack* min_stack,stacktype value)
{
   if(min_stack == NULL)
    {
        return;
    }
    stacktype min = value;
    stacktype top;
    int ret = front(&min_stack->stack,&top);
    if(ret != 0)
    {
        min = top < value ? top:value;
    }
    Push(&min_stack->stack,value);
    Push(&min_stack->stack,min);
    return;
}

void minstackPop(minstack* min_stack)
{
   if(min_stack == NULL)
    {
        return;
    }
    Pop(&min_stack->stack);
    Pop(&min_stack->stack);
    return;
}

int minstackTop(minstack* min_stack,stacktype* value)
{
   if(min_stack == NULL)
    {
        return 0;
    }
    return front(&min_stack->stack,value);
}

两个栈实现一个队列

#include<stdio.h>
#include"seqstack.h"

typedef struct Squeue
{
    SeqStack input;//入队列
    SeqStack output;//出队列和取队首元素
}Squeue;


void SqueueInit(Squeue* queue)
{
    if(queue == NULL)
    {
        return;
    }
    Init(&queue->input);
    Init(&queue->output);
    return;
}

void SqueuePush(Squeue* queue,stacktype value)
{
    if(queue == NULL)
    {
        return;
    }
    stacktype top;
    while(1)
    {
        int ret = front(&queue->output,&top);
        if(ret == -1)
        {
            break;
        }
        Push(&queue->input,top);
        Pop(&queue->output);
    }
    Push(&queue->input,value);
    return;
}


void SqueuePop(Squeue* queue)
{
    if(queue == NULL)
    {
        return;
    }
    //把input中的所有元素倒腾到output中
    while(1)
    {
        stacktype top;
        int ret = front(&queue->input,&top);
        if(ret == -1)
        {
            break;
        }
        Push(&queue->output,top);
        Pop(&queue->input);
    }
    //把output的栈顶元素出栈
    Pop(&queue->output);
}

int SqueueFront(Squeue* queue,stacktype* value)
{
    if(queue == NULL || value == NULL)
    {
        return 0;
    }
    //把input中的所有元素倒腾到output中
    while(1)
    {
        stacktype top;
        int ret = front(&queue->input,&top);
        if(ret == -1)
        {
            break;
        }
        Push(&queue->output,top);
        Pop(&queue->input);
    }
    front(&queue->output,value);
    return 1;
}

两个队列实现一个栈 

#include<stdio.h>
#include"seqqueue.h"

typedef struct StackBy2Queue{
    SeqQueue queue1;
    SeqQueue queue2;
}StackBy2Queue;

void StackBy2QueueInit(StackBy2Queue* stack){
    if(stack == NULL){
        return;
    }
    SeqQueueInit(&stack->queue1);
    SeqQueueInit(&stack->queue2);
    return;
}

void StackBy2QueuePush(StackBy2Queue* stack,SeqQueueType value){
    if(stack == NULL){
        return;
    }
    SeqQueue* input;
    if(stack->queue1.size == 0){
        input = &stack->queue2;
    }else{
        input = &stack->queue1;
    }
    SeqQueuePush(input,value);
}

void StackBy2QueuePop(StackBy2Queue* stack){
    if(stack == NULL){
        return;
    }
    if(stack->queue1.size == 0 && stack->queue2.size == 0){
        return;
    }
    SeqQueue* to;//要入队列的队列  空
    SeqQueue* from;//要出队列的队列   非空
    if(stack->queue1.size == 0){
        to = &stack->queue1;
        from = &stack->queue2;
    }
    else{
        to = &stack->queue2;
        from = &stack->queue1;
    }
    SeqQueueType top;
    while(1){ //将from中的元素全部入队列到to中只剩下1个元素为止
             if(from->size == 1){
                 return;
             }
             SeqQueueTop(from,&top);
             SeqQueuePush(to,top);
             SeqQueuePop(from);
            }
    //将最后一个元素出队列
    SeqQueuePop(from);
}

int StackBy2QueueFront(StackBy2Queue* stack, SeqQueueType* value){
    if(stack == NULL || value == NULL){
        return 0;
    }
    if(stack->queue1.size == 0 && stack->queue2.size == 0){
        return 0;
    }
    int ret;
    SeqQueueType top;
    SeqQueue* to;//要入队列的队列  空
    SeqQueue* from;//要出队列的队列   非空
    if(stack->queue1.size == 0){
        to = &stack->queue1;
        from = &stack->queue2;
    }
    else{
        to = &stack->queue2;
        from = &stack->queue1;
    }
    while(1){
        ret = SeqQueueTop(from,value);
        if(ret == -1){
            break;
        }
        SeqQueuePop(from);
        SeqQueuePush(to,*value);
    }
    return 0;
}

判定字符串是否按照出栈顺序 

#include<stdio.h>
#include"seqstack.h"

int IsSeq(char src[],int size1,char dst[],int size2)
{
    if(src == NULL||dst == NULL)
    {
        return 0;
    }
    if(size1 != size2)
    {
        return 0;
    }
    SeqStack stack;
    SeqStackInit(&stack);
    int src_cur = 0;
    int dst_cur = 0;
    //原字符串中元素一个一个入栈
    while(src_cur != size1)
    {
        //保证所有元素都能入栈
        SeqStackPush(&stack,src[src_cur]);//入栈当前元素
        //取当前栈顶元素和目标字符串进行比较
        SeqStackType top;
        int ret;
        while(dst_cur != size2)
        {
            ret = SeqStackTop(&stack,&top);
            if(ret == -1)
            {
                return 0;
            }
            //栈顶元素若和目标字符串元素不同，则原字符串元素入栈
            if(top != dst[dst_cur])
            {
                break;
            }
            else
            {
                SeqStackPop(&stack);
                ++dst_cur;
            }
        }
        ++src_cur;
    }
    if(dst_cur == 0 && stack.size == 0)
    {
        return 1;
    }
    else
    {
        return -1;
    }
} 

共享栈(一个数组实现两个栈)

#include<stdio.h>
#include"seqstack.h"

#define SharedStackMaxSize 1000

typedef int SharedType;

typedef struct SharedStack
{
    SharedType data[SharedStackMaxSize];
    size_t top1;
    size_t top2;
}SharedStack;

//[0,top1)表示第一个栈，[top2,SharedStackMaxSize)表示第二个栈。

void SharedStackInit(SharedStack* stack)
{
    if(stack == NULL)
    {
        return;
    }
    stack->top1 = 0;
    stack->top2 = SharedStackMaxSize;
}


void SharedStackPush1(SharedStack* stack,SharedType value)
{
    if(stack == NULL)
    {
        return;//error
    }
    if(stack->top1 >= stack->top2)
    {
        return;//full
    }
    stack->data[stack->top1++] = value;
    return;
}

void SharedStackPush2(SharedStack* stack,SharedType value)
{
    if(stack == NULL)
    {
        return;
    }
    if(stack->top1 >= stack->top2)
    {
        return;
    }
    stack->data[--stack->top2] = value;
}

int SharedStackTop1(SharedStack* stack,SharedType* value)
{
    if(stack == NULL || value == NULL)
    {
        return 0;//fail
    }
    if(stack->top1 == 0)
    {
        return 0;
    }
    *value = stack->data[stack->top1 - 1];
    return 1;
}


int SharedStackTop2(SharedStack* stack,SharedType* value)
{
    if(stack == NULL || value == NULL)
    {
        return 0;//fail
    }
    if(stack->top2 == SharedStackMaxSize)
    {
        return 0;
    }
    *value = stack->data[stack->top2];
    return 1;
}


void SharedStackPop1(SharedStack* stack)
{
    if(stack == NULL)
    {
        return;
    }
    if(stack->top1 == 0)
    {
        return;
    }
    --stack->top1;
    return;
}

void SharedStackPop2(SharedStack* stack)
{
    if(stack == NULL)
    {
        return;
    }
    if(stack->top2 == SharedStackMaxSize)
    {
        return;
    }
    ++stack->top2;
    return;
}