链表:
#ifndef LINKEDLIST_H_
#define LINKEDLIST_H_
#include <stdexcept>
using namespace std;
template<typename T>
class Node {
public:
T element;
Node<T> *next;
Node() {
next = NULL;
}
Node(T element) {
this->element = element;
next = NULL;
}
};
//----------------- Iterator -----------------
template<typename T>
class Iterator {
public:
Iterator(Node<T> *p) {
current = p;
}
Iterator &operator++() {
current = current->next;
return *this;
}
Iterator &operator++(int) {
return ++(*this);
}
T operator*() {
return current->element;
}
bool operator==(const Iterator<T> &iterator) {
return current == iterator.current;
}
bool operator!=(const Iterator<T> &iterator) {
return current != iterator.current;
}
private:
Node<T> *current;
};
//----------------- Iterator -----------------
template<typename T>
class LinkedList {
public:
LinkedList();
void addFirst(T element);
void addLast(T element);
T getFirst();
T getLast();
T get(int index);
T removeFirst() throw (runtime_error);
T removeLast() throw (runtime_error);
void add(T element);
void add(int index, T element);
void remove(T element);
T removeAt(int index) throw (runtime_error);
void clear();
int getSize();
bool isEmpty();
//----------------- Iterator -----------------
Iterator<T> begin();
Iterator<T> end();
//----------------- Iterator -----------------
private:
Node<T> *head, *tail;
int size;
};
template<typename T>
LinkedList<T>::LinkedList() {
size = 0;
head = tail = NULL;
}
template<typename T>
void LinkedList<T>::addFirst(T element) {
Node<T> *newNode = new Node<T> (element);
newNode->next = head;
head = newNode;
size++;
if (tail == NULL)
tail = head;
}
template<typename T>
void LinkedList<T>::addLast(T element) {
if (tail == NULL)
tail = head = new Node<T> (element);
else {
tail->next = new Node<T> (element);
tail = tail->next;
}
size++;
}
template<typename T>
T LinkedList<T>::getFirst() {
if (size == 0)
throw runtime_error("Index out of range.");
return head->element;
}
template<typename T>
T LinkedList<T>::getLast() {
if (size == 0)
throw runtime_error("Index out of range.");
return tail->element;
}
template<typename T>
T LinkedList<T>::get(int index) {
if (index < 0 || index > (size - 1))
throw runtime_error("Index out of range.");
else if (index == 0)
return getFirst();
else if (index == (size - 1))
return getLast();
else {
Node<T> *current = head;
for (int i = 0; i < index; i++)
current = current->next;
return current->element;
}
}
template<typename T>
T LinkedList<T>::removeFirst() throw (runtime_error) {
if (size == 0)
throw runtime_error("No elements in the list.");
Node<T> *temp = head;
head = head->next;
if (head == NULL)
tail = NULL;
size--;
T element = temp->element;
delete temp;
return element;
}
template<typename T>
T LinkedList<T>::removeLast() throw (runtime_error) {
if (size == 0)
throw runtime_error("No elements in the list.");
else if (size == 1) {
Node<T> *temp = head;
head = tail = NULL;
size = 0;
T element = temp->element;
delete temp;
return element;
} else {
Node<T> *current = head;
for (int i = 0; i < size - 2; i++)
current = current->next;
Node<T> *temp = tail;
tail = current;
tail->next = NULL;
size--;
T element = temp->element;
delete temp;
return element;
}
}
template<typename T>
void LinkedList<T>::add(T element) {
addLast(element);
}
template<typename T>
void LinkedList<T>::add(int index, T element) {
if (index == 0)
addFirst(element);
else if (index >= size)
addLast(element);
else {
Node<T> *current = head;
for (int i = 1; i < index; i++)
current = current->next;
Node<T> *temp = current->next;
current->next = new Node<T> (element);
(current->next)->next = temp;
size++;
}
}
template<typename T>
void LinkedList<T>::remove(T element) {
}
template<typename T>
T LinkedList<T>::removeAt(int index) throw (runtime_error) {
if (index < 0 || index > (size - 1))
throw runtime_error("Index out of range.");
else if (index == 0)
return removeFirst();
else if (index == (size - 1))
return removeLast();
else {
Node<T> *previous = head;
for (int i = 1; i < index; i++)
previous = previous->next;
Node<T> *current = previous->next;
previous->next = current->next;
size--;
T element = current->element;
delete current;
return element;
}
}
template<typename T>
void LinkedList<T>::clear() {
while (head != NULL) {
Node<T> *temp = head;
delete temp;
head = head->next;
}
tail = NULL;
}
template<typename T>
int LinkedList<T>::getSize() {
return size;
}
template<typename T>
bool LinkedList<T>::isEmpty() {
return head == NULL;
}
//----------------- Iterator -----------------
template<typename T>
Iterator<T> LinkedList<T>::begin() {
return Iterator<T> (head);
}
template<typename T>
Iterator<T> LinkedList<T>::end() {
return Iterator<T> (tail->next);
}
//----------------- Iterator -----------------
#endif /* LINKEDLIST_H_ */
栈:
#ifndef STACKWITHLINKEDLIST_H_
#define STACKWITHLINKEDLIST_H_
#include "LinkedList.h"
template<typename T = int>
class Stack {
public:
Stack();
bool isEmpty();
T peek();
void push(T value);
T pop();
int getSize();
private:
LinkedList<T> list;
};
template<typename T>
Stack<T>::Stack() {
}
template<typename T>
bool Stack<T>::isEmpty() {
return list.isEmpty();
}
template<typename T>
T Stack<T>::peek() {
return list.getLast();
}
template<typename T>
void Stack<T>::push(T value) {
list.addLast(value);
}
template<typename T>
T Stack<T>::pop() {
return list.removeLast();
}
template<typename T>
int Stack<T>::getSize() {
return list.getSize();
}
#endif /* STACKWITHLINKEDLIST_H_ */
队列:
#ifndef QUEUE_H_
#define QUEUE_H_
#include "LinkedList.h"
using namespace std;
template<typename T>
class Queue {
public:
Queue();
void enqueue(T element);
T dequeue() throw (runtime_error);
int getSize();
private:
LinkedList<T> list;
};
template<typename T>
Queue<T>::Queue() {
}
template<typename T>
void Queue<T>::enqueue(T element) {
list.addLast(element);
}
template<typename T>
T Queue<T>::dequeue() throw (runtime_error) {
return list.removeFirst();
}
template<typename T>
int Queue<T>::getSize() {
return list.getSize();
}
#endif /* QUEUE_H_ */