// 樹的迭代器 tree_iterator.h

//
// Created by Yongyu Wu on 2018/11/11.
//
//樹節點的迭代器


#ifndef C11TEMPLATE_TREE_ITERATOR_H
#define C11TEMPLATE_TREE_ITERATOR_H
#pragma once
template <typename N>
class tree_iterator{
    const N *pos; //當前位置
public:
    typedef typename N::value_type value_type;
    typedef typename N::const_reference_type const_reference_type;
    typedef tree_iterator<N> self_type;

    tree_iterator():pos(0){}
    tree_iterator(const N*pos):pos(pos){}

    bool operator ==(self_type const &right)const{
        return pos == right.pos;
    }

    self_type &operator++(){
        if(pos){
            //首先確保不是空的迭代器，再檢視有沒有右子樹
            if(pos->right){
                //定位到右子樹的最左節點
                pos=pos->right;
                while (pos->left)pos=pos->left;
            }else{
                //定位到尚未訪問過的祖先節點
                while ((pos->parent)&&(pos->parent->right==pos))pos=pos->parent;
                pos=pos->parent;
            }
        }
        return *this;

    }

    const_reference_type operator *()const throw(std::runtime_error){
        if(pos)return pos->value;
        else {
            throw  std::runtime_error("dereference null iterator!");
        }
    }

};

template <typename N>
bool operator !=(tree_iterator<N>const & left,tree_iterator<N> const & right){
    return !(left==right);
}


#endif //C11TEMPLATE_TREE_ITERATOR_H

 

//
// Created by Yongyu Wu on 2018/11/11.
//

#ifndef C11TEMPLATE_SET_H
#define C11TEMPLATE_SET_H

#pragma once

#include <iostream>
#include "tree_iterator.h"

//二叉搜尋樹模板
template <typename T>
struct tree_node{
    typedef T value_type;
    typedef T & reference_type;
    typedef const T& const_reference_type;
    T value;
    tree_node * parent;
    tree_node * left;
    tree_node * right;

    tree_node(T const & value,tree_node *parent,tree_node*left,tree_node* right):value(value),
    parent(parent),left(left),right(right){}

    ~tree_node(){
        if(left) delete  left;
        if (right) delete right;
    }

};
//集合容器模板
template <typename T>
class set{
    typedef tree_node<T> node_type;
    node_type* root;
public:
    typedef T value_type;
    typedef tree_iterator<node_type> const_iterator;

    set():root(){}
    ~set(){if(root)delete root;}

    //嘗試向集合中插入資料，返回是否成功的插入
    //當集合中已經有該值時，返回false，否則返回true
    bool insert(T const &v){
        node_type **n =&root; //這裡root雖然是個指標但是可能是空值,為了給指標賦值，所以取地址
        node_type*p=0;

        while(*n){
            if(v==(*n)->value)//集合中已經有該值
                return false;
            else{
                p =*n;
                n=v<(*n)->value?&((*n)->left):&((*n)->right);

            }
        }
        *n =new node_type(v,p,0,0);
        return true;
    }
    //查詢集合中是否有某值，有時返回true，沒有返回=false
    bool has(T const & v){
        node_type*n =root;
        while (n){
            if(v==n->value)
                return true;
            n= v < n->value ? n->left : n->right;
        }
        return false;
    }

    bool is_empty()const{
        return root ==0;
    }
    const_iterator begin()const{
        //定位到最左節點及中序遍歷的第一個節點，返回一個指向該節點的遍歷器
        node_type*n=root;
        while (n->left)n=n->left;
        return const_iterator(n);
    }
    const_iterator end()const{

        return const_iterator();
    }



};


#endif //C11TEMPLATE_SET_H