数据结构学习笔记-链表，链栈，链式队列

这是最近学习过的数据结构的一些基本线性存储方式，
整理一下笔记，其中双链表和循环list等操作，思想类似，就不做整理了

//链表操作
#include<iostream>
using namespace std;
template <class T>
struct Node                                     //节点设置
{
	T data;                                         //节点存储的元素
	struct Node<T>* next;                //节点存储的指针
};
template <class T>
class linklist
{
private:
	struct Node<T>* front;
public:
	linklist()
	{
		front = new Node<T>;
		front->next = NULL;
	
	}
	linklist(T a[], int n)    //有参构造
	{
		//头插法
		front = new Node<T>;
		front->next = NULL;
		for (int i = n - 1; i >= 0; i--)
		{
			Node<T>* s = new Node<T>;      //建立新节点
			s->data=a[i];                                 //将数据存入s的数据域中
			s->next = front->next;                 //修改新节点的指针域
			 front->next=s;                             //修改头节点的指针域
		}
		//尾插法
		/*
		front = new Node<T>;
		Node<T> *r=front;
		for (int i =0; i <n; i++)
		{
			Node<T>* s = new Node<T>;      建立新节点
			s->data=a[i];                新节点的数据域
			r->next = s;                 讲新节点尾插至链表中
			 r=s;                          修改尾指针
		}
		r->next=NULL;             尾指针置空
		*/
	}
	~linklist() //析构
	{
		Node<T>* p = front;
		while (p != NULL)
		{
			front = p;           //暂存要释放的p节点
			p = p->next;      //后移指针
			delete front;      //释放
		}
	}
	Node<T>* get(int i) //获取第i个位置上元素节点的地址
	{
		Node<T>* p = front;
		int j = 1;                  //计数器
		while ((p != NULL) && (j != i))
		{
			p = p->next;         // 后移指针
			j++;
		}
		return p;
	}
	int locate(T x)
	{
		Node<T>* p = front;
		int j = 1;                  //计数器
		while (p != NULL)
		{
			if (p->data == x)
				return  j;

			p = p->next;
			j++;

		}
		return -1;
	}
	void insert(int i, T x)     //在第i个位置插入值为x新元素
	{
		Node<T>* p = front;
		if (i != 1)
			p = get(i - 1);        //获取要插入元素前面的位置
		if (p != NULL)
		{
			Node<T>* s = new Node<T>;      //建立新节点
			s->data = x;                                 //将数据存入s的数据域中
			s->next = p->next;                      //修改新节点的指针域
			p->next = s;                                //修改p节点的指针域
		}
		else
			throw "wrong location";
		
	}
	T Delete(int i)
	{
		Node<T>* p = front;
		if (i != 1)
			p = get(i - 1);
		Node<T>* q = p->next;
		T x = q->data;
		p->next = q->next;
		delete q;
		return x;
	}
};

//链式栈
template <class T>                               //c++小小模板整上
struct Node                                      //节点设置
{
	T data;                                      //节点存储的元素
	struct Node<T>* next;                        //节点存储的指针
};
template <class T>
class linkstack {                              //整一个链式stack类
private:
      struct Node<T>*top;                      //栈顶指针
	
public:
	linkstack()                                   //构造函数，先整个空表
	{
		top = NULL;
	}                           
	~linkstack()                                //析构
	{
		while (top != NULL)
		{
		//法一	T pop();
		//法二
			struct Node<T>* p = top;
			top = top->next;
			delete p;
		}
	
	}
	void push(T x)                             //入栈操作
	{
		struct Node<T>* p = new Node<T>;       //new个空间放p
		p->data = x;                           //把数据放入p中
		p->next = top;                         //把p变成栈顶
		top = p;
	}
	T pop()                          //出栈
	{
		if (top == NULL) throw "wrong";          //及时抛出异常
		T x = top->data;                               
		struct Node<T>* p = top;
		top = top->next;                           //top指针下移
		delete p;                                  //销毁p指针
		return x;                                  //返回出栈元素
	}
	T getpop()                                     //获取栈顶元素
	{
		return top->data;
	}
		bool empty()                               //判断是否为空表
	{ 
			return (NULL == top) ? true : false;
	}
	};

//链式队列
template <class T>
struct Node                               //节点设置
{
	T data;                              //节点存储的元素
	struct Node<T>* next;                //节点存储的指针
};
template <class T>
class linkqueue                        //创建队列
{
private:                               //创建队头和队尾
	Node<T>* front;                    //对头指针
	Node<T>* rear;                     //队尾指针
public:  
	linkqueue()                          //构造函数
	{
		front = rear = new Node<T>;      //new个空间
		front->NULL;
	}
	void inqueue()   //入队
	{
		Node<T>* p = new Node<T>;
		p->data = x;
		p->next == NULL;
		rear->next = p;
		rear = p;
	} 
	T dequeue()     //出队
	{
		if(p!=NULL) throw "wrong operation"   //防止异常
		Node<T>* p = front->next;             
		T x = front->data;
		front->next = p->next;
		delete p;
		if (front->next = rear)
		{
			rear = front;
		}
	}


};