【数据结构】栈和队列相关面试题

最新推荐文章于 2021-05-20 14:40:46 发布
最新推荐文章于 2021-05-20 14:40:46 发布
阅读量531 收藏 2
点赞数
分类专栏： 数据结构知识总结 文章标签： 栈 队列 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41035588/article/details/81750931
版权

栈和队列面试题（c语言实现）

  • 1.实现一个栈，要求实现Push(入栈)、Pop(出栈)、Min(返回最小值)的时间复杂度为O(1).
  • 2.使用两个栈实现一个队列
  • 3.使用两个队列实现一个栈
  • 4.元素出栈、入栈的合法性。如入栈的序列(1,2,3,4,5),出栈序列为(4,5,3,2,1)
  • 5.一个数组实现两个共享栈
1.实现一个栈，要求实现Push(入栈)、Pop(出栈)、Min(返回最小值)的时间复杂度为O(1).

思路：
这里写图片描述
参考代码：

//构建两个栈，一个栈存储元素，另一个栈存储当前最小值

typedef struct MinStack
{
    Stack s;
    Stack mins;
}MinStack;

void MinStackInit(MinStack* pms);
void MinStackDestory(MinStack* pms);

void MinStackPush(MinStack* pms, DataType x);
void MinStackPop(MinStack* pms);
int MinStackSize(MinStack* pms);
int MinStackEmpty(MinStack* pms);
DataType MinStackTop(MinStack* pms);
int MinStackMin(MinStack* pms);
void testmin();


void MinStackInit(MinStack* pms)
{
    assert(pms);
    StackInit(&pms->s);
    StackInit(&pms->mins);
}
void MinStackDestory(MinStack* pms)
{
    assert(pms);
    StackDestory(&pms->s);
    StackDestory(&pms->mins);

}

void MinStackPush(MinStack* pms, DataType x)
{
    assert(pms);
    StackPush(&pms->s, x);
    if (StackEmpty(&pms->mins) || StackTop(&pms->mins) >= x)
    {
        StackPush(&pms->mins, x);
    }

}
void MinStackPop(MinStack* pms)
{
    assert(pms);
    if (StackTop(&pms->mins) == StackTop(&pms->s))
    {
        StackPop(&pms->mins);
    }
    StackPop(&pms->s);

}
int MinStackSize(MinStack* pms)
{
    assert(pms);
    return StackSize(&pms->s);

}
int MinStackEmpty(MinStack* pms)
{
    assert(pms);
    return StackEmpty(&pms->s);
}
DataType MinStackTop(MinStack* pms)
{   
    assert(pms);
    return StackTop(&pms->s);


}
int MinStackMin(MinStack* pms)
{
    assert(pms);
    return StackTop(&pms->mins);

}

void testmin()
{
    MinStack s;
    MinStackInit(&s);

    MinStackPush(&s, 1);
    MinStackPush(&s, 2);
    MinStackPush(&s, 0);
    MinStackPush(&s, 0);
    MinStackPush(&s, 0);
    MinStackPush(&s, 8);
    MinStackPush(&s, 0);

    printf("大小：%d\n",MinStackSize(&s));
    printf("栈顶元素：%d\n",MinStackTop(&s));
    printf("最小值：%d\n",MinStackMin(&s));
    MinStackPop(&s);

    printf("大小：%d\n", MinStackSize(&s));
    printf("栈顶元素：%d\n", MinStackTop(&s));
    MinStackPop(&s);

    printf("大小：%d\n", MinStackSize(&s));
    printf("栈顶元素：%d\n", MinStackTop(&s));
    MinStackPop(&s);

    printf("大小：%d\n", MinStackSize(&s));
    printf("栈顶元素：%d\n", MinStackTop(&s));

    MinStackDestory(&s);

}
2.使用两个栈实现一个队列

思路：
这里写图片描述
参考代码：

typedef struct  QueueByTwoStack
{
    Stack s1;
    Stack s2;
}QueueByTwoStack;

void QueueByTwoStackInit(QueueByTwoStack* qts);
void QueueByTwoStackDestory(QueueByTwoStack* qts);

void QueueByTwoStackPush(QueueByTwoStack* qts, DataType x);
void QueueByTwoStackPop(QueueByTwoStack* qts);
DataType QueueByTwoStackFront(QueueByTwoStack* qts);
int QueueByTwoStackEmpty(QueueByTwoStack* qts);
int QueueByTwoStackSize(QueueByTwoStack* qts);
void testQueueByTwoStack();

void QueueByTwoStackInit(QueueByTwoStack* qts)
{
    assert(qts);
    StackInit(&qts->s1);
    StackInit(&qts->s2);
}
void QueueByTwoStackDestory(QueueByTwoStack* qts)
{
    assert(qts);
    StackDestory(&qts->s1);
    StackDestory(&qts->s2);

}

// 栈s1入数据，s2出数据，
void QueueByTwoStackPush(QueueByTwoStack* qts, DataType x)
{
    assert(qts);
    StackPush(&qts->s1, x);

}
//s2出数据，如果有数据直接出，如果没有就从s1中把数据倒过来
void QueueByTwoStackPop(QueueByTwoStack* qts)
{
    assert(qts);
    if (StackEmpty(&qts->s2))
    {
        while (!StackEmpty(&qts->s1))
        {
            StackPush(&qts->s2, StackTop(&qts->s1));
            StackPop(&qts->s1);
        }
    }
    StackPop(&qts->s2);

}
DataType QueueByTwoStackFront(QueueByTwoStack* qts)
{
    assert(qts);
    if (StackEmpty(&qts->s2))
    {
        while (!StackEmpty(&qts->s1))
        {
            StackPush(&qts->s2, StackTop(&qts->s1));
            StackPop(&qts->s1);
        }
    }
    return StackTop(&qts->s2);
}
int QueueByTwoStackEmpty(QueueByTwoStack* qts)
{
    assert(qts);
    return StackEmpty(&qts->s1)&StackEmpty(&qts->s2);
}
int QueueByTwoStackSize(QueueByTwoStack* qts)
{
    assert(qts);
    return StackSize(&qts->s1) + StackSize(&qts->s2);
}

void testQueueByTwoStack()
{
    QueueByTwoStack stq;
    QueueByTwoStackInit(&stq);
    QueueByTwoStackPush(&stq, 1);
    QueueByTwoStackPush(&stq, 2);
    QueueByTwoStackPush(&stq, 3);
    QueueByTwoStackPush(&stq, 4);
    QueueByTwoStackPop(&stq);

    QueueByTwoStackPush(&stq, 5);
    QueueByTwoStackPush(&stq, 6);
    QueueByTwoStackPush(&stq, 7);
    QueueByTwoStackPush(&stq, 8);

    printf("%d", QueueByTwoStackSize(&stq));

    while (!QueueByTwoStackEmpty(&stq))
    {
        printf("%d ", QueueByTwoStackFront(&stq));
        QueueByTwoStackPop(&stq);
    }
    QueueByTwoStackDestory(&stq);
}
3.使用两个队列实现一个栈

思路：
这里写图片描述
参考代码：

typedef struct  StackByTwoQueue
{
    Queue q1;
    Queue q2;
}StackByTwoQueue;

void StackByTwoQueueInit(StackByTwoQueue* stq);
void StackByTwoQueueDestory(StackByTwoQueue* stq);
void StackByTwoQueuePush(StackByTwoQueue* stq, DataType x);
void StackByTwoQueuePop(StackByTwoQueue* stq);
DataType StackByTwoQueueFront(StackByTwoQueue* stq);
int StackByTwoQueueEmpty(StackByTwoQueue* stq);
int StackByTwoQueueSize(StackByTwoQueue* stq);

void testStackByTwoQueue();


void StackByTwoQueueInit(StackByTwoQueue* stq)
{
    assert(stq);
    QueueInit(&stq->q1);
    QueueInit(&stq->q2);
}
void StackByTwoQueueDestory(StackByTwoQueue* stq)
{
    assert(stq);
    QueueDestory(&stq->q1);
    QueueDestory(&stq->q2);

}
//两个队列实现栈，开始入队时，q1空入q2，q2空入q1，非空队上插入数据，另一个队当出栈时的缓存区
void StackByTwoQueuePush(StackByTwoQueue* stq, DataType x)
{
    assert(stq);
    if (QueueEmpty(&stq->q1))
    {
        QueuePush(&stq->q2, x);
    }
    else
    {
        QueuePush(&stq->q1, x);
    }

}
//出栈时，将非空队列前n-1数据导入空队，将原非空队列第n个数据出队
void StackByTwoQueuePop(StackByTwoQueue* stq)
{
    assert(stq);
    Queue *empty = &stq->q1, *noempty = &stq->q2;
    if (!QueueEmpty(&stq->q1))
    {
        empty = &stq->q2;
        noempty = &stq->q1;
    }
    while (QueueSize(noempty) > 1)
    {
        QueuePush(empty, QueueFront(noempty));
        QueuePop(noempty);
    }
    QueuePop(noempty);

}
DataType StackByTwoQueueFront(StackByTwoQueue* stq)
{
    assert(stq);
    if (QueueEmpty(&stq->q1))
    {
        return QueueBack(&stq->q2);
    }
    else
        return QueueBack(&stq->q1);
}
int StackByTwoQueueEmpty(StackByTwoQueue* stq)
{
    assert(stq);
    return QueueEmpty(&stq->q1)&QueueEmpty(&stq->q2);
}
int StackByTwoQueueSize(StackByTwoQueue* stq)
{
    assert(stq);
    return QueueSize(&stq->q1) + QueueSize(&stq->q2);
}

void testStackByTwoQueue()
{
    StackByTwoQueue stq;
    StackByTwoQueueInit(&stq);
    StackByTwoQueuePush(&stq, 1);
    StackByTwoQueuePush(&stq, 2);
    StackByTwoQueuePush(&stq, 3);
    StackByTwoQueuePush(&stq, 4);
    StackByTwoQueuePop(&stq);

    StackByTwoQueuePush(&stq, 5);
    StackByTwoQueuePush(&stq, 6);
    StackByTwoQueuePush(&stq, 7);
    StackByTwoQueuePush(&stq, 8);

    printf("%d     ", StackByTwoQueueSize(&stq));

    while (!StackByTwoQueueEmpty(&stq))
    {
        printf("%d ", StackByTwoQueueFront(&stq));
        StackByTwoQueuePop(&stq);
    }
    StackByTwoQueueDestory(&stq);
}
4.元素出栈、入栈的合法性。如入栈的序列(1,2,3,4,5),出栈序列为(4,5,3,2,1)

思路：
如入栈的序列（1,2,3,4,5），出栈序列为（4,5,3,2,1）
传入两个数组，一个是进入栈的序列另一个是出栈顺序，创建一个栈，将进入栈的序列依次压入栈中,当进入序列和出栈序列的第一个元素相同时，弹出这个元素，同时出栈序列，向后走，该元素已经成功出栈，此时若入栈序列还有元素继续重复上述操作，直到，最后一个元素也入栈,这时栈中剩下的元素位置已经固定，只能从栈顶依次弹出，每次弹出前栈顶元素和弹出序列元素比较若相等则继续弹出，同时弹出序列向后移动，一旦栈顶元素和弹出序列不相等，说明弹出序列要弹出的元素不在栈顶,所以无法弹出，所以就是非法弹出，否则继续重复上述操作，直到栈中的元素数目为0，即栈空，证明弹出序列合法
这里写图片描述
参考代码：

int Check(int *stack_in, int *stack_out, int len_in, int len_out);
void testInWithOut();



int Check(int *in, int *out, int len_in, int len_out)
{
    /*Stack s;
    StackInit(&s);
    assert(stack_in && stack_out);
    //两个序列长度不相等，不合法  
    if (len_in != len_out)
        return 0;

    int j = 0;
    int i = 0;
    for (; i < len_in; i++)
    {
        StackPush(&s, stack_in[i]);
        //入栈序列栈顶元素与当前出栈序列元素不相等，不合法  
        while (StackSize(&s) > 0 && StackTop(&s) == stack_out[j])
        {
            StackPop(&s);
            j++;
        }
    }*/

    Stack s;
    StackInit(&s);
    assert(in && out);
    //两个序列长度不相等，不合法  
    if (len_in != len_out)
        return 0;

    int index = 0;
    int outdex = 0;

    while (index < len_in)
    {
        StackPush(&s, in[index]);
        index++;
        while (!StackEmpty(&s) && (StackTop(&s) == out[outdex]))
        {
            StackPop(&s);
            outdex++;
        }

    }

    //当所有出栈序列元素都匹配完之后，栈不为空，不合法
    if (StackEmpty(&s))
    {
        StackDestory(&s);
        return 1;
    }
    else
    {
        StackDestory(&s);
        return 0;
    }
}


void testInWithOut()
{
    int stack_in[] = { 1, 2, 3, 4, 5 };       //入栈序列  
    int stack_out[] = { 4, 5, 3, 2, 1 };      //出栈序列  
    int len_in = sizeof(stack_in) / sizeof(stack_in[0]);      //入栈序列长度  
    int len_out = sizeof(stack_out) / sizeof(stack_out[0]);   //出栈序列长度  
    int ret = Check(stack_in, stack_out, len_in, len_out);
    if (ret == 1)
        printf("合法\n");
    else
        printf("不合法\n");

}
5.一个数组实现两个共享栈

思路：
这里写图片描述
参考代码：

//方案一：

#define MAXSIZE 10
//利用数组实现一个静态共享栈，第一个栈是从前往后入栈，第二栈的元素从后往前放
typedef struct SharedStack
{
    int data[MAXSIZE];
    int top1;     //左栈顶
    int top2;     //右栈顶
}SharedStack;

//flag为判断区分两个栈 ，规定1为左栈，2为右栈

void SharedStackInit(SharedStack* s);

// 入栈 
void SharedStackPush(SharedStack* s, int data, int flag);
// 出栈 
void SharedStackPop(SharedStack* s, int flag);
// 获取栈顶元素 
int SharedStackTop(SharedStack* s, int flag);
// 有效元素的个数 
int SharedStackSize(SharedStack* s, int flag);
// 检测栈是否为空 
int SharedStackEmpty(SharedStack* s, int flag);

void SharedStackInit(SharedStack* s)
{
    s->top1 = 0;
    s->top2 = MAXSIZE - 1;
}

// 入栈 
void SharedStackPush(SharedStack* s, int data, int flag)
{
    if (s->top2 <= s->top1)
        return;

    if (1 == flag)
        s->data[s->top1++] = data;
    else
        s->data[s->top2--] = data;
}

// 出栈 
void SharedStackPop(SharedStack* s, int flag)
{
    if (SharedStackEmpty(s, flag))
        return;

    if (1 == flag)
        s->top1--;
    else
        s->top2++;
}

// 获取栈顶元素 
int SharedStackTop(SharedStack* s, int flag)
{
    assert(!SharedStackEmpty(s, flag));
    if (1 == flag)
        return s->data[s->top1 - 1];
    else
        return s->data[s->top2 + 1];
}

// 有效元素的个数 
int SharedStackSize(SharedStack* s, int flag)
{
    if (1 == flag)
        return s->top1;
    else
        return MAXSIZE - s->top2 - 1;
}

// 检测栈是否为空 
int SharedStackEmpty(SharedStack* s, int flag)
{
    if (1 == flag)
        return 0 == s->top1;
    else
        return MAXSIZE - 1 == s->top2;
}

//方案二;
typedef int SDataType;
typedef struct SShareStack
{
    SDataType* data;
    int top1;
    int top2;
    int capacity;

}SShareStack;

void  SShareStackInit(SShareStack* pss);
void  SShareStackDestory(SShareStack* pss,int flag);

void  SShareStackPush(SShareStack* pss,SDataType x,int flag);
void  SShareStackPop(SShareStack* pss, int flag);
int  SShareStackSize(SShareStack* pss, int flag);
SDataType  SShareStackTop(SShareStack* pss, int flag);
int  SShareStackEmpty(SShareStack* pss, int flag);
void testShareStack();

void  SShareStackInit(SShareStack* pss)
{
    assert(pss);
    pss->data = (SDataType*)malloc(sizeof(SDataType)* 4);
    pss->capacity = 4;
    pss->top1 = 0;
    pss->top2 = 1;
}
void  SShareStackDestory(SShareStack* pss,int flag)
{
    assert(pss);
    if (flag == 1)
    {
        pss->top1 = 0;
        if (pss->top2 == 1)
        {
            free(pss->data);
            pss->data = NULL;
        }

    }
    else
    {
        pss->top2 = 1;
        if (pss->top1 == 0)
        {
            free(pss->data);
            pss->data = NULL;
        }
    }                                                      

}

SDataType* AddCapacity(SShareStack* pss)
{
    assert(pss);
    SDataType* tmp = (SDataType*)realloc(pss->data, sizeof(SDataType)*(pss->capacity + 4));
    assert(tmp);
    pss->data = tmp;
    pss->capacity += 4;
    printf("增容成功\n");

    return pss->data;

}
void  SShareStackPush(SShareStack* pss, SDataType x, int flag)
{
    assert(pss&&((flag ==1)||(flag ==2)));

    if (flag == 1)
    {
        if (pss->top1 == pss->capacity - 2)
        {
            pss->data=AddCapacity(pss);
            //AddCapacity(pss);
        }
        pss->data[pss->top1] = x;
        pss->top1 += 2;
    }
    else
    {
        if (pss->top2 == pss->capacity - 1)
        {
            pss->data=AddCapacity(pss);
            //AddCapacity(pss);
        }
        pss->data[pss->top2] = x;
        pss->top2 += 2;
    }

}
void  SShareStackPop(SShareStack* pss, int flag)
{
    assert(pss && ((flag == 1) || (flag == 2)));

    if (flag == 1)
    {
        if (pss->top1 == 0)
            return;
        else
            pss->top1 -= 2;

    }
    else
    {
        if (pss->top2 == 1)
            return;
        else
            pss->top2 -= 2;

    }
}
int  SShareStackSize(SShareStack* pss, int flag)
{
    assert(pss && ((flag == 1) || (flag == 2)));
    if (flag == 1)
        return pss->top1/2;
    else
        return pss->top2/2;

}
SDataType  SShareStackTop(SShareStack* pss, int flag)
{
    assert(pss && ((flag == 1) || (flag == 2)));
    if (flag == 1)
        return pss->data[pss->top1-2];
    else
        return pss->data[pss->top2-2];


}
int  SShareStackEmpty(SShareStack* pss, int flag)
{
        assert(pss&&((flag ==1)||(flag ==2)));
        if (flag == 1)
            return pss->top1 == 0;
        else
            return pss->top2 == 1;

}
void testShareStack()
{
    SShareStack s;
    SShareStackInit(&s);

    SShareStackPush(&s, 3, 1);
    SShareStackPush(&s, 4, 2);
    SShareStackPush(&s, 5, 1);
    SShareStackPush(&s, 1, 2);
    SShareStackPush(&s, 5, 1);
    SShareStackPush(&s, 1, 2);

    printf("大小：%d %d\n", SShareStackSize(&s, 1), SShareStackSize(&s, 2));
    printf("栈顶：%d %d\n", SShareStackTop(&s, 1), SShareStackTop(&s, 2));
    printf("判空：%d %d\n", SShareStackEmpty(&s, 1), SShareStackEmpty(&s, 2));

    SShareStackPop(&s, 1);
    SShareStackPop(&s, 2);

    printf("大小：%d %d\n", SShareStackSize(&s, 1), SShareStackSize(&s, 2));
    printf("栈顶：%d %d\n", SShareStackTop(&s, 1), SShareStackTop(&s, 2));
    printf("判空：%d %d\n", SShareStackEmpty(&s, 1), SShareStackEmpty(&s, 2));

    SShareStackDestory(&s,1);
    SShareStackDestory(&s, 2)；
}
码农印象
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
Scanner对象
Q1ANfeng的博客
12-16 686
Scanner对象 基本语法 Scanner s = new Scanner(System.in); 通过Scanner 类的next() 与 nextLine() 方法获取输入的字符串，在读取前一般用hasNext() 与 hasNextLine()判断是否还有输入的数据。 next(): 一定要读取有效字符后才可以结束输入。 对输入有效字符之前遇到的空白，next（）方法会自动将其去掉 只对输入有效字符后才将其后面的空白作为分隔符或者结束符 next（）不能得到带有空格的字
数据结构—栈和队列经典面试题
3166375975@的博客
09-21 8659
栈和队列面试题： 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 使用两个栈实现一个队列 使用两个队列实现一个栈 元素出栈、入栈顺序的合法性。如入栈的序列(1,2,3,4,5)，出栈序列为 (4,5,3,2,1) 一个数组实现两个栈(共享栈) 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O...
数据结构（C语言版） 清华大学出版社 第三章栈和队列 例题答案
09-06
主要讲述了C语言中栈和队列的有关内容，比如队列中链队列和循环队列的实现。
数据结构之栈和队列的经典面试题
qq_40955824的博客
08-30 231
1.实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 在这个题目中要求要返回一个栈里面的最小值。有两种方法： 1). 用两个栈，一个栈存入栈的数据，另一个栈存对应的最小值，如果入栈的顺序为5，8，1，3，4，则存最小值的那个栈存入的数据应该为5，5，1，1，1。 2). 与上边一样，用两个栈，一个放数据，另一个放最小值，最小值由结构体组成...
数据结构与算法面试题整理
最新发布
09-12
数据结构指的是“一组数据的存储...数据结构：数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Tire树 算法： 递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。
iOS面试题系列之基础数据结构的实现
04-15
收集整理了一些常见的数据结构，以及实现源码： 可变数组、哈希表、栈、队列、LRU缓存等等。
【剑指offer】面试题9-用两个栈实现队列-完整的可执行代码（Java）
01-22
题目描述： 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 解题思路参考：https://blog.csdn.net/flower_48237/article/details/104055970
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
算法大全-面试题-链表-栈-二叉树-数据结构，C#版，主要三大块，一，单链表，二，栈和队列，三，二叉树。 每一大块又有许多新鲜好玩的玩法，你会很喜欢的会上瘾的。 适合玩算法的朋友。
《名企数据结构面试题之--栈与队列（上）》课件和代码
12-25
极客学院，《名企数据结构面试题之--栈与队列（上）》课件和代码。
数据结构之堆栈9一些补充
OVS98
09-29 698
1．栈 1.1 栈的定义 栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示： 结论：后进先出（Last In First Out），简称为LIFO线性表。 栈的基本运算有六种： 构造空栈：InitStack(S)、 判栈空: StackEmpty(S)、 判栈满： StackFull(S)、 进栈： Push(S,x)、
【数据结构与算法面试题】二叉查找树转换成双向链表
热门推荐
null的专栏
07-22 1万+
题目来源“数据结构与算法面试题80道”。这是第一部分，包含其中的第1题到第5题。 在此给出我的解法，如你有更好的解法，欢迎留言。 问题分析：二叉查找树是一种二叉树的结构，其中，根节点的值大于左子树的值，小于右子树的值。而二叉查找树的中序遍历即为排序的结果。对于根节点，前驱指针指向左子树中最大的节点，同理，后驱指针指向右子树中最小的节点，如下图所示： 树是一种递归的结果，因...
有关栈和队列的编程题
when_less_is_more的博客
02-27 2261
两个栈实现队列
数据结构-栈和队列相关面试题
y6_xiamo的博客
04-17 223
1.实现一个最小栈，每次取得都是栈里面的最小值，时间复杂度为O(1) 思路：每次入栈两个元素，一个存当前值，一个存当前栈的最小值，先将当前值入栈，再将最小值入栈，出栈时也一次出两个。如图所示： 代码如下： #include"seqstack.h" #include&lt;stdio.h&gt; typedef struct MinStack { SeqStack stack...
C语言栈的面试题,C语言面试编程题
weixin_39693971的博客
05-20 95
在C语言中，输入和输出是经由标准库中的一组函数来实现的。在ANSI/ISO C中，这些函数被定义在头文件;中。下面就由学习啦小编为大家介绍一下C语言面试编程题的文章，欢迎阅读。C语言面试编程题篇1考查的是结构体和数组的内存布局情况。#include#includetypedef struct array1{int ID;struct array1* next;}A;typedef struct a...
数据结构之栈和队列面试题（3）两个队列实现一个栈
mignatian的博客
05-06 266
我们知道队列是先进先出，而栈是后进先出的，所以要拿两个队列来实现一个栈，我们思路就应该这样： 每次总保持一个队列为空，对另一个队列进行操作。 入栈操作时，我们在那个有元素的队列后面直接用入队列操作，就相当于是栈的入栈操作。 在进行出栈操作的时候，我们将有元素的队列里面的元素依次出队列，并且入队列另一个队列，当出的还剩一个元素的时候，这个时候出队列的元素就是队尾元素，就相当于栈的出栈。正好就是...
数据结构-----栈和队列的一些面试题
Z_JUAN1的博客
07-04 346
一、实现一个栈，要求实现push、pop、min的时间复杂度为o(1)1.我们用一个栈实现，偶数下标放的是普通的数据，奇数下标放的是最小数据push:普通（偶数下标）的数据就正常放，奇数下标：当我们要放的数据大于最小值，那么我们就要更新我们的最小值，在放进去。2.我们用两个栈实现，一个栈里面放正常数据，另一个放最小数据push：正常栈就是就正常放，当最小栈为空的时候，就直接放，不为空的时候就要进行...
栈和队列面试题（C语言版）
BOXING666的博客
08-14 1140
1.判断出入栈的合法性 https://blog.csdn.net/Payshent/article/details/69951411 2.使用两个栈实现一个队列 思想：1.栈1中的所有数据弹到栈2中（栈2为空栈）            2.再从栈2弹出所有数据，则可出现队列的效果 （默认压数据压到队列1中，从队列2出数据） typedef struct Stack { DataT...
【数据结构】栈和队列面试题
如风逝去
08-03 349
1、实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最 小值的操作）的时间复杂度为O(1) 针对这个问题我们可以有两种方法来解决，第一种方法： 我们每次压栈的时候压两个数字，先压数据，然后压最小值，每次压之前和数据比较一下，如果数据比最小值还小就把最小值更新成数据，然后再压数据和最小值，这就是压栈操作。这样可以保证栈顶就是最小值。 接下来是出栈操作，因为我们每次多压了一个...
c++ 数据结构面试题
09-03
3、栈和队列：栈是一种先进后出（LIFO）的数据结构，常用于表达式求值和函数调用等场景。队列是一种先进先出（FIFO）的数据结构，常用于多线程同步和任务调度等场景。相关问题包括栈和队列的实现以及应用。 4、树和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农印象

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值