数据结构之集合

非常非常低效率的一个集合，仅仅从功能上实现了接口

/*
 * My_set.h
 *
 *  Created on: 2016年2月6日
 *      Author: triose
 */
#ifndef MY_SET_H_
#define MY_SET_H_

#include<iostream>
using namespace std;

template <class T>
class SetElmt{
public:
	T data;
	SetElmt<T> *next;
	friend bool operator == (const SetElmt<T> & elmt1, const SetElmt<T> & elmt2) {
		return elmt1.data == elmt2.data;
	}
	SetElmt(T data_) {
		data = data_;
		next = NULL;
	}
};
template <class T>
class My_set {
private:
	SetElmt<T> *head;
	int size;
public:
	My_set() {
		head = NULL;
		size = 0;
	}
	~My_set() {

	}
	void insert(T data_) {		//默认由小到大排序(插入排序)	已检查
		SetElmt<T> * newelmt = new SetElmt<T> (data_);
		if(*newelmt < *this) {
			return ;
		}
		if(size == 0) {
			head = newelmt;
			size++;
			return ;
		}
		SetElmt<T> *current_elmt = head;
		if(newelmt->data <= current_elmt->data) {
			newelmt->next = current_elmt;
			head = newelmt;
			size++;
			return ;
		}
		while(current_elmt->data < newelmt->data) {
			if(current_elmt->next == NULL) {
				current_elmt->next = newelmt;
				size++;
				return ;
			}
			else if(current_elmt->next->data >= newelmt->data) {
				newelmt->next = current_elmt->next;
				current_elmt->next = newelmt;
				size++;
				return ;
			}
			current_elmt = current_elmt->next;
		}
	}
	void remove(T data_) {						//移除data = data_的元素。 已检查
		SetElmt<T> *current_elmt = head;
		if(current_elmt->data == data_) {
			head = current_elmt->next;
			size--;
			delete current_elmt;
			return ;
		}
		for(int i = 1; i < size; i++) {
			if(current_elmt->next == NULL) {
				return ;
			}
			if(current_elmt->next->data == data_) {
				SetElmt<T> *delete_elmt = current_elmt->next;
				current_elmt->next = current_elmt->next->next;
				size--;
				delete delete_elmt;
				return ;
			}
			current_elmt = current_elmt->next;
		}
	}
	int getsize() {
		return this->size;
	}
	void output() {														//for Debug
		if(size == 0) {
			cout << "NULL" << endl;
			return ;
		}
		SetElmt<T> *current_elmt = head;
		for(int i = 0; i < size; i++) {
			cout << current_elmt->data << " ";
			current_elmt = current_elmt->next;
		}
		cout << endl;
	}

	friend My_set<T> operator +(const My_set<T> & set1, const My_set<T> & set2) {		//并
		My_set<T> set3;
		SetElmt<T> *current_elmt = set1.head;
		for(int i = 0; i < set1.size; i++) {
			set3.insert(new SetElmt<T> (current_elmt->data));
			current_elmt = current_elmt->next;
		}
		current_elmt = set2.head;
		for(int i = 0; i < set2.size; i++) {
			if(!(*current_elmt < set3)) {
				set3.insert(new SetElmt<T> (current_elmt->data));
			}
			current_elmt = current_elmt->next;
		}
		return set3;
	}
	friend My_set<T> operator -(const My_set<T> & set1, const My_set<T> & set2) {		//差
		My_set<T> set3;
		SetElmt<T> *current_elmt = set1.head;
		for(int i = 0; i < set1.size; i++) {
			if(!(*current_elmt < set2)) {
				set3.insert(new SetElmt<T> (current_elmt->data));
			}
			current_elmt = current_elmt->next;
		}
		return set3;
	}
	friend My_set<T> operator |(const My_set<T> & set1, const My_set<T> & set2) {		//交
		My_set<T> set3;
		SetElmt<T> *current_elmt = set1.head;
		for(int i = 0; i < set1.size; i++) {
			if((*current_elmt) < set2) {
				set3.insert(new SetElmt<T>(current_elmt->data));
			}
			current_elmt = current_elmt->next;
		}
		return set3;
	}
	friend bool operator <(const My_set<T> & set1, const My_set<T> & set2) {	//set1 是 set2 的子集
		SetElmt<T> *current_elmt = set1.head;
		for(int i = 0; i < set1.size; i++) {
			if(!(*current_elmt < set2)) {
				return false;
			}
			current_elmt = current_elmt->next;
		}
		return true;
	}
	friend bool operator >(const My_set<T> & set1, const My_set<T> & set2) {	//set2 是 set1 的子集
		return (set2 < set1);
	}
	friend bool operator <(const SetElmt<T> & elmt, const My_set<T> & set) {	//elmt 属于 set
		SetElmt<T> * current_elmt = set.head;
		for(int i = 0; i < set.size; i++) {
			if(current_elmt->data == elmt.data) {
				return true;
			}
			current_elmt = current_elmt->next;
		}
		return false;
	}
	friend bool operator ==(const My_set<T> & set1, const My_set<T> & set2) {	//判断两集合是否相等
		if(set1.size != set2.size) {					//size 相等 并且 set1 < set2 ==》 set1 == set2
			return false;
		}
		return set1 < set2;
	}
};


#endif /* MY_SET_H_ */