【代码详解之Day10篇】

doublelist.c (双向循环链表的功能函数)

#include"doublelist.h"

创建一个空的双向循环链表

//创建一个空的双向循环链表
doublelist * DoubleListCreate()
{
    //强转，在堆区创建空间
    doublelist *head = (doublelist *)malloc(sizeof(doublelist));
    
    //自己指向自己
    head->front = head;
    head->next = head;
    
    return head;
}

插入数据

//插入数据
void DoubleListInsert(doublelist *head,DataType value)
{
    //设置一个新的指针tmp
    doublelist *tmp = (doublelist *)malloc(sizeof(doublelist));

    //初始化tmp指针
    tmp->front = NULL;
    tmp->next = NULL;
    tmp->data = value;

    tmp->next = head->next;//tmp的next指针域保存head的后继结点的地址
    tmp->front = head;//tmp的front指针域保存head的地址
	
	head->next->front = tmp; head->next 指原先的第一个结点，其front指针域的地址指向tmp
    head->next = tmp;//tmp成为head新的后继结点
 
}

遍历双向循环链表

//遍历双向循环链表
void DoubleListPrint(doublelist *head)
{
    doublelist *p = head;
    while(p->next != head)//因为是循环链表所以最后一个指向头结点，
                        //当p->next = head时，说明遍历结束
    {
        p = p->next;
        printf("%d ",p->data);
    }
    putchar(10);//相当于换行，回车的ascall码为 10
}

//判断双向循环链表是否为空
int DoubleListIsEmpty(doublelist *head)
{
    return head->next == head ? 1 : 0;//三目运算
}

头删法删除数据

//头删法删除数据
DataType DoubleListDelete(doublelist *head)
{
    if(DoubleListIsEmpty(head))
    {
        printf("删除失败，该链表为空！\n");
        return (DataType)-1;
    }
    //临时保存数据
    DataType value = head->next->data;
    //tmp指针临时保存第一个结点的地址
    doublelist *tmp = head->next;

    //head的next指针域的地址指向 tmp此时的next指针域保存的地址，也就是第二个结点的地址
    head->next = tmp->next;
    
    //因为删除第一个结点所以此时第二个结点的fornt指向head结点
    tmp->next->front = head;

    free(tmp);
    tmp = NULL;

    return value;

}

seqstack.c （顺序栈的功能函数）

创建栈

//创建栈
seqstack* SeqStackCreate()
{
    seqstack *s = (seqstack *)malloc(sizeof(seqstack));
    s->pos = -1;//初始化，栈顶指向NULL
    return s;
}

判断栈是否为满

//判断栈是否为满
int SeqStackIsFull(seqstack *s)
{
    return s->pos == N - 1 ? 1 : 0; //三目运算
}

//判断栈是否为空
int SeqSrackIsEmpty(seqstack *s)
{
    return s->pos == -1 ? 1 : 0; //三目运算
}

入栈

//入栈
void SeqStackPush(seqstack *s,DataType value)
{
    if(SeqStackIsFull(s))
    {
        printf("栈满了！\n");
        return;
    }
    s->pos++; //自增，栈顶位置往上移动一个
    s->data[s->pos] = value; //将value的值赋给s->pos位置上的数据s->data
    return;
}

出栈

//出栈
DataType SeqStackPop(seqstack *s)
{
    if(SeqSrackIsEmpty(s))
    {
        printf("栈为空！\n");
        return (DataType)-1;
    }
    DataType value = s->data[s->pos]; //将s->pos位置上的数据s->data的值赋给 value
    s->pos--; //自减，栈顶位置往下移动一个
    return value;
}

linkstack.c （链栈的功能函数）

#include"linkstack.h"

初始化栈信息

//初始化栈信息
void InitStack(stack *s)
{
    s->length = 0;
    s->top = NULL;
}

入栈

//入栈
void push(stack *s,DataType value)
{
    if(NULL == s)//如果栈s为空
    {
        printf("栈空间分配失败，初始化失败！\n");
        return;
    }
    Node *tmp = (Node *)malloc(sizeof(Node));
    //初始化指针tmp
    tmp->next = NULL;
    tmp->data = value;

    tmp->next =  s->top;//tmp入栈
    s->top = tmp; //s->top上移到栈顶
    s->lemhth++;//自增因为入栈了一个结点，所以长度加一
}

获取栈顶元素

//获取栈顶元素
DataType GetTop(stack *s)
{
    if(NULL == s)//如果栈s为空
    {
        return (DataType)-1;
    }
    if(s->top == NULL)//如果栈顶为空
    {
        return (DataType)-1;
    }
    return s->top->data; //返回栈顶结点的数据
}

出栈

//出栈
DataType pop(stack *)
{
    if(NULL == s)//如果栈s为空
    {
        return (DataType)-1;
    }
    if(s->top == NULL)//如果栈顶为空
    {
        return (DataType)-1;
    }
    Node *tmp = s->top;//定义一个指针tmp
    s->top = tmp->next;//s->top指向tmp的next指针域保存的地址，即：下移一位
    DataType value = tmp->ndata;//定义一个数据保存
    free(tmp);//释放指针tmp
    tmp = NULL;

    s->length--;//自减，因为出栈了一个结点，所以长度减一
    return value;
}

判断栈是否为空

//判断栈是否为空
int EmptyStack(stack *s)
{
    return s-top == NULL ? 1 : 0; //三目运算
}

//清空栈
int ClearStack(stack *s)
{
    if(NULL == s) //如果栈s为空
    {
        return (DataType)-1;
    }
    if(s->top == NULL)//如果栈顶为空
    {
        return (DataType)-1;
    }
    Node *tmp = s->top; //定义一个指针tmp
    while(tmp)//即 while(tmp != NULL)
    {
        s->top = tmp->next; //s->top指向tmp的next指针域保存的地址，即：下移一位
        free(tmp); //释放指针tmp现在保存的地址，相当于一次出栈
        tmp = s->top;//指针tmp再次指向s->top
        s->length--;
    }
}