cs11_c++_lab4b

SparseVector.hh

class SparseVector
{
private:
    //结构体不一定会用到，不用初始化
    struct node
    {
        int index;
        int value;
        node *next;
        
        node(int index, int value, node *next = 0) : index(index), value(value), next(next) {}
    };
    //这些才是真正的数据成员，要初始化的
    int size;
    node *start;    

    void clear();
    void copyList(const SparseVector &sv);
    void setNonzeroElem(int index, int value);
    void removeElem(int index);
    void checkListOrder();
    void addSubVector(const SparseVector &sv, bool add);
    void removeZeros();
    void checkZeros();
public:
    SparseVector(int size);
    const int getSize()const;

    ~SparseVector();
    SparseVector(const SparseVector &sv);
    SparseVector & operator= (const SparseVector &sv);
    int getElem(int idx);
    void setElem(int index, int value);
    bool operator==(const SparseVector &sv)const;
    bool operator!=(const SparseVector &sv)const;
    SparseVector& operator+=(const SparseVector &sv);
    SparseVector& operator-=(const SparseVector &sv);
    const SparseVector& operator+(const SparseVector &sv)const;
    const SparseVector& operator-(const SparseVector &sv)const;
};

SparseVector.cc

#include "SparseVector.hh"
#include <cassert>
#include <iostream>
using namespace std;
//单参数构造函数
SparseVector::SparseVector(int size):size(size)
{
    start = 0;
}

const int SparseVector::getSize()const
{
    return size;
}
//成员函数都默认带有this指针，所以默认对调用这个函数的对象进行操作，所以不用再传本对象的地址了。
void SparseVector::clear()
{
    node *next;
    node *current;    
    current = start;
    while(current != 0)
    {
        next = current->next;
        delete current;
        current = next;
    }
    start = 0;
}
//对本对象进行操作，调用成员行数也是默认对本对象进行操作，不用传本对象地址。
SparseVector::~SparseVector()
{
    clear();
}

void SparseVector::copyList(const SparseVector &sv)
{
    size = sv.getSize();
    node *current;
    node *otherCurrent =sv.start;
    node *prev = 0;

    while(otherCurrent != 0)
    {
        current = new node(otherCurrent->index, otherCurrent->value);
        if(prev == 0)
        {
            start = current;
            prev = current;
        }
        prev->next = current;
        prev = current;
        otherCurrent = otherCurrent->next;
    }
}

SparseVector::SparseVector(const SparseVector &sv)
{
    copyList(sv);
}
//注意自赋值，并且直接调用私有帮助函数。
SparseVector & SparseVector:: operator= (const SparseVector &sv)
{
    if (this == &sv)
    {
        return *this;
    }
    clear();
    copyList(sv);
    return *this;
}
//难点
int SparseVector::getElem(int idx)
{
    node *current = start;
    while(current != 0 && current->index < idx)//过滤，两个条件
    {
        current = current->next;
    }
    if(current == 0)//注意判断条件先后次序，先排除current为0情况
    {
        return 0;
    }
    else if(current->index == idx)//如果先执行这个，则current为0时，会直接产生段错误
    {
        return current->value;
    }    
    else 
    {
        return 0;
    }
}
//难点，分种情况讨论：1,初始为空。2,插到最后面。3,插到最前面。4，插到中间。
void SparseVector::setNonzeroElem(int index, int value)
{
    assert(value != 0);
    node *current = start;
    node *prev = 0;
    
    if(start == 0)//容易遗漏，链表初始为空的情况。（1）
    {
        start = new node(index, value);
    }    
    else//除此情况外（2,3,4）
    {
        while(current != 0 && current->index < index)//过滤，两个条件，保证current指向应该指的结点，或其之后的结点。prev指向值小于应该的结点。
        {
            prev = current;
            current = current->next;//别忘了自增
        }
    /*2选1
     *     if(current == start)//插到最前面，current所指结点大于等于它
        {
            if(current->index == index)//等于
            {    
                current->value = value;
            }
            else//大于
            {
                node *other = new node(index, value, start);
                start = other;
            }
        }    
        else if(current == 0)//插到最后面，current所指结点小于它
        {
            node *other = new node(index, value, 0);
            prev->next = other;
        }
        else//插到中间，current所指结点大于等于它
        {
            if(current->index == index)//current所指结点等于它
            {
                current->value = value;
            }
            else//current所指结点结点大于它
            {
                node *other = new node(index, value, current);
                prev->next = other;
            }
        }
*/
        if(current == 0)//插到最后边
        {
            node *other = new node(index, value);
            prev->next = other;
        }
        else if(current -> index == index)//current所指结点等于它的值
        {
            current->value =value;
        }
        else if(current == start)//在最开始的地方
        {
            node *other = new node(index, value, start);
            start = other;
        }
        else //在中间
        {
            node *other = new node(index, value, current);
            prev->next = other;        
        }
    }
}

void SparseVector::removeElem(int index)
{
    node *current = start;
    node *prev = 0;
    while(current != 0 && current->index < index)//过滤
    {
        prev = current;
        current = current->next;
    }
    if(current->index == index)//如果是这个结点
    {
        if(current == start)//是开始结点
        {
            prev = current;
            current = current->next;
            delete prev;
            start = current;
            return; 
        }
        else//是中间结点或者是后边的节点（相同的）
        {
            prev->next = current->next;
            delete current;
            return;
        }
    }
    else 
    {
        return;
    }
}

void SparseVector::setElem(int index, int value)
{
    if(value != 0)
    {
        setNonzeroElem(index, value);
    }
    else
    {
        removeElem(index);
    }
}

void SparseVector::checkListOrder()
{
    node *current = start;
    while(current != 0)
    {
        cout<<"("<<current->index<<"  |  "<<current->value<<")"<<endl;
        current = current->next;
    }
    return;
}

bool SparseVector::operator==(const SparseVector &sv)const
{
    if(size != sv.size)//先判断是不是size不等，直接排除
    {
        return false;
    }
    else//每个结点依次判断index和value
    {
        node *current = start;
        node *otherCurrent = sv.start;
        while(current != 0 && otherCurrent != 0)
        {
            if(current->index != otherCurrent->index || current->value != otherCurrent->value)
            {
                return false;
            }
            current = current->next;
            otherCurrent = otherCurrent->next;
        }
        if(current == 0 && otherCurrent == 0)//看看还有没有哪个剩余结点
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

bool SparseVector::operator!=(const SparseVector &sv)const
{
    return !(*this == sv);//调用等号，结果取反
}

void SparseVector::addSubVector(const SparseVector &sv, bool add)
{
    node *current = start;
    node *otherCurrent = sv.start;
    node *prev = 0;
    int sign = (add ? 1 : -1);//注意符号处理方式

    if(current == 0)//两个链表合并时，一定不能忽略被合并链表为空的情况：（a+=b，其中a为空）
    { 
        if(otherCurrent == 0)//（ab均为空）
        {
            return;
        }
        else
        {
            while(otherCurrent != 0)//（a为空b不为空）参考直接插入法形成一个新链表
            {
                node *addTo = new node(otherCurrent->index, sign * otherCurrent->value, 0);
                if(prev == 0)
                {    
                    start = addTo;
                    prev = addTo;
                    current = addTo;
                }
                else
                {
                    current->next = addTo;
                    current = addTo;  
                }
                otherCurrent = otherCurrent->next;
            }
            return;
        }   
    }
    else//合并时均非空的情况
    {
        while(current != 0 && otherCurrent != 0)//都顺序遍历，直到某一链表结束
        {
            if(current->index > otherCurrent->index)//插入的
            {
                if(prev == 0)//初始结点
                {
                    node *addTo = new node (otherCurrent->index, sign * otherCurrent->value, current);
                    start = addTo;
                    prev = addTo;
                    otherCurrent = otherCurrent->next;
                }
                else//非初始结点
                {
                    node *addTo = new node(otherCurrent->index, sign * otherCurrent->value, current);
                    prev->next = addTo;
                    prev = addTo;
                    otherCurrent = otherCurrent->next;
                }            
            }
            else if(current->index == otherCurrent->index)//直接加减的
            {
                current->value += sign * otherCurrent->value;
                prev = current;
                current = current->next;
                otherCurrent = otherCurrent->next; 
            }
            else if(current->index < otherCurrent->index)//不插入的
            {
                prev = current;
                current = current->next;
            }
        }
        if(otherCurrent == 0)//处理剩余的结点
        {
            return;
        }
        else//把剩余的插入到原来的
        {
            while(otherCurrent != 0)
            {
                node *addTo = new node(otherCurrent->index, sign * otherCurrent->value, current);
                prev->next = addTo;
                prev = addTo;
                otherCurrent = otherCurrent->next;
            }
        }
        return;
    }    
}

void SparseVector::removeZeros()
{
    node *current = start;
    node *prev = 0;
    while(current != 0)//非0状态
    {
        if(current->value != 0)
        {
            prev = current;
            current = current->next;
        }
        else//为0状态
        {
            if(prev == 0)//如果初始结点为0
            {
                prev = current;
                current = current->next;
                delete prev;
                start = current;
                prev = 0;
            }
            else//非初始结点为0
            {
                node *temp = current;
                current = current->next;
                delete temp;
                prev->next = current;
            }
        }
    }
}

SparseVector& SparseVector::operator+=(const SparseVector &sv)
{
    addSubVector(sv, true);
    removeZeros();
    node * current = start;
    size = 0;
    while(current != 0)//最后还要把size弄好
    {
        ++size;
        current = current->next;
    }
    return *this;
}

SparseVector& SparseVector::operator-=(const SparseVector &sv)
{
    addSubVector(sv, false);
    removeZeros();
    size = 0;
    node *current = start;
    while(current != 0)//最后还要把size弄好
    {
        ++size;
        current = current->next;
    }
    return *this;
}

const SparseVector& SparseVector::operator+(const SparseVector &sv)const
{
    SparseVector *newSp = new SparseVector(*this);
    *newSp += sv;
    return *newSp;
}

const SparseVector& SparseVector::operator-(const SparseVector &sv)const
{
    SparseVector *newSp = new SparseVector(*this);
    *newSp -= sv;
    return *newSp;
}

void SparseVector::checkZeros()
{
    node *current = start;
    while(current != 0)
    {
        if(current->value == 0)
        {
            cout<<"number "<<current->index<<"  "<<current->value<<endl;
            current = current->next;
        }
    }
}