栈和队列笔试题

最新推荐文章于 2024-05-13 03:02:23 发布
最新推荐文章于 2024-05-13 03:02:23 发布
阅读量393 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Alsnoa/article/details/80285841
版权

两种方式实现最小栈

minstack.c  引用 stcak_seq.h（详见栈的实现文章）https://blog.youkuaiyun.com/Alsnoa/article/details/80216882

#include<stdio.h>
#include"stack_seq.h"
#define TEST_HEADER printf("==================%s==================\n",__FUNCTION__)
//Question:return min value as O(1)time  stack (two way).
//1.Fisrt insert two value.
typedef struct MinStack
{
    SeqStack stack;

}MinStack;

void MinStackInit(MinStack* minstack)
{
      if(minstack==NULL)
      {
          return;
      }
    InitSeqStack(&minstack->stack);

}

void DestoryMinStack(MinStack* minstack)
{
    if(minstack==NULL)
    {
        return;
    }
    DestoryStack(&minstack->stack);
}

void MinStackPush(MinStack* minstack,TypeStack value)
{
     if(minstack==NULL)
     {
         return;
     }
     int i;
     TypeStack tmp;
     TypeStack min=value;
     i=SeqStackTop(&minstack->stack,&tmp);
      if(i>0 && tmp<min) 
     {
         min=tmp;
     }
     
     SeqStackPush(&minstack->stack,value);
     SeqStackPush(&minstack->stack,min);
     

}

void MinStackPop(MinStack* minstack)
{
    if(minstack==NULL)
    {
        return;
    }
    SeqStackPop(&minstack->stack);
    SeqStackPop(&minstack->stack);
    
}

int MinStackTop(MinStack* minstack,TypeStack* value)
{
    if(minstack==NULL)
    {
        return 0;
    }

    return SeqStackTop(&minstack->stack, value);
}

void Test()
{
    TEST_HEADER;
    MinStack min;
    TypeStack value;
    int i;
    MinStackInit(&min);
    MinStackPush(&min,'a');
    MinStackPush(&min,'b');
    MinStackPush(&min,'c');
    MinStackPush(&min,'d');
    MinStackPush(&min,'e');
    i=MinStackTop(&min,&value);
    printf("Ret expect:1 actully:%d \n",i);
    printf("Top expect:a actully:%c \n",value);
    MinStackPop(&min);
    i=MinStackTop(&min,&value);
    printf("Ret expect:1 actully:%d \n",i);
    printf("Top expect:a actully:%c \n",value);
    DestoryMinStack(&min);

    i=MinStackTop(&min,&value);
    printf("Ret expect:0 actully:%d \n",i);
    printf("Top expect:  actully:%c \n",value);
    
}

//2.Use two stack to complete.
typedef struct TwoStack{
    SeqStack first;
    SeqStack second;
 }TwoStack;

void TwoStackInit(TwoStack* min)
{
   if(min==NULL)
   {
       return;
   }
  InitSeqStack(&min->first);
  InitSeqStack(&min->second);
   
}

void DestoryTwoStack(TwoStack* min)
{
     if(min==NULL)
     {
         return;
     }
     DestoryStack(&min->first);
     DestoryStack(&min->second);
}

void TwoStackPush(TwoStack* min,TypeStack value)
{
    if(min==NULL)
   {
      return;
   }
   TypeStack minvalue;
   int i;

   i=SeqStackTop(&min->second,&minvalue);
  
   if(i=0)
   {//first intert.
       minvalue=value;
   }
   else if(i>0)
   {
       if(value<minvalue)
       {
           minvalue=value;
       }
   }
   
   SeqStackPush(&min->first,value);
   SeqStackPush(&min->second,minvalue);

}
void TwoStackPop(TwoStack* min)
{
    if(min==NULL)
    {
        return;
    }
    SeqStackPop(&min->first);
    SeqStackPop(&min->second);
}

int TwoStackTop(TwoStack* min,TypeStack *value1,TypeStack* value2)
{
    if(min==NULL|| value1==NULL|| value2==NULL)
    {
        return 0;
    }
    SeqStackTop(&min->first,value1);
    SeqStackTop(&min->second,value2);
    return 1;
}
void Test2()
{
   TEST_HEADER;
   int i;
   TwoStack min;
   TypeStack tmp1;
   TypeStack tmp2;
   TwoStackInit(&min);
   TwoStackPush(&min,'a');
   TwoStackPush(&min,'b');
   TwoStackPush(&min,'c');
   TwoStackPush(&min,'d');
   TwoStackPush(&min,'e');
   TwoStackPop(&min);
   i=TwoStackTop(&min,&tmp1,&tmp2);
   printf("i except: 1 ,actully:%d \n",i);
   printf("tmp1 expect:d ,actully:%c \n",tmp1);
   printf("tmp2 expect:a ,acurlly:%c \n",tmp2);
   DestoryTwoStack(&min);
   i=TwoStackTop(&min,&tmp1,&tmp2);
   printf("i except: 0 ,actully:%d \n",i);
   printf("tmp1 expect: ,actully:%c \n",tmp1);
   printf("tmp2 expect: ,acurlly:%c \n",tmp2);


}
int main()
{
  Test();
  Test2();
  return 0;
}

两个栈实现一个队列 queue_by_two_stack.c  

引用 stcak_seq.h（详见栈的实现文章）https://blog.youkuaiyun.com/Alsnoa/article/details/80216882

#include<stdio.h>
#include"stack_seq.h"
#define TEST_HEADER printf("================%s===============\n",__FUNCTION__)
//1.two stack to complete a queue.
typedef struct Queue_by_two_stack{
   
    SeqStack input;
    SeqStack output;

}Queue;


void QueueInit(Queue* que)
{
   if(que==NULL)
   {
     return;
   }
   InitSeqStack(&que->input);
   InitSeqStack(&que->output);
}

void DestoryQueue(Queue* que)
{
    if(que==NULL)
    {
        return;
    }
    DestoryStack(&que->input);
    DestoryStack(&que->output);
}

void QueuePush(Queue* que,TypeStack value)
{
     if(que==NULL)
     {
         return;
     }
     while(1)
     {
         int i;
         TypeStack tmp;
         i=SeqStackTop(&que->output,&tmp);
         if(i==0)
         {
             break;
         }
         else if(i>0)
         {
           SeqStackPush(&que->input,tmp);
         }
         SeqStackPop(&que->output);

     }
     SeqStackPush(&que->input,value);

}

void QueuePop(Queue* que)
{
    if(que==NULL)
    {
        return;
    }
    
     while(1)
     {
         int i;
         TypeStack tmp;
         i=SeqStackTop(&que->input,&tmp);
         if(i==0)
         {
             break;
         }
         else if(i>0)
         {
           SeqStackPush(&que->output,tmp);
         }
         SeqStackPop(&que->input);

     }
     SeqStackPop(&que->output);

}

int QueueTop(Queue* que,TypeStack *value)
{
    if(que==NULL)
    {
        return;
    }
     while(1)
     {
         int i;
         TypeStack tmp;
         i=SeqStackTop(&que->input,&tmp);
         if(i==0)
         {
             break;
         }
         else if(i>0)
         {
           SeqStackPush(&que->output,tmp);
         }
         SeqStackPop(&que->input);

     }
     return SeqStackTop(&que->output,value);

}

void Test()
{
  TEST_HEADER;
  Queue que;
  int i;
  TypeStack tmp;
  QueueInit(&que);
  QueuePush(&que,'a');
  QueuePush(&que,'b');
  QueuePush(&que,'c');
  QueuePush(&que,'d');
  QueuePush(&que,'e');
  QueuePop(&que);
  ShowStruct(&(&que)->output);
  i=QueueTop(&que,&tmp);
  printf("i   expect:1 actully:%d \n",i);
  printf("top exptct:b actully:%c \n",tmp);
  DestoryQueue(&que);
  i=QueueTop(&que,&tmp);
  printf("i   expect:0 actully:%d \n",i);
  printf("top exptct:  actully:%c \n",tmp);
  
}

int main()
{
  Test();
  return 0;
}

stack_by_two_queue.c  引用queue_seq.h  原文链接https://blog.youkuaiyun.com/Alsnoa/article/details/80217742

#include<stdio.h>
#include"queue_seq.h"
#define TEST_HEADER printf("=============%s============\n",__FUNCTION__)

typedef struct Stack_By_Two_Queeue{

    SeqQueue queue1;
    SeqQueue queue2;

}Stack;

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


void StackPush(Stack *stack ,TypeQueue value)
{
      if(stack==NULL)
      {
          return;
      }

      //fisrt insert in queue2
      
      if(stack->queue1.size==0)
      {
          SeqQueuePush(&stack->queue2,value); 
      }
      else
      {
          SeqQueuePush(&stack->queue1,value); 
      }
        
}

void StackPop(Stack* stack)
{
   if(stack==NULL)
   {
       return;
   }

   if(stack->queue1.size==0 && stack->queue2.size==0)
   {
       return;
   }

  if(stack->queue1.size==0) 
  {
          TypeQueue value;
      while(1)
      {
           if(stack->queue2.size==1)
           {
              break;
           }
          SeqQueueTop(&stack->queue2,&value);
          SeqQueuePush(&stack->queue1,value); 
          SeqQueuePop(&stack->queue2);
      }
      
               SeqQueuePop(&stack->queue2);
  }
  else
  {
            TypeQueue value;
      while(1)
      {

            SeqQueueTop(&stack->queue1,&value);
           if(stack->queue1.size==1)
           {
               break;
           }
         SeqQueuePush(&stack->queue2,value);
         SeqQueuePop(&stack->queue1);

      }
               SeqQueuePop(&stack->queue1);
  }
}

int StackTop(Stack*stack ,TypeQueue* value)
{
    if(stack==NULL || value==NULL)
    {
        return 0;
    }
    if(stack->queue1.size==0 && stack->queue2.size==0)
    {
        return 0;
    }
        
    if(stack->queue1.size==0)
    {
        while(1)
        {
            if(stack->queue2.size==0)
            {
                break;
            }
            
            SeqQueueTop(&stack->queue2,value);
            SeqQueuePush(&stack->queue1,*value);
            SeqQueuePop(&stack->queue2);
            
        }
    }
    else
    {
        while(1)
        {
          if(stack->queue1.size==0)
          {
              break;
          }
          SeqQueueTop(&stack->queue1,value);
          SeqQueuePush(&stack->queue2,*value);
          SeqQueuePop(&stack->queue1);
        }
    }
    return 1;
}
 
void Test()
{
    TEST_HEADER;
    Stack stack;
    TypeQueue tmp;
    size_t a;
    StackInit(&stack);
    StackPush(&stack,'a');
    StackPush(&stack,'b');
    StackPush(&stack,'c');
    StackPush(&stack,'d');
    StackPush(&stack,'e');
    StackPush(&stack,'f');
    StackTop(&stack,&tmp);
    printf("expect:f, acutlly:%c \n",tmp);

    StructShow(&stack.queue1);
    StructShow(&stack.queue2);
    StackPop(&stack);
    StackPop(&stack);
    StackPop(&stack);
    StackPop(&stack);
         
    StackTop(&stack,&tmp);
    printf("expect:b, acutlly:%c \n",tmp);
    StructShow(&stack.queue1);
    StructShow(&stack.queue2);
    StackPop(&stack);
    StackPop(&stack);
    StackPop(&stack);
    StackPop(&stack);
         
    StructShow(&stack.queue1);
    StructShow(&stack.queue2);
}
int main()
{
    Test();
    return 0;
}
=============Test============
expect:f, acutlly:f 
Seq->top:a 
Seq->head:0 
Seq->tail:5 
Seq->size:6 


Seq->top:f 
Seq->head:5 
Seq->tail:5 
Seq->size:0 


expect:b, acutlly:b 
Seq->top:b 
Seq->head:9 
Seq->tail:9 
Seq->size:0 


Seq->top:a 
Seq->head:11 
Seq->tail:12 
Seq->size:2 


Seq->top:a 
Seq->head:9 
Seq->tail:9 
Seq->size:0 


Seq->top:b 
Seq->head:12 
Seq->tail:12 
Seq->size:0 


if_number_from_stack.c    引用stack_seq.h https://blog.youkuaiyun.com/Alsnoa/article/details/80216882

#include<stdio.h>
#include<string.h>
#include"stack_seq.h"
#define TEST_HEADER printf("\n=============%s=============\n",__FUNCTION__)
//1.to judge if the string was accounding to the stackpush and stack pop.

int If_number_from_stack_pop(char arr_in[],size_t size_in,\
                              char arr_out[], size_t size_out)
{
    if(size_in==0||size_out==0)
    {
        return 0;
    }
       //a b c d e f  6        d e f c b a  6       
      size_t input=0;
      size_t output=0;
      SeqStack tmp;
      InitSeqStack(&tmp);

     for(input=0;input<size_in;input++)
     {
        SeqStackPush(&tmp,arr_in[input]); 
        

        while(1)
        {
            size_t i;
            TypeStack value;
            i=SeqStackTop(&tmp,&value);
  
            if(i==0)
            {
                  break; 
            }
         
            if(value==arr_out[output])
            {
                SeqStackPop(&tmp); 
                output++;
                printf("%c ",value);
            }
            else
            {
                break;
            }
  
  
        }


     }
     printf("\n");
     if(output==size_out)
     {
         return 1;
     }
     return 0;

      
}

void Test()
{
    TEST_HEADER;
  char arr_in[6]="abcdef";
  char arr_out1[6]="defcba";
  char arr_out2[6]="defcab";
  int i;
  i=If_number_from_stack_pop(arr_in,6,arr_out1,6);
  printf("i:1 actully:%d \n",i);
  i=If_number_from_stack_pop(arr_in,6,arr_out2,6);
  printf("i:0 actully:%d \n",i);
  
}
int main()
{
    Test();
    return 0;
}

shared_stack.c 

#include<stdio.h>
#define TEST_HEADER printf("=============%s==============\n",__FUNCTION__)
#define MaxSize 1024

typedef struct SharedStack{
//[0,top1)  [top2,MaxSize)
    TypeStack data[MaxSize];
    size_t top1;
    size_t top2;

}SharedStack;

 void SharedStackInit(SharedStack* stack)
{
        if(stack==NULL)
        {
            return;
        }
        stack->data[0]=0;
        stack->top1=0;
        stack->top2=MaxSize;
}

void DestorySharedStack(SharedStack* stack)
{
    if(stack==NULL)
    {
        return;
    }
    stack->data[0]=0;
    stack->top1=0;
    stack->top2=MaxSize;
}

void Stack1Push(SharedStack* stack,TypeStack value)
{
    if(stack==NULL)
    {
        return;
    }
    if(stack->top1>=stack->top2)
    {
        printf("The SharedStack is full!\n");
        return;
    }
    stack->data[stack->top1]=value;
    stack->top1++;

}

void Stack2Push(SharedStack* stack, TypeStack value)
{

    if(stack==NULL)
    {
        return;
    }
    if(stack->top1>=stack->top2)
    {
        printf("The SharedStack is full!\n");
        return;
    }
    stack->data[stack->top2-1]=value;
    stack->top2--;
}

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

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

int StackTop1(SharedStack* stack,TypeStack* value)
{
    if(stack==NULL)
    {
        return;
    }
    if(stack->top1==0)
    {
        return 0;
    }
    *value=stack->data[stack->top1-1];
   return 1; 
}

int StackTop2(SharedStack* stack,TypeStack* value)
{
    if(stack==NULL)
    {
        return;
    }
    if(stack->top2==MaxSize)
    {
        *value='0';
        return 0;
    }
    *value=stack->data[stack->top2];
    return 1;
}

void Test()
{
    TEST_HEADER;
    SharedStack share;
    int i;
    TypeStack value;
    SharedStackInit(&share);
    Stack1Push(&share,'a');
    Stack1Push(&share,'b');
    Stack1Push(&share,'c');
    Stack1Push(&share,'d');
    Stack1Push(&share,'e');
    Stack1Pop(&share);
    Stack1Pop(&share);
    Stack1Pop(&share);
    Stack1Pop(&share);
    i=StackTop1(&share,&value);
    printf("\n----------stack1_test-----------\n");
    printf("value: a actully :%c \n",value);
    Stack2Push(&share,'a');
    Stack2Push(&share,'b');
    Stack2Push(&share,'c');
    Stack2Push(&share,'d');
    Stack2Pop(&share);
    i=StackTop2(&share,&value);
    printf("\n----------stack2_test-----------\n");
    printf("value: c actully :%c \n",value);
    for(i=0;i<1020;i++)
    {

      Stack2Push(&share,'b');
    }
    printf("\n----------stack_only_full_test-----------\n");
    i=StackTop2(&share,&value);
    printf("value: b actully :%c \n",value);
    
    printf("\n----------stack_over_full_test-----------\n");
    Stack1Push(&share,'c');
   i=StackTop1(&share,&value);
    printf("value: c actully :%c \n",value);
}
int main()
{
    Test();
    return 0;
}


[04数据结构]栈和队列的基本理解、操作和笔试题
再吃一个橘子
11-14 863
栈使用顺序结构（数组栈）；而队列使用链式结构（链式队列）
栈和队列详解（C语言）
Raikkonen_love的博客
11-19 848
栈和队列的实现，力扣简单笔试oj
栈和队列常见笔试题
sandmm112的博客
04-16 4167
        以下有关栈的知识请见这篇博客：https://blog.youkuaiyun.com/sandmm112/article/details/79860236        以下有关队列的知识请见这篇博客：https://blog.youkuaiyun.com/sandmm112/article/details/79860257        前面我们介绍过了栈和队列的两种实现方法以及一些基本操作。下面利用之...
栈和队列经典笔试题
liyuuhuvnjjv的博客
03-29 216
1.问题描述： 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 Map<Character,Character> map = new HashMap(); map.put('(',')'...
栈和队列的相关笔试面试题
Nessie_zhao的博客
04-17 419
在程序中引用的“seqstack.h”文件和“seqqueue.h”可以参见https://blog.youkuaiyun.com/Nessie_zhao/article/details/79917049 https://blog.youkuaiyun.com/Nessie_zhao/article/details/798344041.实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值）的时间复杂度
栈和队列的一些笔试题（1）
L_X_Y_HH的博客
04-11 683
下面来写一些关于栈和队列的一些笔试题：问题1：实现一个栈，要求实现Push（入栈）、Pop（入栈）、Min（返回最小值）的时间复杂度为O(1)问题2：使用两个栈实现一个队列问题3：使用两个队列实现一个栈问题1：实现一个栈，要求实现Push（入栈）、Pop（入栈）、Min（返回最小值）的时间复杂度为O(1)问题分析：要实现返回栈的最小值的时间复杂度为O(1)，就要使整个栈的最小元素一定要是在栈顶，那...
栈和队列常考笔试题（二）
Nan_Feng726的博客
06-10 404
1、使用队列实现栈的下列操作 push(x) – 元素 x 入栈 pop() – 移除栈顶元素 top() – 获取栈顶元素 empty() – 返回栈是否为空 思路： 先创建一个队列，用队列实现入栈操作很简单，直接在队列的末尾增加元素就可以： pop操作移除栈顶元素相对来说比较复杂，在上面那个示例中，栈顶元素是5，在最右边，而出队列又只能在最左边进行，要移除5这个元素，我们首先得把前面的4...
2024年C C++最全栈和队列经典笔试题_队列笔试题，金九银十
最新发布
2401_84976030的博客
05-13 616
/->的优先级高于&，其实是&(pst->q1)，将定义的结构体变量的地址传过去。(img-jtduPSB7-1715540521040)](img-NOdHz1bX-1715540521040)]//把非空队列的前size-1个元素push到空队列。
关于栈和队列常见笔试面试题
谢广涛的博客
04-14 426
关于栈和队列相关笔试面试题：1.入栈、出栈、取栈中最小元素的时间复杂度0(1) 2.使用两个栈实现一个队列 3.使用两个队列实现一个栈 4.判断字符串入栈出栈的合法性，即判定字符串是否按照入栈出栈顺序 5.一个数组实现两个栈（共享栈）
栈与队列相关笔试题
mi_rencontre的博客
05-10 1641
1.用两个栈实现队列 分析：队列的特点是“先进先出”，而栈的特点是“后进先出”，入队列时让所有的元素进到stack1中，出队列时先判断stack2是否为空，不为空直接pop即可，若为空，将stack1中所有的元素“倒入”stack2中，这样就用两个栈实现了队列。 实现代码： class Solution { public: void push(int node) {
栈和队列习题
03-30
对于棧和队列部分的基础运用，你需要进行系统的基础复习，和对于小程序的实现
栈和队列练习题
An_Mo的博客
07-04 711
一、有效的括号 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 1、左括号必须用相同类型的右括号闭合。 2、左括号必须以正确的顺序闭合。 示例 1： 输入：s = “()” 输出：true 示例 2： 输入：s = “()[]{}” 输出：true 示例 3： 输入：s = “(]” 输出：false 示例 4： 输入：s = “([)]” 输出：false 示例 5： 输入：s = “{[]}” 输出：true 提示： 1 &lt
栈和队列（题集）
weixin_54342360的博客
03-22 633
循环队列，栈实现队列、队列实现栈以及最小栈的问题
栈与队列相关题目
m0_68161818的博客
10-30 129
1.对于栈和队列来说，要了解清楚其底层代码是如何书写的，这样用的时候才能得心应手。2.栈是容器适配器，底层容器使用不同的容器，导致栈内数据在内存中是不是连续分布。3.要理解单调队列和优先级队列。
史上最强数据结构----栈和队列相关笔试面试题
m0_57304511的博客
04-11 2470
史上最强数据结构----栈和队列相关笔试面试题
栈和队列的练习题
AlinaQ05的博客
08-04 1030
第一个栈 push 元素时，当另一个栈中没有元素时将当前插入的元素 push 进去，然后每一次插入元素时两个栈中的栈顶元素进行比较。如果当前插入的元素小于第二个栈的栈顶元素，就将当前元素 push 到第二个栈中，否则就将第二个栈中的栈顶元素重新入栈。处理括号问题，就是将括号中的部分看成一个整体，每次遇到左括号，将括号放入栈中，直到遇到右括号，再计算括号中的部分。所以就可以使用栈来完成，遇到左括号就将相应匹配的右括号加入栈中，后续如果是合法的，右括号的顺序就是栈中弹出的顺序。队列中的元素为int类型。....
栈和队列相关题目汇总
陈云佳的专栏
02-27 625
内容会持续更新，有错误的地方欢迎指正，谢谢!前言栈：后进先出，常用于存储函数调用时函数的参数、返回地址及临时变量等。 队列：先进先出，常用于BFS，比如：在遍历某一层节点时，把节点的子节点放进一个队列里，以备下一层节点的遍历。 但栈和队列却有互相之间的联系，请见下题。用两个栈实现队列用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。小诀窍：通过具体的例子+画图的
关于栈和队列一些例题
chihiro1122的博客
10-09 809
栈的例题
栈和队列习题整理
m0_49991895的博客
02-19 799
一、括号匹配问题 题目描述如下： 解题思路：使用栈来解决，扫描字符串，当碰到左括号时直接入栈，当扫描到右括号时，弹出栈顶元素查看是否匹配，不匹配直接false，否者重复上述流程。 两个边界问题： 扫描完字符串，栈不为空时，说明左括号多了，没有相匹配的右括号，直接false。 扫描到第一个右括号时，发现栈为空，说明右括号是该字符串的第一个字符，没有相匹配的左括号，直接false。 代码如下： public class Num20 { public boolean isValid...
C和C++软件公司全面笔试题集锦
标题中提到的是“C,C++常见笔试题大全（很全面）”，这表明文件内容包含了大量针对C和C++语言的编程题目，这些题目覆盖了多个公司的笔试场景，如华为、中兴、大唐等。这样的题目集很适合用于求职者的面试准备，尤其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值