【数据结构与算法】牛客面试真题，带你领略算法思想

💛 前情提要💛

本章节是数据结构的栈和队列的相关面试题目讲解~

以下的内容一定会让你对栈和队列相关知识的题目,有一个颠覆性的认识哦！！！

❗以下内容以C语言的方式实现❗

以下内容干货满满，跟上步伐吧~

👉前情提要

  • 本次题目涉及面试题解答思路&中等难度题目

  • 欢迎大家上手测试一波🥰

📒面试真题【全面深度解析】


🏷️ 有效的括号【难度：简单】

:mag:题目传送门：

Leetcode：20. 有效的括号

给定一个只包括'('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合

    1. 左括号必须以正确的顺序闭合
  • 示例 1： 
输入：s = "()"
输出：true
  • 示例 2： 
输入：s = "()[]{}"
输出：true
  • 示例 3： 
输入：s = "(]"
输出：false
  • 示例 4： 
输入：s = "([)]"
输出：false
  • 示例 5： 
输入：s = "{[]}"
输出：true

💡解题关键：

  • 我们不难发现这是一个括号匹配的问题，即括号的特性就是一左一右在对应的位置上相互匹配的

  • 我们便可以利用此特性，借助栈来实现括号匹配的功能

➡️思路： 栈

❓为什么利用栈这个结构呢

  • 1️⃣括号一左一右的特性，刚好符合栈的LIFO（Last in first out）原则

  • 2️⃣那这样我们就可以利用栈将左括号类型的括号依次入栈，根据括号需要相互对应的特性，就可以按顺序出栈并依次按顺序与右括号类型比较，看是否匹配

    • 若直至左括号类型全部出栈，且全都匹配的话，说明括号全部匹配，返回true

    • 否则，若中途有不匹配的，则匹配失败，返回false

❗特别注意：

  • 因为我们需要借助栈的数据结构，在任何时候返回结果前都需要检查借助数据结构所申请的空间是否释放了，否则会造成内存泄露的问题

🔥特殊情况：

  1. 数组没走完，但栈却是NULL的【Eg：第一个元素就为右括号类型】，就可以不用接着匹配下去了，返回false

  2. 数组走完了，但栈却不为NULL，那此时相当于还有左括号类型没有得匹配，返回false

✊动图示例：

在这里插入图片描述

👉实现：

1️⃣实现栈

typedef char STDatatype;
typedef struct Stack
{
    STDatatype* a;
    int top;        // 栈顶
    int capacity;
}ST;

void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDatatype x);
void StackPop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);
STDatatype StackTop(ST* ps);

void StackInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0; // -1
    ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
    assert(ps);
    if (ps->a)
    {
        free(ps->a);
    }
    ps->a = NULL;
    ps->top = 0; 
    ps->capacity = 0;
}

void StackPush(ST* ps, STDatatype x)
{
    assert(ps);


    // 检查空间够不够，不够就增容
    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        STDatatype* tmp = realloc(ps->a, sizeof(STDatatype)*newcapacity);
        if (tmp == NULL)
        {
            printf("rellaoc fail\n");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = newcapacity;
    }

    ps->a[ps->top] = x;
    ps->top++;
}

void StackPop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    --ps->top;
}

bool StackEmpty(ST* ps)
{
    assert(ps);

    return ps->top == 0;
}

int StackSize(ST* ps)
{
    assert(ps);

    return ps->top;
}

STDatatype StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->a[ps->top - 1];
}

2️⃣实现括号匹配功能

bool isValid(char * s){
    ST st;
    StackInit(&st);
    bool match = true;

    while(*s)
    {
        if(*s == '[' || *s == '(' || *s == '{')
        {
            StackPush(&st, *s);
            s++;
        }
        else
        {
            //数组还没走完，
            //但栈已经空了
            if(StackEmpty(&st))
            {
                match = false;
                break;
            }

            char ch = StackTop(&st);
            StackPop(&st);

            if((*s == ']' && ch != '[')
            || (*s == '}' && ch != '{')
            || (*s == ')' && ch != '('))
            {
                match = false;
                break;
            }
            else
            {
                s++;
            }
        }
    }

    //双重保险，预防上述第二种特殊情况
    if(match == true)
    {
        match = StackEmpty(&st);
    }

    StackDestroy(&st);

    return match;
}

🏷️ 用队列实现栈【难度：简单】

:mag:题目传送门：

Leetcode：225. 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素
  • int top() 返回栈顶元素
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false

示例 1：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

💡解题关键：

  • 理解好队列与栈各自的特性，并试想如何利用此特性去操作两个队列模拟实现一个栈【即实现栈的LIFO特性】

➡️思路： 本质由队列底层实现栈

  • 1️⃣实现pop接口

  • 两个队列实现pop（出栈）接口，即实现后进先出，但队列的性质是先进先出，刚好相反，我们要怎么实现呢？

  • 此时就刚好体现两个队列的作用了，将两个队列分为空队列、 非空队列【非空or空是依据队列是否为空来灵活定义的，随时变化的】

  • 将 不为空的队列 的数据出队列入到 空队列 当中，当非空队列只剩下一个元素时，就可以pop，达到LIFO的目的

❗这里很巧妙的利用特性即达到后进后出，也达到即使元素在队列间不断出入，也没有改变在栈的角度看这些元素之间的顺序发生改变

✊动图示例：

在这里插入图片描述

  • 2️⃣实现push接口

  • 为了可以像执行pop后一样依旧保持“栈”内的压栈的顺序不变，我们选择往不为空的队列里插入数据，就可以实现同样效果

✊动图示例：

在这里插入图片描述

  • 3️⃣实现top接口

  • 判断两个队列中哪个是非空队列，并返回其队尾的结点即可

  • 4️⃣实现empty接口

  • 判断两个队列是否都为NULL，是则返回true，否则返回false

👉实现：

1️⃣实现队列的数据结构

typedef int QDataType;
typedef struct QueueNode
{
    struct QueueNode* next;
    QDataType data;

}QNode;

typedef struct Queue
{
    //int size;
    QNode* head;
    QNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = pq->tail = NULL;
}

void QueueDestroy(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }

    pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    newnode->data = x;
    newnode->next = NULL;

    if (pq->tail == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
}

void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* next = pq->head->next;
        free(pq->head);
        pq->head = next;
    }
}

QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->tail->data;
}

bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->head == NULL;
}

int QueueSize(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    int size = 0;
    while (cur)
    {
        ++size;
        cur = cur->next;
    }

    return size;
}

2️⃣模拟实现栈的接口

typedef struct {
    Queue q1;
    Queue q2;

} MyStack;

//初始化“栈”
MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);

    return pst;
}

//push
void myStackPush(MyStack* obj, int x) {
    //给非空队列进行入队操作
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

//pop
int myStackPop(MyStack* obj) {

    Queue* pEmpty = &obj->q1, *pNonEmpty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        pEmpty = &obj->q2;
        pNonEmpty = &obj->q1;
    }

    while(QueueSize(pNonEmpty) > 1)
    {
        QueuePush(pEmpty, QueueFront(pNonEmpty));
        QueuePop(pNonEmpty);
    }

    int top = QueueFront(pNonEmpty);
    //队尾元素出队
    QueuePop(pNonEmpty);

    return top;
}

//top
int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

//empty
bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

//释放
void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

🏷️用栈实现队列【难度：简单】

:mag:题目传送门：

Leetcode：232. 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾

  • int pop() 从队列的开头移除并返回元素

  • int peek() 返回队列开头的元素

  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

💡解题关键：

  • 理解好队列与栈各自的特性，并试想如何利用此特性去操作两个栈模拟实现一个队列【即实现队列的FIFO特性】

➡️思路： 本质由栈的底层实现队列

  • 1️⃣实现pop接口

  • 两个栈实现pop（出队列）接口，即实现先进先出，但栈的性质是后进先出，刚好相反，我们要怎么实现呢？

  • 此时就刚好体现两个栈的作用了，将两个队列分为专门入数据的栈、 专门出数据的栈

  • 将 专门入数据的栈 的数据出栈入到 专门出数据的栈 ，但正因为栈是后进先出的特性，导致数据入到另外一个栈里的顺序就是逆转过后的【不同于队列实现栈】，那此时就可以按照栈的特性去pop，达到队列的LIFO的目的

  • 这也是为什么令一个栈为专门入数据的栈，另外一个栈为专门出数据的栈

❗这里很巧妙的利用特性即达到先进后出，正是因为数据从一个栈里出来再入到另外一个栈里的顺序发生改变，从而可以直接利用后进先出达到先进先出的效果

✊动图示例：

在这里插入图片描述

✨综上：

  • 我们只要每次想出队列的时候，直接看专门出数据的栈进行出数据即可，所以我们可以先判断专门出数据的栈是否为NULL

    • 若为NULL，则将专门入数据的栈里的数据入到专门出数据的栈里，再由专门出数据的栈进行pop

    • 若不为NULL，则可以直接在专门出数据的栈利用后进先出栈的特性，达到队列先进先出对于原本数据的出队列的顺序要求

  • 2️⃣实现push接口

  • 为了可以依旧保持“队列”内的元素的顺序不变，我们选择往专门如数据的栈里插入数据，就可以实现顺序不变的效果

✊动图示例：

在这里插入图片描述

  • 3️⃣实现peek接口

  • 判断专门出数据的栈是否为空，若不为空则可直接栈顶的数据获取到队列的队头数据

  • 4️⃣实现empty接口

  • 判断两个栈是否都为NULL，是则返回true，否则返回false

👉实现：

1️⃣实现栈的数据结构

typedef int STDataType;

//数组实现栈
typedef struct Stack
{
    STDataType* a;
    int capacity; //容量，方便增容
    int top; // 表示栈顶
}Stack;

//初始化
void StackInit(Stack* pst);

//销毁
void StackDestory(Stack* pst);

//插入
void StackPush(Stack* pst, STDataType x);

//删除
void StackPop(Stack* pst);

//取栈顶的数据【返回栈顶的数据】
STDataType StackTop(Stack* pst);

//判断栈内是否为空
bool StackEmpty(Stack* pst);

//返回栈内数据的个数
int StackSize(Stack* pst);

void StackInit(Stack* pst)
{
    assert(pst);

    pst->a = (STDataType*)malloc(sizeof(STDataType) * 4);
    pst->top = 0;
    pst->capacity = 4;
}

//销毁
void StackDestory(Stack* pst)
{
    assert(pst);
    free(pst->a);
    pst->a = NULL;

    pst->capacity = pst->top = 0;
}

//插入数据
void StackPush(Stack* pst, STDataType x)
{
    assert(pst);

    if (pst->top == pst->capacity)
    {
        //增容
        STDataType* tmp = (STDataType*)realloc(pst->a,sizeof(STDataType) * pst->capacity * 2);
        if (tmp == NULL)
        {
            printf("realloc fail\n");
            exit(-1);//结束程序
            //这个-1不是return，而是给进程的，直接结束整个程序（return是结束当前函数） 
        }

        pst->a = tmp;
        pst->capacity = pst->capacity * 2;
    }

    pst->a[pst->top] = x;
    pst->top++;
}

//尾删【实际 就是删除排在最后，最晚***来的 栈顶】
void StackPop(Stack* pst)
{
    //跟之前一样，对栈顶的数据进行删除时
    //没必要抹除这个数据，只需要不访问到它就行
    assert(pst);
    //这里唯一需要考虑的是：这个栈里面是不是空的
    assert(!StackEmpty(pst)); //判断是不是 非空的
    pst->top--;
}

//返回栈顶的数据
STDataType StackTop(Stack*pst)
{
    assert(pst);
    //需要判断是不是不为空的
    assert(!StackEmpty(pst));

    return pst->a[pst->top - 1];
}

//判断栈内是否为空
bool StackEmpty(Stack* pst)
{
    assert(pst);
    return pst->top == 0; //如果等于0，则说明为真，即 如果为空，就返回TURE
                          //不为0，不为空，则返回 FALSE
}

//返回栈内数据的个数
int StackSize(Stack* pst)
{
    assert(pst);

    return pst->top; //top就是大小
}

2️⃣模拟实现队列的接口

typedef struct 
{
    Stack pushST;
    Stack popST;
} MyQueue;

//初始化
MyQueue* myQueueCreate()
{
    MyQueue*q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);

    return q;
}

//插入
void myQueuePush(MyQueue* obj, int x) 
{
    StackPush(&obj->pushST,x);
}

//出队列
int myQueuePop(MyQueue* obj) 
{
    assert(obj);
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int top = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return top;
}

//获取对头的数据
int myQueuePeek(MyQueue* obj) 
{
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }

    return StackTop(&obj->popST);
}

//empty
bool myQueueEmpty(MyQueue* obj) 
{
    return StackEmpty(&obj->popST)&&StackEmpty(&obj->pushST);
}

//释放
void myQueueFree(MyQueue* obj) 
{
    StackDestory(&obj->pushST);
    StackDestory(&obj->popST);
    free(obj);
}

🏷️ 设计循环队列【难度：中等】

:mag:题目传送门：

Leetcode：622. 设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k

  • Front: 从队首获取元素。如果队列为空，返回 -1

  • Rear: 获取队尾元素。如果队列为空，返回 -1

  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真

  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真

  • isEmpty(): 检查循环队列是否为空

  • isFull(): 检查循环队列是否已满

💡解题关键：

  • 要着重设计通过头尾指针表示出循环队列的结束标志和循环队列为NULL的标志

  • 循环队列不像队列，队列没有空间可以增容，但循环队列的空间是有限的

➡️思路： 用数组实现循环队列

  • 1️⃣ 当我们创造的空间大小与所需空间大小相等时，我们便无法再借助头尾指针去表示循环队列什么时候为NIULL，什么时候空间满了

    • 所以此时我们便可以通过创造比实际需求多1个空间的循环队列给予头尾指针更多的操作空间

  • 2️⃣判空条件即为：tail == front

  • 3️⃣判断队列满的条件：【tail+1= tailNext】tailNext== front

  • 4️⃣push的时候就根据tail走的去入数据

  • 5️⃣pop的时候就用front去走一步以达到删除一个元素的目的，因为front表示的队头的下标，如果队头下标移动了，说明判空条件也随着front下标的移动而移动，到时候原来的队头位置的数据就会因为入新的数据而被覆盖

❗特别注意：

  • tail的下标本质指向的是没有数据的空间，即tail-1下标指向的才是有数据的空间，因为每一次push之后，tail++就是指向"无数据"的空间了

  • 删除数据并不需要真正的删除，而是以覆盖代替删除，达到删除的效果，只要判断队列满了之后，tail走一步就是队列为空的条件，那tail再循环遍历队列的话，就是覆盖删除了

✊动图示例：

在这里插入图片描述

在这里插入图片描述

👉实现：

typedef struct 
{
    int* a;
    int k;//记录队列实际个数的大小

    int front; //头的下标
    int tail;
    //本质：指向的是真正有数据的结点的下一个结点
    //【因为tail指向的地方是没有数据的，而上一个是有数据的】
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue*cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    cq->a = (int*)malloc(sizeof(int) * (k+1));
    cq->front = 0;
    cq->tail = 0;
    cq->k = k;
    return cq;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->front == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    int tailNext = obj->tail+1;
    if(tailNext == obj->k+1) //说明此时tail已经到达空间的尾
    {
        tailNext = 0;// 那此时next就为 队列的头
    }

    return tailNext == obj->front;
}

//入数据
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->tail] = value;

        obj->tail++;

        //如果tail此时在尾巴上
        if(obj->tail == obj->k+1)
        {
            obj->tail = 0;
        }

        return true;
    }
}

//出数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front++;
        if(obj->front == obj->k+1)
        {
            obj->front = 0;
        }
        return true;
    }
}

//取头
int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->front];
}

//取尾 -- tail的前一个
int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    //极端情况：tail = 0的时候
    if(obj->tail == 0)
    {
        return obj->a[obj->k];
    }
    return obj->a[obj->tail-1];
}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a);
    free(obj);
}

🌟总结

综上，我们基本了解了数据结构中的 "栈和队列重要面试真题" :lollipop: 的知识啦~~

恭喜你的内功又双叒叕得到了提高！！！

感谢你们的阅读:satisfied:

后续还会继续更新:heartbeat:，欢迎持续关注:pushpin:哟~

:dizzy:如果有错误❌，欢迎指正呀:dizzy:

:sparkles:如果觉得收获满满，可以点点赞👍支持一下哟~:sparkles:
在这里插入图片描述

全部评论
牛客带你领略算法思想
点赞 回复 分享
发布于 2022-08-29 13:27 河南

相关推荐

04-29 13:34
蚌埠坦克学院 嵌入式软件开发
ARM架构 VS RISC-V架构
随着嵌入式、移动、物联网、AI等领域的高速发展，处理器架构的重要性越来越突出。其中，ARM架构和RISC-V架构成为最受关注的两大主流体系。那么，它们到底有什么不同？各自适合什么应用？本文将全面对比！1. 基本概念ARM架构由英国ARM公司（现属于Arm Holdings）设计授权。属于**精简指令集计算机（RISC）**范畴。以高性能、低功耗著称，广泛应用于智能手机、嵌入式设备、服务器等领域。ARM不直接生产芯片，而是将架构授权给芯片制造商（如高通、苹果、三星等）。RISC-V架构起源于美国加州大学伯克利分校，完全开源的指令集架构（ISA）。也是一种精简指令集（RISC）。任何个人或公司都可...
嵌入式面试八股文全集
点赞 评论 收藏
分享
04-28 16:17
4399_产品经理(准入职员工)
4399游戏内推-4399游戏内推码
4399游戏PM笔试题目：请列举当前游戏行业中三种热门的游戏类型，并分析其各自的用户群体特点和市场趋势。你认为未来游戏行业的发展方向有哪些？请结合技术发展和用户需求变化进行阐述。选择一款你熟悉的 4399 游戏，分析其核心玩法、优势以及存在的不足，并提出改进建议。以《王者荣耀》为例，分析其在社交互动方面的设计亮点，以及这些设计对游戏用户留存和活跃度的影响。请设计一款以 “古代神话” 为主题的 4399 小游戏，阐述其核心玩法、主要关卡设计和角色设定。假设要为 4399 平台开发一款面向小学生的教育类游戏，你会如何设计游戏的功能和玩法，以实现教育与娱乐的平衡？给出一组 4399 某款游戏的用户数...
点赞 评论 收藏
分享
03-17 10:14
广东工业大学 C++
暑实不应该
no_work_no_life：深圳，充电宝，盲猜anker
点赞 评论 收藏
分享
04-29 20:39
蔚来_AI算法应用工程师(准入职员工)
蔚来内推蔚来内推码
蔚来汽车AS一面面经7/5面试普通二本，老师推荐给的机会给蔚来投的简历，因此直接进入面试流程帖主有2个基本项目:1.selenium爬虫做招聘词条分析的简单项目2.美赛F奖的一个传统算法与机器学习相结合的音乐流派分析项目。1面:1.常规自我介绍2.介绍一下自己的第2个项目，然后我给面试官讲了为什么构建人际网络我不选择机器学习而是并查集，以及相似度类比用到的余弦相似度与k-means聚类，然后面试官问了一下k-means的原理与底层实现注意的细节，k-means的k值你是怎么定的呢？调参效果如何？余弦相似度介绍下为什么选择，他有什么优势吗？3.看了一下ACM经历，介绍下自己竞赛经历给你带来了什么...
点赞 评论 收藏
分享
评论
1
3
分享

全站热榜

更多

创作者周榜

更多
正在热议
更多
# 实习要如何选择和准备？ #
47461次浏览 748人参与
# 摸鱼被leader发现了怎么办 #
45153次浏览 319人参与
# 大疆求职进展汇总 #
472785次浏览 3181人参与
# 学历or实习经历，哪个更重要 #
88937次浏览 648人参与
# 潍柴工作体验 #
21082次浏览 18人参与
# 你觉得通信/硬件有必要实习吗？ #
95915次浏览 893人参与
# 找工作，行业重要还是岗位重要？ #
19977次浏览 354人参与
# Offer比较，求稳定还是求发展 #
42919次浏览 228人参与
# 你最满意的offer薪资是哪家公司？ #
19316次浏览 119人参与
# 来聊聊机械薪资天花板是哪家 #
113681次浏览 721人参与
# 硬件兄弟们 甩出你的华为奖状 #
96687次浏览 670人参与
# 金融财会交流会 #
102312次浏览 361人参与
# 机械人与华为的爱恨情仇 #
106810次浏览 923人参与
# 24届硬件人与华为的爱恨情仇 #
121402次浏览 962人参与
# 机械人怎么评价今年的华为 #
191816次浏览 1502人参与
# 运营面经 #
102531次浏览 1202人参与
# 外包能不能当跳板？ #
26538次浏览 192人参与
# 国企/银行/研究所公司爆料 #
125198次浏览 742人参与
# 国企还是互联网，你怎么选？ #
127867次浏览 963人参与
# 机械专业只有考研才有出路吗 #
96644次浏览 850人参与
牛客网
牛客企业服务