数据布局C语言实现之行列

副标题#e#

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

typedef int elemType;
/************************************************************************/
/*                    以下是关于行列链接存储操纵的6种算法               */
/************************************************************************/
struct sNode{
    elemType data;            /* 值域 */
    struct sNode *next;        /* 链接指针 */
};
struct queueLK{
    struct sNode *front;    /* 队首指针 */
    struct sNode *rear;        /* 队尾指针 */
};

/* 1.初始化链队 */
void initQueue(struct queueLK *hq)
{
    hq->front = hq->rear = NULL;        /* 把队首和队尾指针置空 */
    return;
}

/* 2.向链队中插入一个元素x */
void enQueue(struct queueLK *hq, elemType x)
{
    /* 获得一个由newP指针所指向的新结点 */
    struct sNode *newP;
    newP = malloc(sizeof(struct sNode));
    if(newP == NULL){
        printf("内存空间分派失败！ ");
        exit(1);
    }
    /* 把x的值赋给新结点的值域，把新结点的指针域置空 */
    newP->data = x;
    newP->next = NULL;
    /* 若链队为空，则新结点等于队首结点又是队尾结点 */
    if(hq->rear == NULL){
        hq->front = hq->rear = newP;
    }else{    /* 若链队非空，则依次修改队尾结点的指针域和队尾指针，使之指向新的队尾结点 */
        hq->rear = hq->rear->next = newP;        /* 留意赋值顺序哦 */
    }
    return;
}

/* 3.从行列中删除一个元素 */
elemType outQueue(struct queueLK *hq)
{
    struct sNode *p;
    elemType temp;
    /* 若链队为空则遏制运行 */
    if(hq->front == NULL){
        printf("行列为空，无法删除！ ");
        exit(1);
    }
    temp = hq->front->data;        /* 暂存队尾元素以便返回 */
    p = hq->front;                /* 暂存队尾指针以便接纳队尾结点 */
    hq->front = p->next;        /* 使队首指针指向下一个结点 */
    /* 若删除后链队为空，则需同时使队尾指针为空 */
    if(hq->front == NULL){
        hq->rear = NULL;
    }
    free(p);        /* 接纳原队首结点 */
    return temp;    /* 返回被删除的队首元素值 */
}

/* 4.读取队首元素 */
elemType peekQueue(struct queueLK *hq)
{
    /* 若链队为空则遏制运行 */
    if(hq->front == NULL){
        printf("行列为空，无法删除！ ");
        exit(1);
    }
    return hq->front->data;        /* 返回队首元素 */
}

/* 5.查抄链队是否为空，若为空则返回1, 不然返回0 */
int emptyQueue(struct queueLK *hq)
{
    /* 判定队首或队尾任一个指针是否为空即可 */
    if(hq->front == NULL){
        return 1;
    }else{
        return 0;
    }
}

/* 6.排除链队中的所有元素 */
void clearQueue(struct queueLK *hq)
{
    struct sNode *p = hq->front;        /* 队首指针赋给p */
    /* 依次删除行列中的每一个结点，最后使队首指针为空 */
    while(p != NULL){
        hq->front = hq->front->next;
        free(p);
        p = hq->front;
    }    /* 轮回竣事后队首指针已经为空 */
    hq->rear = NULL;        /* 置队尾指针为空 */
    return;
}

/************************************************************************/
int main(int argc, char* argv[])
{
    struct queueLK q;
    int a[8] = {3, 8, 5, 17, 9, 30, 15, 22};
    int i;
    initQueue(&q);
    for(i = 0; i < 8; i++){
        enQueue(&q, a[i]);
    }
    printf("%d ", outQueue(&q));    printf("%d  ", outQueue(&q));
    enQueue(&q, 68);
    printf("%d ", peekQueue(&q));    printf("%d  ", outQueue(&q));
    while(!emptyQueue(&q)){
        printf("%d ", outQueue(&q));
    }
    printf(" ");
    clearQueue(&q);
    system("pause");
}

#p#副标题#e#

#include <stdio.h>
#include <stdlib.h>
typedef int elemType;

/************************************************************************/
/*                      以下是关于行列顺序存储操纵的6种算法               */
/************************************************************************/

struct queue{
    elemType *queue;        /* 指向存储行列的数组空间 */
    int front, rear, len;    /* 队首指针（下标），队尾指针（下标），行列长度变量 */
    int maxSize;            /* queue数组长度 */
};

void againMalloc(struct queue *q)
{
    /* 空间扩展为本来的2倍，原内容被自动拷贝到p所指向的存储空间中 */
    elemType *p;
    p = realloc(q->queue, 2 * q->maxSize * sizeof(elemType));
    /* 动态存储空间分派，若失败则退出运行 */
    if(!p){
        printf("空间分派失败！ ");
        exit(1);
    }
    q->queue = p;        /* 使queue指向新的行列空间 */
    /* 把原行列的尾部内容后移maxSize个位置 */
    if(q->rear != q->maxSize -1){
        int i;
        for(i = 0; i <= q->rear; i++){
            q->queue[i+q->maxSize] = q->queue[i];
        }
        q->rear += q->maxSize;        /* 队尾指针后移maxSize个位置 */
    }
    q->maxSize = 2 * q->maxSize;    /* 把行列空间巨细修改为新的长度 */
    return;
}

/* 1.初始化行列 */
void initQueue(struct queue *q, int ms)
{
    /* 查抄ms是否有效，若无效则退出运行 */
    if(ms <= 0){
        printf("ms值犯科! ");
        exit(1);
    }
    q->maxSize = ms;        /* 置行列空间巨细为ms */
    /* 动态存储空间分派，若失败则退出运行 */
    q->queue = malloc(ms * sizeof(elemType));
    if(!q->queue){
        printf("内存空间分派失败！ ");
        exit(1);
    }
    q->front = q->rear = 0;        /* 初始置行列为空 */
    return;
}

/* 2.向行列中插入元素x */
void enQueue(struct queue *q, elemType x)
{
    /* 当行列满时进动作态生分派 */
    if((q->rear + 1) % q->maxSize == q->front){
        againMalloc(q);
    }
    q->rear = (q->rear + 1) % q->maxSize;        /* 求出队尾的下一个位置 */
    q->queue[q->rear] = x;                        /* 把x的值赋给新的队尾 */
    return;
}

/* 3.从行列中删除元素并返回 */
elemType outQueue(struct queue *q)
{
    /* 若行列为空则终止运行 */
    if(q->front == q->rear){
        printf("行列为空，无法删除！ ");
        exit(1);
    }
    q->front = (q->front +1) % q->maxSize;        /* 使队首指针指向下一个位置 */
    return q->queue[q->front];                    /* 返回队首元素 */
}

/* 4.读取队首元素，不改变行列状态 */
elemType peekQueue(struct queue *q)
{
    /* 若行列为空则终止运行 */
    if(q->front == q->rear){
        printf("行列为空，无法删除！ ");
        exit(1);
    }
    return q->queue[(q->front +1) % q->maxSize];/* 队首元素是队首指针的下一个位置中的元素 */
}

/* 5.查抄一个行列是否为空，若是则返回1,不然返回0 */
int emptyQueue(struct queue *q)
{
    if(q->front == q->rear){
        return 1;
    }else{
        return 0;
    }
}

/* 6.排除一个行列，并释放动态存储空间 */
void clearQueue(struct queue *q)
{
    if(q->queue != NULL){
        free(q->queue);
        q->queue = NULL;            /* 配置行列空间指针为空 */
        q->front = q->rear = 0;        /* 配置行列为空 */
        q->maxSize = 0;                /* 配置行列巨细为0 */
    }
    return;
}

/************************************************************************/

int main(int argc, char* argv[])
{
    struct queue q;
    int a[8] = {3, 8, 5, 17, 9, 30, 15, 22};
    int i;
    initQueue(&q, 5);
    for(i = 0; i < 8; i++){
        enQueue(&q, a[i]);
    }
    printf("%d ", outQueue(&q));    printf("%d  ", outQueue(&q));
    enQueue(&q, 68);
    printf("%d ", peekQueue(&q));    printf("%d  ", outQueue(&q));
    while(!emptyQueue(&q)){
        printf("%d ", outQueue(&q));
    }
    printf(" ");
    clearQueue(&q);
    system("pause");
    return 0;
}