数据结构 创建，插入，删除

[yiqiesuifengf]

有没有那位高手提供一个经典范例，苦闷中··········
谢谢！！！！！

[stainboy]

Windows的话可以用ADO进行数据库操作，参考：http://www.cppblog.com/astone/archive/2006/05/29/8272.html

Linux下面一般用mysql了，可以用mysql connector for cpp,参考：http://www.mysql.com/downloads/connector/cpp/

如果是oracle的数据库，直接使用oracle client。

[lovestefanie]

数据还是数据库？
数据用容器吧

[yiqiesuifengf]

数据结构 要用typedef定义结构体

[yiqiesuifengf]

这是一本书，《数据结构》，里面的链表，插入，删除，创建

[gules]

这是我以前仿STL写的代码，供你参考吧（没写主函数），使用方式与STL一样。

#include <cstddef>

struct bidirectional_iterator_tag {}; // 迭代器的种类

// 节点基本结构
struct ListNodeBase {
	ListNodeBase() : prev(0), next(0) {}
	ListNodeBase* prev;
	ListNodeBase* next;
};

// 完整节点结构
template <class T>
struct ListNode : public ListNodeBase {
	explicit ListNode(const T& x) : ListNodeBase(), data(x) {}
	T data;
};

// 双向链表迭代器基本结构
struct ListIteratorBase {
	typedef bidirectional_iterator_tag iterator_category;
	typedef ptrdiff_t      difference_type;
	typedef ListNodeBase*  NodeBasePtr;
	
	NodeBasePtr node;  // 指向一个节点的基本结构
	
	ListIteratorBase(NodeBasePtr p) : node(p) {}
	void prev() { node = node->prev; } // 后退一个节点
	void next() { node = node->next; } // 前进一个节点
	
	bool operator==(const ListIteratorBase& rhs) const {
		return node == rhs.node;
	}
	bool operator!=(const ListIteratorBase& rhs) const {
		return node != rhs.node;
	}
};

// 双向链表迭代器
template <class T, class Ref, class Ptr>
struct ListIterator : public ListIteratorBase {
	typedef T            value_type;
	typedef Ref          reference;
	typedef Ptr          pointer;
	typedef ListNode<T>* NodePtr;
	
	typedef ListIterator<T, T&, T*>             Iterator;
	typedef ListIterator<T, const T&, const T*> ConstIterator;
	typedef ListIterator<T, Ref, Ptr>           Self;
	
	ListIterator() : ListIteratorBase(0) {}
	ListIterator(NodePtr x) : ListIteratorBase(x) {}
	// Iterator可转换为ConstIterator，OK；反之，不行
	ListIterator(const Iterator& rhs) : ListIteratorBase(rhs.node) {}
	
	reference operator*() const { return ((NodePtr)node)->data; }
	pointer operator->() const { return &(operator*()); }
	
	Self& operator++() {
		next();
		return *this;
	}
	Self operator++(int) {
		Self temp = *this;
		++*this;
		return temp;
	}
	Self& operator--() {
		prev();
		return *this;
	}
	Self operator--(int) {
		Self temp = *this;
		--*this;
		return temp;
	}
};

// 双向链表类
template <class T>
class List {
public:
	typedef T                ValueType;
	typedef T&               Reference;
	typedef const T&         ConstReference;
	typedef T*               Pointer;
	typedef const T*         ConstPointer;
	typedef size_t           SizeType;
	typedef ptrdiff_t        DifferenceType;
	
	typedef ListIterator<T, T&, T*>             Iterator;
	typedef ListIterator<T, const T&, const T*> ConstIterator;
	typedef List<T, Alloc>   Self;
private:
	typedef ListNodeBase     NodeBase;
	typedef ListNodeBase*    NodeBasePtr;
	typedef ListNode<T>      Node;
	typedef ListNode<T>*     NodePtr;
public:
	List() { empty_init(); }
	List(const Self& rhs) {
		empty_init();
		operator=(rhs);
	}
	Self& operator=(const Self& rhs) {
		if (this != &rhs) {
			// 先清除自身
			clear();
			// 复制rhs的元素
			ConstIterator it = rhs.begin();
			while (it != rhs.end())
				push_back(*it++);
		}
		return *this;
	}
	~List() {
		clear();
		delete head;
	}
	
	Iterator begin() { return (NodePtr)head->next; }
	ConstIterator begin() const { return (NodePtr)head->next; }
	Iterator end() { return (NodePtr)head; }
	ConstIterator end() const { return (NodePtr)head; }
	
	SizeType size() const { return distance(begin(), end()); }
	bool empty() const { return head == head->next; }
	
	Reference front() { return *begin(); }
	Reference back() {
		Iterator tmp = end();
		return *(--tmp);
	}
	
	void push_front(const T& x) { insert(begin(), x); }
	void push_back(const T& x) { insert(end(), x); }
	void pop_front() { erase(begin()); }
	void pop_back() { Iterator tmp = end(); erase(--tmp); }
	// 在position所指位置插入一个节点
	Iterator insert(Iterator position, const T& x) {
		NodePtr node = create_node(x); // 创建一个节点，内容为x
		// 调整双向指针
		node->next = position.node;
		node->prev = position.node->prev;
		position.node->prev->next = node;
		position.node->prev = node;
		return node;
	}
	Iterator erase(Iterator position) {
		NodePtr node = (NodePtr)position.node;
		//assert(node == head);
		// 调整双向指针
		NodePtr next_node = (NodePtr)node->next;
		NodePtr prev_node = (NodePtr)node->prev;
		prev_node->next = next_node;
		next_node->prev = prev_node;
		// 销毁position位置的节点
		destroy_node(node);
		return next_node;
	}
	void remove(const T& x) {
		Iterator it = begin();
		while (it != end()) {
			Iterator next = it;
			++next;
			if (*it == x) erase(it); // 找到即删除，注意it会失效
			it = next;
		}
	}
	// 移除连续且相同的元素，剩一个
	void unique(const T& x) {
		Iterator first = begin();
		Iterator last  = end();
		if (first == last) return; // 空表什么也不做
		Iterator next = first; // 当前位置
		while (++next != last) { // 当前的下一个位置
			if (*first == *next)
				erase(next); // 连续相同则移除
			else
				first = next; // 不相同则调整当前位置指向下一个元素
			next = first;  // 重置当前的下一个位置，因为移除操作使next失效
		}
	}
	void clear() {
		NodePtr cur = (NodePtr)head->next;
		while(cur != head) {
			NodePtr tmp = cur;
			cur = (NodePtr)cur->next;
			destroy_node(tmp);
		}
		// 恢复空表状态
		head->prev = head;
		head->next = head;
	}
private:
	// 创建一个节点，并返回其指针
	NodePtr create_node(const T& x) { return new Node(x); }
	// 销毁一个节点
	void destroy_node(NodePtr p) { delete p; }
	// 创建一个空表头节点基本结构，前后都指向自己
	void empty_init() {
		head = new NodeBase();
		head->prev = head; 
		head->next = head;
	}
private:
	NodeBasePtr head;  // 只要一个头节点指针即可表示整个双向环状链表
};