自己的Queue

/*
 * Queue サンプル
 *
 *  2004.12.08
 *
 */

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

typedef struct _LIST{
    int data;
    struct _LIST *next;
}LIST;

LIST *NodeAlloc(void);
void NodeFree(LIST *Node);
void HeadInsert(LIST **Head, LIST *Node);
void TailInsert(LIST **Head, LIST *Node);
void DeleteNode(LIST **Head, int Position);

int GetNodeTotal(LIST **Head);
LIST *GetNode(LIST **Head, int n);

int main(void)
{
    LIST *p, *wp;
    LIST *head;
    int w, in, data;

    head = (LIST *)NULL;

    for(;;){
        printf(" 1.キューに入れる\n");
        printf(" 2.キューから取り出す\n");
        printf(" 3.キューに連続で入れる -1で終了\n");
        printf(" 4.全データ表示\n");
        printf(" 5.要素の数\n");
        printf("-1.終了\n");
        printf("\n");
        printf("Input Number >> ");

        scanf("%d", &in);
        if(in == -1)
            break;

        switch(in){
            case 1:
                printf("Data   >> ");
                scanf("%d", &data);
                p = NodeAlloc();
                p->data = data;
                TailInsert(&head, p);
                printf("入れました >> %d\n", p->data);
                break;

            case 2:
                w=1;                            /* 先頭を指定 */
                p=GetNode(&head, w);
                if(p!=(LIST *)NULL){
                    printf("取り出しました >> %d\n", p->data);
                    DeleteNode(&head, w);
                }else{
                    printf("取り出すデータはありません");
                }
                printf("\n");
                break;

            case 3:
                for(;;){
                    printf("Data >> ");
                    scanf("%d", &data);
                    if(data==-1)break;

                    p = NodeAlloc();
                    p->data = data;

                    TailInsert(&head, p);
                }
                break;
            case 4:
                printf("\nView All Data\n");
                w=1;
                while((p=GetNode(&head, w))!=(LIST *)NULL){
                    printf("%2d >> %d\n", w, p->data);
                    w++;
                }
                printf("\n");
                break;
            case 5:
                printf("\n要素の数 >> %d個\n", GetNodeTotal(&head));
                break;
            default:
                break;
        }
        printf("\n");
    }

    for(p=head; p!=(LIST *)NULL; p = wp){
        wp = p->next;
        NodeFree(p);
    }
    return 0;
}

/*
 * リストの先頭にNodeを追加
 */

void HeadInsert(LIST **Head, LIST *Node)
{
      /* データを追加 */
    Node->next = *Head;
    *Head = Node;
}

/*
 * リストの最後にNodeを追加
 */

void TailInsert(LIST **Head, LIST *Node)
{
    LIST *p;

    if(*Head == (LIST *)NULL){ /* リストにデータが無い場合、先頭に追加 */
        HeadInsert(Head, Node);
    }else{
        for(p=*Head; p->next!=(LIST *)NULL; p=p->next); /* リストの最後を検索 */

          /* データを追加 */
        p->next = Node;
        Node->next = NULL;
    }
}

/*
 * リスト内のNodeを削除
 */

void DeleteNode(LIST **Head, int Position)
{
    LIST *p, *Node;

    Position--;                                   /* 削除位置の一つ前にする */

    if(*Head != (LIST *)NULL){                    /* LISTが存在しないなら終了 */
        if(Position==0){                          /* 削除位置が先頭なら解放 */
            p=*Head;
            *Head = p->next;
            NodeFree(p);
        }else if(GetNodeTotal(Head)>Position && Position>0){   /* 削除位置がList内なら */
            p=GetNode(Head, Position);            /* 削除位置のNodeを取得 */
            Node = p->next;                       /* Nodeを解放する */
            p->next = Node->next;
            NodeFree(Node);
        }
    }
}

/*
 * Nodeを確保する
 */

LIST *NodeAlloc(void)
{
    return (LIST *)malloc(sizeof(LIST));
}

/*
 * Nodeを解放する
 */

void NodeFree(LIST *Node)
{
    free(Node);
}

/*
 * Nodeの総数を取得
 */

int GetNodeTotal(LIST **Head)
{
    LIST *p;
    int n=0;

    for(p=*Head; p!=(LIST *)NULL; p=p->next)    /* NULLが出るまで、ノードをカウント */
        n++;

    return n;
}

/*
 * Nodeのデータを取得
 */

LIST *GetNode(LIST **Head, int n)
{
    int j=1;
    LIST *p;

    for(p=*Head; p!=(LIST *)NULL; p=p->next){    /* NULLが出るか、n番目のノードを取得するまでループ */
        if(j==n)break;
        j++;
    }

    return p;
}
http://www.daccho-it.com/program/algo/queue.c
时间: 2024-10-02 07:27:43

自己的Queue的相关文章

UVALive-7304 - Queue of Soldiers 【动态规划】【组合函数】【好题】

UVALive- 7304 - Queue of Soldiers 题目链接:7304 题目大意:士兵过山洞,必须以类似7 6 5 4 3 2 1顺序过.在第i个人之后,比i高的人都会被杀死,问如果要杀死k个人,有几种排队方法. 题目思路:先将士兵的身高离散化.假设N表示不同身高的数目.cnt[i] 表示i这个身高的人有多少个.(i的范围为1~N)sum[i]表示小于等于该身高段的士兵数目 然后开始dp,dp[i][j]表示已经到第i个士兵,已经死了j个人的方法数. 第三维遍历,q表示,第i+1

Java集合类: Set、List、Map、Queue使用

目录 1. Java集合类基本概念 2. Java集合类架构层次关系 3. Java集合类的应用场景代码 1. Java集合类基本概念 在编程中,常常需要集中存放多个数据.从传统意义上讲,数组是我们的一个很好的选择,前提是我们事先已经明确知道我们将要保存的对象的数量.一旦在数组初始化时指定了这个数组长度,这个数组长度就是不可变的,如果我们需要保存一个可以动态增长的数据(在编译时无法确定具体的数量),java的集合类就是一个很好的设计方案了. 集合类主要负责保存.盛装其他数据,因此集合类也被称为容

【译】RabbitMQ:工作队列(Work Queue)

在第一篇我们写了两个程序通过一个命名的队列分别发送和接收消息.在这一篇,我们将创建一个工作队列在多个工作线程间分发耗时的工作任务. 工作队列的核心思想是避免立刻处理资源密集型任务导致必须等待其执行完成.相反的,我们安排这些任务在稍晚的时间完成.我们将一个任务封装为一个消息并把它发送到队列中.一个后台的工作线程将从队列中取出任务并最终执行.当你运行多个工作线程,这些任务将在这些工作线程间共享. 这个概念对于在一个HTTP请求中处理复杂任务的Web应用尤其有用. 准备工作 在前一篇中,我们发送了一条

HDU 1908 Double Queue&lt;Set&gt;

Problem Description The new founded Balkan Investment Group Bank (BIG-Bank) opened a new office in Bucharest, equipped with a modern computing environment provided by IBM Romania, and using modern information technologies. As usual, each client of th

UVa 133 The Dole Queue

 The Dole Queue  In a serious attempt to downsize (reduce) the dole queue, The New National Green Labour Rhinoceros Party has decided on the following strategy. Every day all dole applicants will be placed in a large circle, facing inwards. Someone i

python线程队列---queue

queue队列 :使用import queue,用法与进程Queue一样 用法介绍: class queue.Queue(maxsize=0) #先进先出 import queue q=queue.Queue() q.put('first') q.put('second') q.put('third') print(q.get()) print(q.get()) print(q.get()) ''' 结果(先进先出): first second third ''' class queue.Lif

queue

queue是一种先进先出的数据结构.以下由简入繁引入queue. queue的操作主要有:入队,出队,空满判断等. 1. 数组实现简单队列 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MAX 10 int arr[MAX]; int head = 0; int tail = 0; int counter = 0; void enqueue(int value) { arr[tai

queue队列

今天有一个需求需要随时更新数据需要及时删除过期数据,就用到队列了.每执行一次定时任务就往queue中加一次数据,所以需要在一个独立于定时任务的类中加静态属性: public static Queue<CB_SingleDolaryToday> queue = new LinkedList<>() 因为需要求元素和所以加静态属性   public static double sumDolary = 0.0; 在定时任务中需要更新队列并删除过期元素 /*** 循环检测队列头元素,如果超

Deque 和Queue

概述 接口,一个线性结合,支持在集合首尾add , remove , deque 是double  ended queue 的缩写,意味双端队列,接口提供的方法有两种类型,如果失败,一种抛出异常,一种返回特殊值(null, false)   第一个元素(头部) 最后一个元素(尾部)   抛出异常 特殊值 抛出异常 特殊值 插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e) 移除 removeFirst() pollFirst() remove

在Golang中实现有无限容量的同步Queue

chan对象是Golang的一个核心卖点,可以轻松实现goroutine之间的通信.Golang允许我们为chan设置不同的缓冲大小.当默认缓冲大小为0的时候,一个goroutine对chan的写入操作必须要等到有其他goroutine对chan进行读取的时候才会返回,反之一个goroutine对chan进行读取的时候要等到另外一个goroutine对chan进行写入才会返回.如果我们不希望每次对chan进行读取和写入都堵塞的话,可以对chan设置缓冲大小.这样,在缓冲区没满之前,gorouti