【两周编程学习】--栈与队列

一、栈的学习

先看一下栈的存储结构：栈是先进后出的存储结构

在递归过程中用到了栈，递归定义必须至少有一个条件， 满足时递归不再进行， 即不再引用自身而是返回值退出。

 

 

#include<stack> 

stack<int> s;

栈的基本用法有：push():向栈内压入一个元素；

pop():从栈顶弹出一个元素；

empty():如果栈为空，则返回true，否则返回false；

top(): 返回栈顶元素，但不删除元素；

size():返回栈内元素的个数；

 

用数组实现一个顺序栈：

#include<iostream>
using namespace std;
#define MAXSIZE 10

typedef struct
{
	int d[MAXSIZE];
	int top;
}Stack;
void initStack(Stack *s);
bool isEmpty(Stack *s);
bool isFull(Stack*s);
void push(Stack* s,int a);
void pop(Stack* s,int *a);
int top(Stack*s,int *a);
int len(Stack*s);

void initStack(Stack* s)
{
	s->top=-1;
}

bool isEmpty(Stack* s)
{
	if(-1==s->top)
		return true;
	else
		return false;
}

bool isFull(Stack* s)
{
	if(9==s->top)
		return true;
	else
		return false;
}

void push(Stack* s,int a)
{
	if(isFull(s))
		return;
	else{
		s->top++;
		s->d[s->top]=a;
	}
}

void pop(Stack*s,int *a)
{
	if(isEmpty(s))
		return ;
	else{
		*a=s->d[s->top];
		s->top--;
	}
}

int top(Stack*s,int a)
{
	if(isEmpty(s))
		return 0;
	else{
		a=s->d[s->top];
		return a;
	}
}

int len(Stack*s)
{
	return s->top+1;
}

用链表实现一个链式栈：

template<class T>class Stack
{
private:
	struct Node{
		T data;
		Node* next;
	}*stack_t;
	
	Node* head;
	Node* p;
	int len；
public:
	Stack()
	{
		head=NULL;
		len=0;
	}
	void push(stack_t *s,T n)
	{
		stack_t *q=new stack_t;
		if(!q)
			return ;
		q->data=n;
		q->next=s;
		s=q;
	}
	
	bool isEmpty(stack_t *s)
	{
		return(!s);
	}
	
	T pop(stack_t* s)
	{
		if(isEmpty(s))
			return;
		stack_t * temp=s;
		T data=s->data;
		s=s->next;
		if(temp)
			delete temp;
		return data;
	}
	int size(stack_t * s)
	{
		return len;
	}
}

 二、队列的学习：（队列不是很懂）

在尾部加入元素时队列加长，在前端删除数据时队列缩短。与栈不同，队列是一种两端的结构：一端用来加入新元素，另一端用来删除元素。因此，元素必须等到排在它之前的所有元素删除之后才能操作。队列是FIFO（first in first out)结构。

队列用数组实现：

#ifndef _ARRAY_QUEUE_H
#define _ARRAY_QUEUE_H
 
#include <iostream>
using namespace std;
 
template<typename T, int size = 0>
class Queue{
public:
	Queue();
 
	bool is_empty()const;
	bool is_full()const;
 
	void enqueue(const T&);
	T dequeue();
 
	void traverse()const;
private:
	T storge[size];
	int first;
	int last;
};
 
template<typename T, int size>
Queue<T, size>::Queue()
{
	first = last = -1;
}
 
template<typename T, int size>
bool Queue<T, size>::is_empty()const
{
	return first == -1;
}
 
template<typename T, int size>
bool Queue<T, size>::is_full()const
{
	return first == 0 && last == size - 1 || last == first - 1;
}
 
template<typename T, int size>
void Queue<T, size>::enqueue(const T& elem)
{
	if(!is_full()){
		if(last == -1 || last == size -1){
			storge[0] = elem;
			last = 0;
			if(first == -1)
				first = 0;
		}
		else storge[++last] = elem;
	}
	else{
		cout << "Queue full." << endl;
		exit(EXIT_FAILURE);
	}
}
 
template<typename T, int size>
T Queue<T, size>::dequeue()
{
	if(is_empty()){
		cout << "Queue empty." << endl;
		exit(EXIT_FAILURE);
	}
 
	T tmp;
 
	tmp = storge[first];
	if(first == last)
		last = first = -1;
	else if(first == size - 1)
		first = 0;
	else ++first;
 
	return tmp;
}
 
template<typename T, int size>
void Queue<T, size>::traverse()const
{
	for(auto i=first; i<=last; ++i)
		cout << storge[i] << " ";
	cout << endl;
}
 
#endif

队列用链表实现：

#ifndef _LIST_QUEUE_H
#define _LIST_QUEUE_H
 
#include <list>
#include <iostream>
using namespace::std;
 
template<class T>
class Queue{
public:
	Queue() = default;
 
	bool is_empty()const;
	T& front();
	
	T dequeue();
	void enqueue(const T&);
	
	size_t size()const;
	void clear();
private:
	list<T> lst;
};
 
template<class T>
bool Queue<T>::is_empty()const
{
	return lst.is_empty();
}
 
template<typename T>
T& Queue<T>::front()
{
	return lst.front();
}
 
template<typename T>
T Queue<T>::dequeue()
{
	if(!lst.size()){
		cout << "Queue empty." << endl;
		exit(EXIT_FAILURE);
	}
 
	T tmp = lst.front();
	lst.pop_front();
	
	return tmp;
}
 
template<typename T>
void Queue<T>::enqueue(const T& elem)
{
	lst.push_back(elem);
}
 
template<typename T>
void Queue<T>::clear()
{
	lst.clear();
}
 
template<typename T>
size_t Queue<T>::size()const
{
	return lst.size();
}
 
#endif

 

 

三、递归

斐波那契数列：

递推法

int Fibonacci(int n)
{
	if(n<0)
		return 0;
	if(n==0)
		return 0;
	else if(n==1)
		return 1;
	int s=0;
	int f1=0;
	int f2=1;
	while(n>=2){
		s=f1+f2;
		f1=f2;
		f2=s;
		n--;
	}
	return s;
}

leetcode爬楼梯问题及变态爬楼梯楼梯：

https://blog.csdn.net/wxq_1993/article/details/86660460