0

我一直在制作队列并尝试管理它。我需要一个队列来记录我的 udp 单服务器/多客户端应用程序中的活动客户端（我被迫使用 udp，所以请不要建议转移到 tcp）。

有单个服务器和 x 个客户端。每当客户端发送其第一条消息时，该客户端的 ip 号和端口号都会被 push() 到队列中。

然后，每 5 秒后，服务器将 ip 和端口号从队列中弹出，并使用此 ip 和端口号向客户端发送一条消息。如果客户端在特定时间内回复，则认为它是“活动的”，但如果在超时内没有收到来自客户端的回复，则认为客户端已死，必须从队列中删除。

现在的问题是如何删除这个节点。一种选择是简单地添加 NULL 代替此节点，但我想从队列中完全删除此节点。

任何建议都非常受欢迎。

下面是我的代码：

struct node
{
    int rollno;
    struct node*n;
};

struct node* create()
{
    struct node*q;
    q=(struct node*)malloc(sizeof(struct node));
    return q;
}
void push(struct node*cur)
{
    if(head==NULL)
    {
        head = cur;
        tail = cur;
        start = cur; //keeps a track of first node
    }
    else
    {
        struct node*f;
        f=head;
        head->n = cur;
        head=head->n; //keep updating head
    }
}

struct node* pop()
{
    struct node*p;
    struct node*s = NULL;p = tail;

    if (p == head && tail != head) /*if at the end of list, display starting from first element as Queue is FIFO*/
    {
        p = start;
        tail=p->n;
        s = p;
        display(s);
        return s;
    }

    if(p == NULL)
    {
        if (start == NULL)  //if no emelemt yet in the Queue
           return NULL;
        else // if at the End of list, go back to start
           {
              p = start;
              tail=p->n;
              s = p;
           }
    }
    else 
    {
           tail=p->n; //keep updating tail
           s = p;
    }

    display(s);
    return s;
}

void main()
{
   while(1)
   {
        //if new client
    struct node*j;  
    j = create();
        // j= ip and port of client.
    j->n=NULL;
        push(j); 
        //after every 5 secs
        {
           pop();
           //if client fails to reply
           {
              delete node.
           }
        }
   }



}
4

3 回答 3

1

由于它是一个队列，因此删除只会发生在前面，这意味着您只需要摆脱 head 元素。就像是：

void delete()
{
    node* temp = head;  /* store the head the pointer so we can free it later */
    head = head->next;  /* make the node next to head be the head */
    free(temp);         /* free the original head pointer */
}

考虑到您的评论，如果我理解正确，您需要删除链表中的任何节点。

这是链表中节点的删除函数，它处理三个 3 种不同的情况 - 如果要删除的节点是头部、尾部或介于两者之间（请注意，您需要提供自己的识别死节点的功能）：

/* need id argument to know which node needs to be deleted
 * we need to already know which node is dead */
void delete_arbitrary(int id) 
{
    if (head->rollno == id) /* id matches that of head, let's delete it */
    {
        node* temp = head;  /* store the head pointer so we can free it later */
        head = head->next;  /* make the node next to head be the head */
        free(temp);         /* free the original head pointer */
    }
    else /* node somewhere down the line, let's find it */
    {
        node* curr = head->next /* start from the node after the head */
        node* prev; /* this is to keep track of the previous node */

        while(curr->rollno != id && curr != NULL)
        {
            prev = curr;
            curr = curr->next;
        }

        if (curr == NULL) /* didn't find it so let's report it and quit */
        {
            printf("Node not found\n");
        }
        else if (curr->next == NULL) /* we're at the tail */
        {
            node* temp = tail; /* store it for later deletion */
            tail = prev; /* the previous node is now the tail */
            free(temp); /* free the old tail */
        }
        else /* it's somewhere in between */
        {
            prev->next = curr->next; /* the previous node now points to the one after the current */
            free(curr); /* get rid of the current pointer */
        }
    }
}
于 2013-06-13T06:20:40.923 回答
1

如果使用malloc函数为节点分配内存，则可以使用free函数释放该内存。在这里，您没有为 j 指针分配内存，这是一个错误。

在您的应用程序中，您必须每 5 分钟检查一次每个元素是否处于活动状态，如果此时任何节点处于非活动状态，则必须将其删除。所以，我认为你不需要 FIFO 数据结构。最好使用链表数据结构。

于 2013-06-13T06:32:14.783 回答
1

正如DPG所说，链表更适合这里。

现在，你需要这样的东西吗？

void freenode(struct node* n)
{
    struct node* p = start;
    struct node* last = start;
    while (p != NULL) {
        if (p == n) {
            if (p == start) {
                if (p->n = NULL) {
                    head = NULL;
                    start = NULL;
                    tail = NULL;
            }
            else {
                if (tail == start)
                    tail = start->n;
                    start = start->n;
            }
            }
            else if (p == head) {
                head = last;
            head->n = NULL;
            }
            else {
                last->n = p->n;
            }
            free(p);
            break;
        }
        last = p;
        p = p->n;
    }
}
于 2013-06-13T06:49:56.510 回答