链表实现队列-栈

#include<stdio.h>
#include<stdlib.h>
//定义节点
typedef int data_t;
typedef struct link{
data_t data;
struct link *next;
}link_t;
//定义队列首尾
typedef struct {
link_t *head;
link_t *tail;
}link_queue_t;
//创建队列
link_queue_t *creat_queue()
{
link_queue_t *lqp = NULL;
lqp = malloc(sizeof(link_queue_t));
lqp->head = malloc(sizeof(link_t));
lqp->tail = lqp->head;
lqp->head->next = NULL;
lqp->head->data = -1;
return lqp;
}

//打印

void print(link_queue_t *lqp)
{
link_t *temp  = lqp->head;
while(NULL != temp)
{
printf(" %d ",temp->data);
temp  = temp->next;
}
printf("\n");
return;
}
//添加
int insert(link_queue_t *lqp, data_t *data)
{
link_t *newnode = malloc(sizeof(link_t));
if(NULL != data)
        newnode->data = *data;
       newnode->next = NULL;
        lqp->tail->next = newnode;
       lqp->tail = newnode;
      return 0;
}
//出队列
int output(link_queue_t *lqp,data_t *data)
{
      if(NULL == lqp->head->next)
        return -1;
     link_t *temp = lqp->head->next;
     lqp->head->next = temp->next;
     if(NULL != data)
         *data = temp->data;
     if(NULL == lqp->head->next)
         lqp->tail = lqp->head;
     free(temp);
     return 0;
}
int main()
{
link_queue_t *lqp = creat_queue();
int data  = 10,buf = 0;
for(data = 0; data < 10;data++)
 insert(lqp,&data);
print(lqp);
for(data = 0; data < 5; data++)
{
      output(lqp,&buf);
 printf(" %d ",buf);
} 
printf("\n");
print(lqp);

}

//链表实现栈

#include<stdio.h>
#include<stdlib.h>
typedef int data_t;
typedef struct linkstack{
    data_t data;
    struct linkstack *next;
}linkstack_t;

linkstack_t *creat_linkstack()
{
   linkstack_t *head;
   head = malloc(sizeof(linkstack_t));
   head->next = NULL;
   return head;
}

//入栈

int push_linkstack(linkstack_t *lsp,const data_t *data)
{
    linkstack_t *newnode;
    newnode = malloc(sizeof(linkstack_t));
if(NULL != data)
    newnode->data = *data;
    newnode->next = lsp->next;
    lsp->next = newnode;
    return 0;
}
//出栈
int pop_linkstack(linkstack_t *lsp,data_t *data)
{
if(NULL == lsp->next)
      return -1;
    linkstack_t *temp = lsp->next;
    if(NULL != data)
         *data  = temp->data;
    lsp->next = temp->next;
    free(temp);
    return 0;
}
//获取头数据
int get_top_stack(linkstack_t *lsp,data_t *databuf)
{
    if(NULL == lsp->next)
          return -1;
    if(NULL != databuf)
         *databuf = lsp->next->data;
    return 0;
}
//打印栈信息
void print_stack(linkstack_t *lsp)
{
    printf("top:\n");
while(NULL != lsp->next)
    {
        lsp = lsp->next;
        printf(" %d \n",lsp->data);
    }
    printf("end: \n");
}

int main(int argc, const char *argv[])
{
    linkstack_t *lsp;
    int i;
     data_t buf;
    lsp = creat_linkstack();
    for(i = 0;i < 8;i++){
      push_linkstack(lsp,&i);
    }
    print_stack(lsp);
    for(i = 0 ;i < 10;i ++){
       pop_linkstack(lsp,&buf);
       printf("pop :%d\n",buf);
    }
    print_stack(lsp);
    return 0;
}