[DS&A]栈

栈的实现方式有两种：一种以数组的形式作为存储方式，另一中则以链表形式。第一种较简单不做过多的模拟。

注意一个问题： 在一个加了const限定符的成员函数中，不能够调用 非const成员函数。

提示错误：.discards qualifiers 的意思就是缺少限定符，为了修改const在linklist.cpp中使用从const_cast<>去掉了const,我怀疑在所有const修饰的成员函数中都给对象添加了const修饰。

linklist.h(修改过)

#ifndef _LINKLIST
#define _LINKLIST
#include<string>
typedef int T;
class linklist
{
  struct Node
  {
	T data;
	Node *next;
	Node(T d = T()):data(d),next(0){};
  };
  
  int len;
  Node head;
  
public:
  linklist();
  
  ~linklist();
  
  void clear();
 
  Node *& getptr(int pos)const; //获取指向该位置pos的next指针
 
  linklist& Insert(T d,int pos); //任意位置插入
  
  linklist& put_back(T d);//插入链表尾部
 
  
  linklist& put_front(T d);//插入链表头部
 
  void travel()const ;//遍历链表
  
  linklist& remove_index(int pos);//按位置删除
 
  int find(T d); //查找d所在第一个位置
  
  linklist& remove_val(T d);//按值删除
  
  linklist& remove_xall(T d);
  
  linklist& set(T d,int pos); //修改指定位置节点的值
  
  bool empty()const; //判空
  
  linklist& reverse(); //翻转
  
  linklist& sort(); //冒泡排序
  
  linklist& merge(linklist& l); //合并
  
  T getend()const;
 
  int size();
  
  void save(std::string path);//保存到文件
  
  linklist& f2l(std::string path);//文件内容保存到链表

};

#endif

linklist.cpp

//带头结点的单链表类
#include<iostream>
#include"linklist.h"
#include<string>
#include<fstream>
using namespace std;

linklist::linklist():len(0),head(Node()){}
 
linklist:: ~linklist()
  {
	clear();
  }
  
void   linklist::clear()
  {
	Node *p = head.next;
	Node *temp;
	while(p)
	{
	  temp = p;
	  p = p->next;
	  delete temp;
	}
	len = 0;	
  }
  
linklist::Node *&  linklist::getptr(int pos)const //获取指向该位置pos的next指针
  {
	if(pos<0 ||pos> len+1) cout<< "指针越界！"<<endl;//pos = 1...len,len+1
	Node *p = const_cast<Node*>(&head);
	for(int i = 1; i < pos; i++)
	{
	  p = p->next;
	}
	return p->next;
  }
  
linklist&   linklist::Insert(T d,int pos) //任意位置插入
  {
	Node *& p = getptr(pos);
	Node *pn = new Node(d);
	pn->next = p;
	p = pn;
	++len;
	return (*this);
  }
  
linklist&  linklist:: put_back(T d)//插入链表尾部
  {
	Insert(d,len+1);
	return (*this);
  }
  
T linklist::getend()const
  {
	return getptr(len)->data;
  }
  
linklist& linklist::put_front(T d)//插入链表头部
  {
	Insert(d,1);
	
	return (*this);
  }
  
void linklist::travel()const //遍历链表
  {
	if(empty()) 
	{
	  cout << "链空" << endl;
	  return;
	}
	Node *p = head.next;
	while(p)
	{
	  cout << p->data << " ";
	  p = p->next;
	}
	cout << endl;
	return;
  }
  
linklist& linklist::remove_index(int pos)//按位置删除
  {
	Node *& p = getptr(pos);
	Node *temp = p;
	p= p->next;
	delete temp;
	--len;
	return (*this);
	
  }
  
int linklist:: find(T d) //查找d所在第一个位置
  {
	Node *p = head.next;
	int i = 1;
	while(p)
	{
	  if(p->data == d) return i;
	  ++i;
	  p = p->next;
	}
	return 0;
  }
  
linklist& linklist::remove_val(T d)//按值删除
  {
	int i = find(d);
	remove_index(i);
	return (*this);
  }
linklist& linklist::remove_xall(T d)
  {
	int i = find(d);
	while(i)
	{
	  remove_index(i);
	  i = find(d);
	}
	return (*this);
  }
  
linklist& linklist::set(T d,int pos) //修改指定位置节点的值
  {
	if(pos<1 || pos > len) cout<< "out of range!" << endl;
	getptr(pos)->data = d;
	return (*this);
  }
  
bool linklist::empty()const //判空
  {
	return len == 0;
  }
  
linklist& linklist::reverse() //翻转
  {
	if(len < 2) return (*this);
	Node *p1,*p2,*p3;
	p1 = head.next;
	p2 = p1->next;
	p3 = p2->next;
	p1->next = NULL;
	while(p3)
	{
	  p2->next = p1;
	  p1 = p2;
	  p2 = p3;
	  p3 = p3->next;
	}
	p2->next = p1;
	head.next = p2;
	return (*this);
	
  }
  
linklist& linklist::sort() //冒泡排序
  {
	
	bool flag = true;
	Node *p, *pn;
	T temp;
	while(flag)
	{
	  flag = false;
	  p = head.next;
	  pn = p->next;
	  while(pn)
	  {
		if(p->data > pn->data)
		{
		  temp = p->data;
		  p->data = pn->data;
		  pn->data = temp;
		  flag = true;
		}
		p = pn;
		pn = pn->next;
	  }
	}
	
	return (*this);
  }
  
linklist& linklist:: merge(linklist& l) //合并
  {
	cout << len << endl;
	getptr(len+1)=l.head.next;
	len += l.len;
	return (*this);
  }
int linklist::  size()
{
  return this->len;
}

void linklist::save(string path)
{
    ofstream fout;
	fout.open(path.c_str(),ios::trunc);
	if(empty()) return;
	Node *p = head.next;
	while(p)
	{
	  fout << p->data << " ";
	  p = p->next;
	}
	fout.close();
	return;
}

linklist& linklist::f2l(std::string path)
{
  ifstream fin(path.c_str(),ios::in);
  T d;
  fin >> d;
  while(fin)
  {
	put_back(d);
	fin >> d;
  }
  fin.clear();
  fin.close();
  return (*this);
}


 

stack_ll.cpp

#include<iostream>
#include"linklist.h"
using namespace std;
typedef int T;
class stack_ll
{
private:
  linklist l;
public:
  stack_ll& push(const T& d);//数据入栈成为栈顶
  T pop();//栈顶数据出栈，下一个数据成为栈顶
  T top();//取得栈顶数据
  bool empty()const{return l.empty();}//是否空栈
  bool full()const{return false;}//是否已满
  void clear(){l.clear();}//栈清空（复位)
  int size(){return l.size();}//栈中数据个数
};

stack_ll& stack_ll::push(const T& d)
{
  l.put_back(d);
  return (*this);
}

T stack_ll::pop()
{
  T d= l.getend();
  l.remove_index(l.size());
  return d;
}
T stack_ll::top()const
{
  return l.getend();
}

int main()
{
  stack_ll s;
  s.push(1).push(2).push(3);
  cout << s.pop() << endl;
  cout << s.top() << " s.empty = " << s.empty() << endl;
  s.clear() ;
  cout << s.empty() << endl;
  return 0;
}