数据结构的学习（四）---栈和队列

#ifndef _STACK_H_
#define _STACK_H_ 

//要处理的 数据类型
typedef int data_t;


//栈标签 ---代表一个栈 
typedef struct seqstack
{
	data_t *stack; //开辟栈空间 
	int top;  //top 栈顶 -栈针 
	int max;  //栈空间容量的上限 
}seqstack_t;

//创建 
seqstack_t * create_stack(int len);
//入栈 
int push(seqstack_t *pstack,data_t d);
//出栈 
int pop(seqstack_t *pstack,data_t *d);
//获取栈顶元素:
data_t get_top_element(seqstack_t *pstack);
//6.栈的大小 //此时栈中有效数据的个数
int get_stack_size(seqstack_t *pstack);
//销毁
int seqstack_destroy(seqstack_t **ppstack);
#endif

2.链式栈：

用链表来实现

结构体：

复制代码

#ifndef _LINKSTAK_H_ 
#define _LINKSTAK_H_ 

typedef int data_t;

typedef struct stack
{
	data_t data;
	struct stack *next;
}snode_t;

//1.创建链表 
snode_t *create_linkstack(void);
int pop(snode_t *pstack,data_t *data);
int push(snode_t *pstack,data_t data);
data_t get_top_element(snode_t *pstack);
int get_stack_size(snode_t *pstack);
int linkstack_destroy(snode_t ** ppstack);
#endif

相关算法：

1.创建栈

2.入栈出栈

3.获取栈顶元素

4.获取栈的容量---链式不考虑容量

4.获取栈的大小（此时栈中有效数据的个数）

复制代码

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


 
//创建空栈 
snode_t *create_linkstack(void)
{
	snode_t *head = malloc(sizeof(snode_t));
	if (head == NULL)
	{
		printf("malloc fail");
		return NULL;
	}
	head->next = NULL; // 

	return head;
}
//2.头插 
int push(snode_t *pstack,data_t data)
{
	if (pstack == NULL)
	{
		return -1;
	}

	//1.创建新节点 
	snode_t *p_new = malloc(sizeof(snode_t));
	if (p_new == NULL)
	{
		printf("%s: malloc fail\n",__func__);
		return -1;
	}
	p_new->data = data;
	//2.链接链表  
    p_new->next = pstack->next;
    pstack->next = p_new;

	return 0;
}


int is_empty(snode_t *pstack)
{
	if (pstack == NULL)
		return -1;

	return pstack->next == NULL;
}

int pop(snode_t *pstack,data_t *data)
{
	if (pstack == NULL)
	{
		return -1;
	}
	//判断链表是否为空
	if (is_empty(pstack) == 1)
	{
		printf("%s:linkstack empty!\n",__func__);
		return -1;
	}
	//  step1.有一个指针变量 指向首节点 phead->pnext
	snode_t *p = pstack->next;
	//  step2.让头节点指向p->pnext 
	pstack->next = p->next;
	//  step3.释放 p所在的节点 
	//        free(p);
	
	*data = p->data;
	
	free(p);

	return 0;
}

data_t get_top_element(snode_t *pstack)
{

	if (pstack == NULL)
	{
		return -1;
	}
	//判断链表是否为空
	if (is_empty(pstack) == 1)
	{
		printf("%s:linkstack empty!\n",__func__);
		return -1;
	}

	return pstack->next->data;

}

int get_stack_size(snode_t *pstack)
{
	if (pstack == NULL)
	{
		return -1;
	}
	//判断链表是否为空
	if (is_empty(pstack) == 1)
	{
		return 0;
	}

	snode_t *p = pstack->next;
    int cnt = 0;
	while (p!=NULL)
	{
		cnt++;
		p = p->next;
	}

	return cnt;
}

int linkstack_destroy(snode_t ** ppstack)
{
	if (ppstack == NULL || *ppstack == NULL)
	{
		return  -1;
	}
	snode_t *p = (*ppstack)->next; 
	while (p!=NULL)
	{
		snode_t *ptemp = p;
		p = p->next;
		free(ptemp);
	}
	free(*ppstack);
	*ppstack=NULL; //防止悬空指针 
	return 0;
}

二、队列

队列也是一种受到限制的线性数据结构

队头出数据

队尾入数据

操作数据的顺序：FIFO（first in first out）

1.顺序队列：

用数组来实现

结构体：

复制代码

#ifndef _QUEUE_H_
#define _QUEUE_H_

typedef int data_t;

typedef struct queue
{
	data_t *que;
	int head;
	int tail;
	int tlen;
}queue_t;

//创建 
queue_t * create_queue(int len);
//入队
int enqueue(queue_t *pque, data_t data);
//出队
int dequeue(queue_t *pque, data_t *data);
//销毁
int queue_destroy(queue_t **ppque);

#endif

2.链式队列：

用链表来实现

结构体：

复制代码

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

//数据类型 
typedef int data_t;

//节点类型 
typedef struct queue
{
	data_t data;
	struct queue *next;
}qnode_t; 
//1.创建队列  
qnode_t *create_queue(void);
//5.入队 -- 尾插
int enqueue(qnode_t *pque,data_t dt);
//出队--头删
data_t dequeue(qnode_t *pque);
int queue_destroy(qnode_t ** ppque);
#endif

三、总结

只要单向链表和结构体搞明白，理解这些就简单一些