C语言强化——链表（2）

目录

链表的应用：

• 栈
• 循环队列
• C语言实现动态数组
• 数组实现定长元素个数层次建树
• 队列实现不定元素个数层次建树 (*)

栈

栈（链表应用）

"stack.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct tag{
    int m_ival;
    struct tag *next;
}Node,*pNode;

typedef struct{
    pNode phead;//栈顶指针
    int size;
}Stack,*pStack;

void initStack(pStack);
void pop(pStack);
void push(pStack,int);
int top(pStack);
int empty(pStack);
int size(pStack);

"stack.c"

#include "stack.h"

void initStack(pStack p)
{
    memset(p,0,sizeof(Stack));
}
void pop(pStack p)
{
    if(!p->size)
    {
        printf("stack is empty\n");
        return;
    }
    p->phead=p->phead->next;
    p->size--;
}
void push(pStack p,int val)
{
    pNode pNew=(pNode)calloc(1,sizeof(Node));
    pNew->m_ival=val;
    if(NULL==p->phead)
    {
        p->phead=pNew;
    }else{
        pNew->next=p->phead;//新结点的next指向原有头结点
        p->phead=pNew;
    }
    p->size++;
}
int top(pStack p)
{
    return p->phead->m_ival;
}
int empty(pStack p)
{
    return !p->size;
}
int size(pStack p)
{
    return p->size;
}

"main.c"

#include "stack.h"

int main() {
    Stack s;
    initStack(&s);
    push(&s, 5);
    push(&s, 10);
    printf("Stack size is %d\n", size(&s));
    printf("Stack top val is %d\n", top(&s));
    pop(&s);
    printf("Stack top val is %d\n", top(&s));
    pop(&s);
    pop(&s);
    return 0;
}

循环队列

queue.h

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

#define MaxSize 5
typedef int ElemType;
typedef struct{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;

void InitQueue(SqQueue*);
int EnQueue(SqQueue*,ElemType);
int DeQueue(SqQueue*,ElemType*);

queue.c

#include "queue.h"

void InitQueue(SqQueue* pq)
{
    pq->front=pq->rear=0;
}

int EnQueue(SqQueue* pq,ElemType val)
{
    if((pq->rear+1)%MaxSize==pq->front)
    {
        printf("queue is full\n");
        return 0;
    }
    pq->data[pq->rear]=val;
    pq->rear=(pq->rear+1)%MaxSize;
    return 1;
}
int DeQueue(SqQueue* pq,ElemType* x)
{
    if(pq->rear==pq->front)
    {
        printf("queue is empty\n");
        return 0;
    }
    *x=pq->data[pq->front];
    pq->front=(pq->front+1)%MaxSize;
    return 1;
}

main.c

#include "queue.h"

int main()
{
    SqQueue q;
    ElemType val;
    InitQueue(&q);
    EnQueue(&q,10);
    EnQueue(&q,7);
    EnQueue(&q,5);
    EnQueue(&q,3);
    EnQueue(&q,9);
    DeQueue(&q,&val);
    system("pause");
}

C语言实现动态数组

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

typedef struct{
    char *p;
    int size;//当前放了多少数据
    int capacity;//容量大小，申请了多少空间
}DynArr;

#define N 10
int main()
{
    DynArr d;
    int i=0;
    d.size=0;
    d.capacity=N;
    d.p=(char*)malloc(d.capacity);
    while(scanf("%c",d.p+d.size)!=EOF)
    {
        d.size++;
        if(d.size==d.capacity)
        {
            d.capacity=d.capacity*2;
            d.p=(char*)realloc(d.p,d.capacity);
        }
    }
    d.p[d.size-1]='\0';
    printf("%s\n",d.p);
    system("pause");
}

队列实现不定元素个数层次建树 (*)

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

typedef char ElemType;
typedef struct node{
    ElemType c;
    struct node *pleft;
    struct node *prgiht;
}Node,*pNode;

typedef struct que{
    pNode p;
    struct que *pNext;
}Que_t,*pQue_t;

//前序遍历
void preOrder(pNode p)
{
    if(p)
    {
        putchar(p->c);
        preOrder(p->pleft);
        preOrder(p->prgiht);
    }
}
int main()
{
    ElemType c;
    pQue_t queHead=NULL,queTail=NULL,queNew,queFree;
    pNode treeRoot=NULL,treeNew;
    while(scanf("%c",&c)!=EOF)
    {
        if(c=='\n')
        {
            break;
        }
        treeNew=(pNode)calloc(1,sizeof(Node));//给树的新结点申请空间
        treeNew->c=c;
        queNew=(pQue_t)calloc(1,sizeof(Que_t));//给队列的新结点申请空间
        queNew->p=treeNew;
        if(!treeRoot)
        {
            treeRoot=treeNew;//第一个结点作为树根
            queHead=queTail=queNew;//第一个结点作为队列头
        }else{

            if(NULL==queHead->p->pleft)
            {
                queHead->p->pleft=treeNew;
            }else if(NULL==queHead->p->prgiht)
            {
                queHead->p->prgiht=treeNew;
                //头部删除法
                queFree=queHead;
                queHead=queHead->pNext;
                free(queFree);
            }
            //尾插法
            queTail->pNext=queNew;
            queTail=queNew;
        }
    }
    preOrder(treeRoot);
    printf("\n");
    system("pause");
}

数组实现定长元素个数层次建树

#include<stdio.h>
#define N 10

typedef char ElemType;
typedef struct node {
    ElemType c;
    struct node *pleft;
    struct node *pright;
}Node, *pNode;

void preOrder(pNode p)
{
    if (p)
    {
        putchar(p->c);
        preOrder(p->pleft);
        preOrder(p->pright);
    }
}

int main() {
    ElemType c[N + 1] = "ABCDEFGHIJ";
    int i, j;
    pNode p[N];   //结构体指针数组
    pNode root;
    for (i = 0;i < N;++i) {
        p[i] = (pNode)calloc(1, sizeof(Node));
        p[i]->c = c[i];
    }
    root = p[0];
    j = 0;
    for (i = 1;i < N;++i) {
        if (NULL == p[j]->pleft) {
            p[j]->pleft = p[i];
        }
        else if (NULL == p[j]->pright) {
            p[j]->pright = p[i];
            j++;
        }
    }
    preOrder(root);
    return 0;
}