数据结构(二) 栈、队列、递归

栈

1.用数组实现一个顺序栈

//用数组实现一个顺序栈
#define maxsize 64  //栈的最大容量 
typedef struct
{
	datatype data[maxsize];  //栈的存储空间 
	int top;  //栈顶指针 
}sqstack, *sqslink;  //顺序栈说明符

//置栈空
void Clearstack(sqslink s)
{
	s->top = -1;  //用指针值为-1表示栈空 
} 
//判栈空
int Emptystack(sqslink s)
{
	if(s->top < 0) return (1);  //栈空返回1 
	else return (0);  //栈非空返回0 
} 
//元素x进栈
int Push(sqslink s, datatype x)
{
	if(s->top >= maxsize-1) return(0);  //栈满溢出 
	else{
		s-top++;   //移动栈顶指示器
		s->data[s->top] = x;  //x进栈 
		return (1);
	}
}
//出栈
datatype Pop(sqslink s)
{
	if(Emptystack(s)) return (NULL);  //栈空返回NULL 
	else
	{
		s->top--;
		return (s->data[s->top+1]);  //弹出栈顶元素 
	}
} 
//取栈顶元素
datatype Getstop(sqslink s)
{
	if(Emptystack(s)) return (NULL);  //栈空返回NULL 
	else return(s->data[s->top])  //返回栈顶元素 
}

2.用链表实现一个链式栈

//用链表实现一个链式栈

typedef struct node
{
	datatype data;  //存储一个栈元素 
	struct node *next;  //后继指针 
}snode, *slink;
//置栈空
Lclearstack(slink top)
{
	top = NULL;
}
//判栈空否
int Lemptysatck(slink top)
{
	if(top == NULL) return(1);
	else return (0);
}
//进栈
Lpush(slink top, datatype e)
{
	slink p;
	p = (slink)malloc(sizeof(snode));  //生成进栈的p节点 
	p->data = e;  //存入元素e 
	p->next = top;  //p节点作为新的栈顶节点 
	top = p;
} 
 
//出栈
datatype Lpop(slink top)
{
	datatype e;
	slink p;
	if(Lemptystack(top)) return(NULL);  //栈空返回 
	else
	{
		e = top->data;  //取栈顶元素
		p = top; top = top->next;   //重置栈顶元素
		free(p); return (e); 
	}
 } 

3.编程模拟实现一个浏览器的前进、后退功能

队列

1.用数组实现一个顺序队列

//用数组实现一个顺序队列
typedef struct
{
	datatype data[maxsize];  //队列的存储空间 
	int front, rear;  //队头，队尾指针 
}squeue, *squlink;

2.用链表实现一个链式队列

//用链表实现一个链式队列
typedef struct node  //节点类型 
{
	datatype data;
	struct node *next;
}Qnode, *Qlink;

typedef struct  //q节点结构 
{
	Qnode *front, *rear;
}linkqueue;
//创建队列 
void Lcreatqueue(linkqueue *q)
{
	q->front = (Qlink)malloc(sizeof(Qnode));  //申请头节点 
	q->front->next = NULL;  //置队空 
	q->rear = q->front;
 }
//判队空 
int Lemptyqueue(linkqueue *q)
{
	if(q->front == q->rear) return(1);
}
//元素e进队的算法
void Lenqueue(linkqueue *q, datatype e)
{
	Qlink p;
	p = (Qlink)malloc(sizeof(Qnode));  //申请进队节点 
	p->data = e;  //存入元素e 
	p->next = NULL;
	q->rear->next = p; q->rear = p;
 } 
//出队
datatype Ldequeue(linkqueue *q)
{
	Qlink p;
	if(Lemptyqueue(q)) return(NULL);  //队空处理 
	else
	{
		p = q->front;
		q->front = p->next;  //将队头元素提前至节点 
		free(p);
		return (q->front->data);  //返回被提前至头节点的原队头元素值 
	}
 } 

3.实现一个循环队列

//实现一个循环队列

//置队空 
void ClearQueue(squlink Q)
{
	Q->front = Q->rear = 0;
}
//判队空
int EmptyQueue(sqlink Q)
{
	if(Q->front == Q->rear) return(1);  //队空返回1 
	else return (0);  //队非空返回0 
}
//元素e进队
int EnQueue(squlink Q, datatype e)
{
	if((Q->rear + 1)%maxsize == Q->front)
	{
		ERROR(Q);
		return (0);
	}
	else
	{
		Q->rear = (Q->rear + 1)%maxsize;
		Q->data[Q->rear] = e;
		return (1); 
	}
}
//出队
datatype DeQueue(squlink Q)
{
	if(EmptyQueue(Q)) return(NULL);
	else
	{
		Q->front = (Q->font + 1)%maxsize;
		return (Q->data[Q->front]);
	}
}
//求队Q中当前元素个数
int Lenqueue(squlink Q)
{
	int i;
	i = (Q->rear - Q->front + maxsize)%maxsize;
	return(i);
 }

递归

1.编程实现斐波那契数列求值 f(n)=f(n-1)+f(n-2)

//编程实现斐波那契数列求值 f(n)=f(n-1)+f(n-2)
void Fibonacci(int Fib[n])
{
	int i;
	for(int i = 0; i < n; i++)
		Fib[i] = Fib-i(i);
}
int Fib-i(int i)
{
	if(i == 0) return(0);
	else if(i == 1) return(1);
	else return(Fib-i(i - 1) + Fib-i(i - 2));
}

2.编程实现求阶乘 n!

//编程实现求阶乘 n!
int Fact(int n)
{
	if(n==0) return(1);
	else return(n*Fact(n - 1));
}

3.编程实现一组数据集合的全排列