算法： 第二章 线性表、栈和队列

一、线性表 LIST

1、LIST：ADT

#include<iostream>
using namespace std;

template<typename E>
class List
{
private:
	void operator =(const List&){} //重载运算符
	List(const List&){} //拷贝构造
public:
	List(){}
	virtual ~List(){}

	virtual void insert(E& item) = 0;
	virtual void append(E& item) = 0;
	virtual void remove() = 0;
	virtual void clear() = 0;

	virtual void movetostart() = 0;
	virtual void movetoend() = 0;
	virtual void prev() = 0;
	virtual void next() = 0;
	virtual void movetocurrpos(int pos) = 0;
	virtual int currpos()const = 0;

	virtual int length()const = 0;
	virtual const E& getvalue()const = 0;

};

2、LIST：顺序表 array-based list

//顺序表
template<typename E>
class AList :public List<E>
{
private:
	int maxsize;
	int listsize;
	int curr;
	E* arraylist;

public:

	AList(int size)
	{
		maxsize = size;
		listsize = curr = 0;
		arraylist = new E[maxsize];
	}

	void clear()
	{
		delete[]arraylist;          //删掉原来的链表
		listsize = curr = 0;
		arraylist = new E[maxsize]; //创建新的空链表
	}

	void insert(E& item)
	{
		if (listsize < maxsize)
		{
			for (int i = listsize; i > curr; i--)
			{
				arraylist[i] = arraylist[i - 1];
			}
			arraylist[curr] = item;
			listsize++;
		}
		else
			cout << "list capacity exceeded" << endl;
	}

	 void append(E& item)
	{
		if (listsize < maxsize)
		{
			arraylist[listsize] = item;
			listsize++;
		}
		else
			cout << "list capacity exceeded" << endl;
	}

	 void remove() 
	{
		if (curr >= 0 && curr < listsize)
		{
			for(int i=curr;i<listsize-1;i++)
			{
				arraylist[i] = arraylist[i + 1];
			}
		listsize--;
		}
	}
	
	 void movetostart() { curr = 0; }
	 void movetoend() { curr = listsize; }
	 void prev() { if (curr != 0) curr--; }
	 void next() { if (curr <= listsize - 1) curr++; }

	 void movetocurrpos(int pos) 
	{
		if ((pos >= 0) && (pos <= listsize))
			curr = pos;
		else
			cout<<"Pos out of range"<<endl;
		
	}
	 int currpos()const { return curr; }

	 int length()const { return listsize; }

	 const E& getvalue() const
	{
		if (curr >= 0 && curr < listsize)
			return arraylist[curr];
		else
			cout << "No current element" << endl;
	}


};

3、LIST：linked list

//链式表 sequential list

//先建立节点
template<typename E>
class Link
{
public:
	E element;
	Link* next;

	Link(const E& e, Link* n = NULL) // 构造函数
	{
		element = e;  next = n;
	}
	Link( Link* n = NULL) // 构造函数（不初始化元素的值）
	{
		 next = n;
	}
};

template<typename E>
class LList :public List<E>
{
private:
	Link<E>* head;  //头节点为虚
	Link<E>* tail;
	Link<E>* curr;  //curr指针指向目标元素的前一个元素，指向栅栏|左边的元素
	int size;       //链表长度

	void init()
	{
		head = tail = curr = new Link<E>;
		size = 0;
	}
	void removeall()
	{
		while (head != NULL)
		{
			curr = head;
			head = head->next;
			delete curr;
		}
	}

public:

	LList(int s) { init(); }
	~LList() { removeall(); }

	void clear() { removeall(); init(); }
	void insert(const E& item)
	{
		curr->next = new Link<E>(item, curr->next); 
		if (tail == curr->next) tail=curr;
		size++;
	}
	void append(const E& item)
	{
		tail=tail->next = new Link<E>(item, NULL);
		size++;
	}
	E remove()
	{
		if (curr->next != NULL)
		{
			E item = curr->next->element;
			Link<E>* p = curr->next;
			if (curr->next == tail)
				tail = curr;
			curr->next = curr->next->next;
			delete p;
			size--;
			return item;
		}
	}

	void movetostart() { curr = head; }
	void movetoend() { curr = tail; }
	void prev()
	{
		if (curr == head) return;
		Link<E>* p = head;
		while(p->next !=curr) p = p->next;
		curr = p;
	}
	void next() 
	{
		if (curr != tail)    curr = curr->next;
	}

	void movetocurrpos(int pos)
	{
		if ((pos >= 0) && (pos <= size))
		{
			curr = head;
				for (int i = 0; i < pos; i++)
					curr = curr->next;
		}
	}
	int currpos()const 
	{
		Link<E>* p=head;
		int i = 0;
		for( i=0;p!=curr;i++)
			p=p->next;
	    return i;
	}

	int length() const { return size; }
	const E& getvalue() const
	{
		if(curr!=tail)
			return curr->next->element;
	}


};

4、LSIT：双链表

二、栈 STACK

1、STACK：ADT

template <class Elem> class Stack
{
private:
	void operator = (const Stack&) {}
	Stack(const Stack&) {}
public:

	virtual void clear() = 0;
	virtual void push(const Elem&) = 0;. 
	virtual Elem pop() = 0;
	virtual const Elem& topValue() const = 0;
	virtual int length() const = 0;
	//在成员函数的声明后边添加const，函数内部无法修改成员变量
};

2、STACK：顺序栈

// Array-based stack implementation
template <class Elem> class AStack : public Stack<Elem>
{

private:
	int maxsize; // Maximum size of stack
	int top;//The position to insert the new element
	        //top是已有元素的后一位
	Elem* listArray; //Array holding stack elements

public:
	AStack(int n) :maxsize(n), top(0) { listArray = new Elem[n]; }
	~AStack(){ delete[] listArray; }

	void clear() { top = 0; } 
	void push(const Elem& t)
	{
		if (top == maxsize - 1)
			cout << "full" << endl;
		else
			listArray[top++] = t;
	}
	Elem pop() //返回删除的元素
	{
		if (top == 0)
			return;
		else
			return listArray[--top];
	}
	const Elem& topValue() const
	{
		if (top == 0)
			return;
		else
			return listArray[top-1];
	}
	int length() const
	{
		return top;
	}
};

3、STACK：链式栈

template <class Elem>
class Link
{
public:
	Elem data;
	Link<Elem>* next;
	Link(Elem a, Link<Elem>* n):data(a),next(n){}
};
template <class Elem> class LStack : public Stack<Elem>
{
private:
	Link<Elem>* top; // Pointer to first elem
	                 //与顺序栈相反，top为第一个元素
	int size;        // Count number of elems

public:
	LStack() { top = nullptr; size = 0; }//空栈
	~LStack() { clear(); }
	void clear()
	{
		while (top != NULL) {
			Link<Elem>* temp = top;
			top = top->next;
			delete temp;
		}
		size = 0;
	}
	void push(const Elem& t)
	{
		top = new Link<Elem>(t, top);
		size++;

	}
	Elem pop() {
		if (!top)
			return;
		else
		{
			Elem it = top->element;
			Link<Elem>* ltemp = top->next;
			delete top;
			top = ltemp;
			size--;
			return it;
		}
	}
	const Elem& topValue() const {
		if (!top)
			return;
		else
			return top->element;
	}
	int length() const { return size; }


};

三、队列 QUEUE

1、QUEUE：ADT

template <class Elem> class Queue {
private:
   void operator = (const Queue&) { }     
   Queue(const Queue&) { }
public:
   Queue() { }
   virtual ~Queue() { }
   virtual void clear() = 0;
   virtual void enqueue(const Elem&) = 0;
   virtual Elem dequeue( ) = 0; 
   virtual const Elem& frontValue() const = 0;
   virtual int length() const = 0;
};

2、QUEUE：数组实现 ( 循环队列 )

//第i个元素 (i+1)% size
//Length = ((rear+size) - front + 1) % size
//Empty：  front  = =  (rear+1)%size   
//Full：      front  = =  (rear+2)%size



template <class Elem> class AQueue: public Queue<Elem>
 {
private:
  	int maxsize;         // Maximum size of queue
//Only store n – 1 elements in a Circular queue with the length n.

 	int front;          // Index of front element
  	int rear;           // Index of rear element
  	Elem *listArray;     // Array holding queue elements
public:
    AQueue(int size=defaultSize) {
       maxSize = size+1;
       rear=0;  front=1;
       listArray = new Elem[maxSize];
}
~AQueue () {delete [] listArray;
void clear() { rear=0; front=1; } 
void enqueue(const Elem& it) {
   Assert((rear+2) % size) != front, “Queue if full”); 
    rear = (rear+1) % size; // Circular increment
    listArray[rear] = it;
}
Elem dequeue(Elem& it) {                                                                                                          
    Assert (length() != 0, “Queue is empty);  
    it = listArray[front];
    front = (front+1) % maxsize; // Circular increment
    return it;
  }
const Elem& frontValue(Elem& it) const {
    Assert (length() != 0,”Queue if empty”);     
    return listArray[front];
 }
 virtual int length() const
   { return ((rear+size) - front + 1) % maxsize; }
};