利用AVL树实现搬箱问题的best fit策略

//my.h
//定义两个数据类型，货物Goods，箱子Box

#include <vector>
#include <cstddef>
#include <iostream>
struct Goods
{
    int id;
    double weight;
    Goods(int i,double w):id(i),weight(w) { }
    ~Goods()
    { };
};

struct Box
{
    int id;
    std::vector<Goods*> vG;
    double space;
    Box(int i,double f,Goods* x = NULL)
    {
        id = i;
        space = f;
        if(x != NULL)
            vG.push_back(x);
    }

    Box& operator-= (Goods& rhs)
    {
        space -= rhs.weight;
        vG.push_back(&rhs);
        return *this;
    }


    Box(Box& rhs)
    {
        operator=(rhs);
    }


    Box& operator= (const Box& rhs)
    {
        if(this == &rhs)
            return *this;
        id = rhs.id;
        space = rhs.space;
        vG = rhs.vG;
        return *this;
    }

    ~Box()
    {
        int n = vG.size();
        for(int i = 0; i < n; ++i)
            delete vG[i];
    }
        
};

bool operator< (const Box& lhs, const Box& rhs)
{
    return (lhs.space < rhs.space);
}
bool operator== (const Box& lhs,const Box& rhs)
{
    return (lhs.space == rhs.space && lhs.id == rhs.id);
}
bool operator<= (const Box& lhs,const Box& rhs)
{
    return !(rhs < lhs);
}
bool operator> (const Box& lhs,int a)
{
    return (lhs.space > a);
}
bool operator< (const Box& lhs,const Goods& rhs)
{
    return (lhs.space < rhs.weight);
}
bool operator< (const Goods& lhs, const Box& rhs)
{
    return (lhs.weight < rhs.space);
}
bool operator== (const Box& lhs,const Goods& rhs)
{
    return (lhs.space == rhs.weight);
}

std::ostream& operator<< (std::ostream& out,const Box& b)
{
    out << "Box: " << b.id << std::endl;
    int n = b.vG.size();
    if( n > 0)
    {
        for(int i = 0; i < n-1; ++i)
            out << "\t" << b.vG[i]->id << " " << b.vG[i]->weight << std::endl;
        out << "\t" << b.vG[n-1]->id << " " << b.vG[n-1]->weight;
    }
    return out;
}

 

//avl.h
//主体部分，建立一个AVL树，实现best fit

#include "my.h"
#include <algorithm>
//#include <utility>

template<class T,class V>
class Avl
{
public:
    Avl():root(NULL),len(0) { }
    Avl(const Avl& rhs)
    {
        operator= (rhs);
    }

    ~Avl()
    {
        makeEmpty();
    }
    void makeEmpty();

    void insert( V* x); //GOODS

    const Avl& operator= (const Avl& rhs)
    {
        if(this == &rhs)
            return *this;
        Avl temp(rhs);
        swap(*this,temp);
        return *this;
    }

    void output()
    {
        for(int i = 0; i < vT.size(); ++i)
            std::cout << *(vT[i]) << std::endl;
        output(root);
    }
private:
    struct Node
    {
        T* element;
        Node *left;
        Node *right;
        int height;

        Node(T* x,Node *lt,Node *rt,int h = 0)
            :element(x),left(lt),right(rt),height(h) { }
        ~Node()
        {
            delete element;
            element = NULL;
        }
    };
    Node *root;
    int len;
    std::vector<T*> vT;

    int height(const Node* t) const
    { return t == NULL ? -1 : t->height; }
    
    void insert(T* x, Node* &t); //BOX
    //void insert(V* x, Node* &t); //GOODS
    void remove(Node* p,Node* &t);
    void percolateDown(Node* t);
    Node* find(V* x,Node* t);
    Node* findmin(Node* t) const;
    Node* findmax(Node* t) const;  //can't use const Node* t
    void rotateWithLeftChild(Node* & k2);
    void rotateWithRightChild(Node* & k2);
    void doubleWithLeftChild(Node* & k3);
    void doubleWithRightChild(Node* & k3);
    void makeEmpty(Node* & t);
    void output(Node* t)
    {
        if(t != NULL)
        {
            output(t->left);
            output(t->right);
            std::cout << *(t->element) << std::endl;
        }
    }
};

template<class T,class V>
void Avl<T,V>::insert(V* x)
{
    Node* t = find(x,root);
    if(t != NULL)
    {
        *(t->element) -= *x;
        //t->element->insert(x);
        if(*(t->element) > 1e-5)
            percolateDown(t);
        else
        {
            Node* p = t;
            if(t->right)
                p = findmin(t->right);
            else
                p = findmax(t->left);
            remove(p,root);
            swap(t->element,p->element);
            vT.push_back(p->element);
        }
    }
    else
    {
        T* b = new Box(len+1,1-x->weight,x);
        //b->insert(x);
        ++len;
        insert(b,root);
    }
        
}

template<class T,class V>
void Avl<T,V>::remove(Node* p, Node* & t)
{
    if(t == NULL)
        return;
    else if(*(p->element) < *(t->element))
    {
        remove(p,t->left);        
        if(height(t->left) - height(t->right) == -2)
            rotateWithRightChild(t);

    }
    else if(*(t->element) < *(p->element))
    {
        remove(p,t->right);
        if(height(t->left) - height(t->right) == 2)
            rotateWithLeftChild(t);
    }
    else
    {
        t = t->left != NULL ? t->left : t->right;
        p->left = NULL;
        p->right = NULL;
        return;
    }
    t->height = max(height(t->left),height(t->right)) + 1;
}

template<class T,class V>
void Avl<T,V>::insert(T* x, Node* &t)
{
    if(t == NULL)
        t = new Node(x,NULL,NULL);
    else if( *x < *(t->element))
    {
        insert(x,t->left);
        if(height(t->left) - height(t->right) == 2)
        {
            if(*x < *(t->left->element))
                rotateWithLeftChild(t);
            else
                doubleWithLeftChild(t);
        }
    }
    else
    {
        insert(x,t->right);
        if(height(t->right) - height(t->left) == 2)
        {
            if( *(t->right->element) <= *x)
                rotateWithRightChild(t);
            else
                doubleWithRightChild(t);
        }
    }
    t->height = max(height(t->left),height(t->right)) + 1;
}

template<class T,class V>
typename Avl<T,V>::Node* Avl<T,V>::find(V* x,Node* t)
{
    Node* p = NULL;
    while(t != NULL)
    {   
        if( *(t->element) < *x)
        {
            t = t->right;
        }
        else if( *x < *(t->element))
        {
            p = t;
            t = t->left;
        }   
        else
        {
            p = t;
            break;
        }
    }
    return p;
}

template<class T,class V>
void Avl<T,V>::percolateDown(Node* t)
{
    while(t->left != NULL || t->right != NULL)
    {
        if(t->left != NULL && (*(t->element) < *(t->left->element)))
        {
            swap(t->element,t->left->element);
            t = t->left;
        }
        else if(t->right != NULL && (*(t->right->element) < *(t->element)))
        {
            swap(t->element,t->right->element);
            t = t->right;
        }
        else
            break;
    }
}

template<class T,class V>
typename Avl<T,V>::Node* Avl<T,V>::findmin(Node* t) const  //can't use const Node* t
{
    if(t != NULL)
        while(t->left != NULL)
            t = t->left;
    return t;
}

template<class T,class V>
typename Avl<T,V>::Node* Avl<T,V>::findmax(Node* t) const
{
    if(t != NULL)
        while(t->right != NULL)
            t = t->right;
    return t;
}

template<class T,class V>
void Avl<T,V>::rotateWithLeftChild(Node* & k2)
{
    Node* k1 = k2->left;
    k2->left = k1->right;
    k1->right = k2;
    k2->height = max(height(k2->left),height(k2->right)) + 1;
    k1->height = max(height(k1->left),k2->height) + 1;
    k2 = k1;
}

template<class T,class V>
void Avl<T,V>::rotateWithRightChild(Node* & k2)
{
    Node* k1 = k2->right;
    k2->right = k1->left;
    k1->left = k2;
    k2->height = max(height(k2->left),height(k2->right)) + 1;
    k1->height = max(height(k1->left),k2->height) + 1;
    k2 = k1;
}

template<class T,class V>
void Avl<T,V>::doubleWithLeftChild(Node* & k3)
{
    rotateWithRightChild(k3->left);
    rotateWithLeftChild(k3);
}

template<class T,class V>
void Avl<T,V>::doubleWithRightChild(Node* & k3)
{
    rotateWithLeftChild(k3->right);
    rotateWithRightChild(k3);
}

template<class T,class V>
void Avl<T,V>::makeEmpty()
{
    makeEmpty(root);
}

template<class T,class V>
void Avl<T,V>::makeEmpty(Node* & t)
{
    if(t != NULL)
    {
        makeEmpty(t->left);
        makeEmpty(t->right);
        delete t;
    }
    t = NULL;
    for(int i = 0; i < vT.size(); ++i)
        delete vT[i];
}

 

//main.cpp
/***********************************
装箱问题：利用AVL树
1、实现首次适配算法
2、实现最佳适配算法
作者：陈卫安
时间：2014-04-09
***********************************/
#include "avl.h"
//#include <iostream>
using namespace std;

void inputGoods(vector<Goods*>& G)
{
    double w;
    int i = 0;
    Goods* p = NULL;
    while(cin)
    {
        cin >> w;
        p = new Goods(i,w);
        G.push_back(p);
        i++;
    }
}

void FirstFit(Avl<Box,Goods>& boxtree,const vector<Goods*>& G)
{
    for(int i = 0; i < G.size(); i++)
        boxtree.insert(G[i]);
}

int main()
{
    Avl<Box,Goods> boxtree;
    vector<Goods*> G;
    inputGoods(G);
    FirstFit(boxtree,G);
    boxtree.output();
    return 0;
}

 

思路：

　　1、当树为空时，建立一个新节点（即开辟一个新箱子）；

　　2、若不为空，寻找最适合的节点（箱子），space =  1 - weight，然后下滤到合适位置；

　　3、若箱子容量为0，从树中删除该节点（箱子），存到数组。

　　4、若没有找到能够容下该货品的节点（箱子），开辟一个箱子，插入到树里。

编程时遇到的一些问题：

　　1、函数形参Node* 前面不能加cosnt，如果加了const，只能传递const类型的数据指针作为实参。这点和传值Node& 不一样，const Node& 表示即可以传const类型的数据，也可以传非const类似的数据。

　　2、Node* find()  返回一个类里面定义的数据类型，这是一个类型成员，类似vector<int>::size_type，需要在返回类型前面加类限定符，

　　改为 typename Avl<T,V>::Node*  find()  ;需要在前面加typename限制，表明这是一个类型成员。