プログラマ専用SNS ミクプラ

typedef struct List{
    struct List *prev;
    struct List *Next;
    ここに空リスト管理？
    ここに高優先度登録リスト管理？
    ここに通常優先度登録リスト管理？
}

typedef struct list List;
struct list{
    List *next,*prev;
    char *rec;
};

・プログラム全体で3つのルート(リストの起点)を持つ場合

List *nRoot,*hpRoot,*npRoot;

上みたいにrootを持っておけば大丈夫です。

・３つのリストを管理する構造体を定義し、プログラム全体で
  １つだけこの構造体のインスタンスを持つ場合

struct{
    List *n;//空リスト
    List *hp;//高優先度
    List *np;//通常優先度
}Root;

typedef struct list List;
struct list{
    List *next,*prev;
    char *rec;
};

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

struct Root root;

int    QueOpen(int RecSize, int RecN)
{
    // 引数のチェック
    if (RecSize <= 0 || RecN <= 0) {
        return -1;
    }
    
    root->List.Empty = (char *)calloc(RecSize, RecN);
        ↑で怒られます。
        流れとしてはココで3つのリスト分（空、高優先度、通常優先度）
        のメモリを確保しなくてはいけないのでしょうか？

    if (rec == NULL) {
        return -1;
    }
    
    return 0;
}

コンパイルが通らないなら通らないで
せめてエラーの内容が無いと困ります＾＾；

struct {
    List    *Empty;        // 空リスト
    …
} Root;
この書き方は、Root と言う名前の構造体を定義するのではなく
名無しの構造体で Root 変数を宣言するとなるので
struct Root root は通りません。

仮に root が通ったとしても
root->List.Empty
root はポインタではないのでアロー演算子は使えません。

Root が持っているのはListという変数ではないので
アクセスする場合は
Root.List.Empty でなく Root.Empty となります。

後半にいきなり rec という変数が出てきています。

calloc の引数は num,size の順番です。

あと、QueOpen は
1．List 1個分だけ calloc
2. その中の rec に対して RecSize 分だけ calloc
3. 空リストに繋げる
4. 1~3を RecN 回繰り返す
このような手順でいくのがいいかと思います。

struct list{
    list *next,*prev;
    char *rec;
}lowPriority,highPriority,normalPriority;

typedef struct List {
    struct    List    *next, *prev;
    char             *rec;
} List;

typedef struct {
    int        cntRegist;        // 登録最大件数
    int        cntEnptyList;        // 空リスト登録数
    int        cntHighPriorityList;    // 高優先度リスト登録数
    int        cntNormalPriorityList;    // 通常優先度リスト登録数
} CntList;

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

struct list{
    list    *next,*prev;
    char     *rec;
} enpty, high, normal;


int QueOpen(int RecSize, int RecN)
{
    struct    list    *p, *tempPre;
    int        i;
    
    // 引数のチェック
    if (RecSize <= 0 || RecN <= 0) {
        return -1;
    }
    
    p = NULL;
    tempPre = NULL;
    enpty.prev = NULL;
    normal.prev = NULL;
    high.prev = NULL;

    list* pNodeList[/url] = { &enpty, &normal, &high };
    
    for (i = 0; i < 3; i++) {
        list *p = pNodeList
        for (j = 0; j < RecN; j++){
            p->rec = (char *)malloc(RecSize);
            p->next = (list *)malloc(sizeof(list));
            if (p->next == NULL) {
                return -1;
            }
            tempPre = p;
            p = p->next;
            p->prev = tempPre;
        }
    }    
    return 0;
}

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

typedef struct {
    char    *rec;
    struct    List    *prev;
    struct    List    *next;
} List;

// 管理テーブル
typedef struct {
    int        RecN;
    List    *dataList;
} ControlList;

ControlList    empty, high, normal;

int QueOpen(int RecSize, int RecN)
{
    List    *now;
    List    *pre;
    int        i;

    // 引数のチェック
    if (RecSize <= 0 || RecN <= 0) {
        return -1;
    }

    empty.dataList->rec   = NULL;
    empty.dataList->prev  = NULL;
    empty.dataList->next  = NULL;

    now = &empty;
    pre = NULL;
    for (i = 0; i < RecN; i++) {
        now->rec = (char *)malloc(RecSize);
        if (now->rec == NULL) {
            return -1;
        }
        if (i + 1 < RecN) {
            now->next = (List *)malloc(sizeof(List));
            if (now->next == NULL) {
                return -1;
            }
        }
        if (pre != NULL) {
            now->prev = pre;
        }
        pre = now;
        now = now->next;
    }
    return 0;
}

int    main(void)
{
    QueOpen(10,2);

    return 0;
}