deque、list、链表性能比较（用于头部插入，尾部出来的情形）

#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <stdexcept>
#include <iostream>
using namespace std;

class Node {
public:
	int element;
	Node *next;
	Node *previous;
	Node(int element, Node *next, Node *previous) {
		this->element = element;
		this->next = next;
		this->previous = previous;
	}
};
class LinkedList {
public:
	LinkedList();
	void addFirst(int);
	void addLast(int);
	void add(int index, int element);
	int getFirst();
	int getLast();
	int get(int);
	int removeFirst();
	int removeLast();
	int remove(int);
	void iterate();
private:
	Node *header;
	int size;
};

#include "singLink.h"

/*
* 构造方法。
* 生成一个空的节点介于表头和表尾之间，初始前后指针都指向自己。
*/
LinkedList::LinkedList() {
	header = new Node(NULL, NULL, NULL);
	header->next = header;
	header->previous = header;
	size = 0;
}
/*
* 在链表头部添加一个元素。
* 生成一个新的节点，向前指向空节点，向后指向原来空节点的下一个节点，即原来的第一个节点。
* 空节点向后指向此节点，原来的第一个节点向前指向此节点。
*/
void LinkedList::addFirst(int i) {
	header->next = new Node(i, header->next, header);
	header->next->next->previous = header->next;
	++size;
}
/*
* 在链表最后添加一个元素。
* 生成一个新的节点，向前指向原来空节点的前一个节点，即原来的最后一个节点，向后指向空节点。
* 原来的最后一个节点向后指向此节点，空节点向前指向此节点。
*/
void LinkedList::addLast(int i) {
	header->previous = new Node(i, header, header->previous);
	header->previous->previous->next = header->previous;
	++size;
}
/*
* 在指定的索引前插入一个元素。0 <= 索引 <= 链表长度。
* 如果索引值小于链表长度的一半，向后（正向）迭代获取索引值位置的节点，反之则向前（反向）。
* 生成一个新的节点，向前指向原来这个位置的节点的前一个节点，向后指向原来这个位置的节点。
* 原来这个位置的节点的前一个节点向后指向此节点，原来这个位置的节点向前指向此节点。
* （在指定的索引删除一个元素实现方法类似）
*/
void LinkedList::add(int index, int i) {
	if(index > size || index < 0) {
		cout << "Exception in add(): Index out of bound." << '\n';
		return;
	}
	Node *entry;
	if(index < size / 2) {
		entry = header->next;
		for(int i = 0; i < index; ++i)
			entry = entry->next;
	}
	else {
		entry = header;
		for(int i = size; i > index; --i)
			entry = entry->previous;
	}
	entry->previous->next = new Node(i, entry, entry->previous);
	entry->previous = entry->previous->next;
	++size;
}
/*
* 获取链表第一个元素。
* 空节点向后指向的节点即是第一个元素。
*/
int LinkedList::getFirst() {
	if(!size)
		cout << "Exception in getFirst(): List is empty." << '\n';
	return header->next->element;
}
/*
* 获取链表最后一个元素。
* 空节点向前指向的节点即是最后一个元素。
*/
int LinkedList::getLast() {
	if(!size)
		cout << "Exception in getLast(): List is empty." << '\n';
	return header->previous->element;
}
/*
* 删除并返回链表第一个元素。
* 链表第二个节点向前指向空节点，空节点向后指向第二个节点。
*/
int LinkedList::removeFirst() {
	int remove = header->next->element;
	header->next->next->previous = header;
	header->next = header->next->next;
	--size;
	return remove;
}
/*
* 删除并返回链表最后一个元素。
* 链表倒数第二个节点向后指向空节点，空节点向前指向倒数第二个节点。
*/
int LinkedList::removeLast() {
	int remove = header->previous->element;
	header->previous->previous->next = header;
	header->previous = header->previous->previous;
	--size;
	return remove;
}
/*
* 用来输出所有元素的迭代方法。
*/
void LinkedList::iterate() {
	if(!size) {
		cout << "Exception in iterate(): List is empty." << '\n';
		return;
	}
	for(Node *entry = header->next; entry != header; entry = entry->next)
		cout << entry->element << " ";
	cout << '\n';
}

#include <iostream>
#include <time.h>
#include <list>
#include <deque>
using namespace::std;

#include "singLink.h"

struct fuck
{
	int a,b,c;
};

 

 

int main()
{
	int len = 10000000;
	list<fuck> l(len);
	deque<fuck> d;
	LinkedList link;

	LARGE_INTEGER litmp;

	::QueryPerformanceCounter(&litmp);
	LONGLONG sllStartTime = litmp.QuadPart; // 获得初始值

	for (int i=0; i < len; i++)
	{
		static fuck data;
		
		data.a = i;
		data.b = i;
		data.c = i;
		d.push_front(data);
	}
	for (int i=0; i < len; i++)
	{
		fuck f = (fuck)(d.front());
		d.pop_back();
	}
	::QueryPerformanceCounter(&litmp);
	LONGLONG sllEndTime = litmp.QuadPart; // 获得初始值
	cout << sllEndTime - sllStartTime << endl;

	::QueryPerformanceCounter(&litmp);
	sllStartTime = litmp.QuadPart; // 获得初始值
	for (int i=0; i < len; i++)
	{
		static fuck data;

		data.a = i;
		data.b = i;
		data.c = i;
		l.push_front(data);
	}
	for (int i=0; i < len; i++)
	{
		fuck f = (fuck)(l.front());
		l.pop_back();
	}
	::QueryPerformanceCounter(&litmp);
	sllEndTime = litmp.QuadPart; // 获得初始值
	cout << sllEndTime - sllStartTime << endl;

	::QueryPerformanceCounter(&litmp);
	sllStartTime = litmp.QuadPart; // 获得初始值
	for (int i=0; i < len; i++)
	{
		static fuck data;

		data.a = i;
		data.b = i;
		data.c = i;
		link.addLast(i);
	}
	for (int i=0; i < len; i++)
	{
		int f = (int)(link.getFirst());
		link.removeFirst();
	}
	::QueryPerformanceCounter(&litmp);
	sllEndTime = litmp.QuadPart; // 获得初始值
	cout << sllEndTime - sllStartTime << endl;

	system("pause");

	return 0;
}