测试-稀疏多项式C++链表的问题

问题描述

稀疏多项式C++链表的问题 
 #include<iostream>
using namespace std;

//约定稀疏多项式输入升幂排列
template<class T>class Polynomial;
template<class T>ostream& operator<<(ostream& out, Polynomial<T>&a);

template<class T>
class Polynomial
{
private:
    class Term
    {
    public:
        T xishu;
        unsigned mi;
    };
    class Node
    {
    public:
        Term data;
        Node* next;
        Node(T x = 0, unsigned y = 0, Node* p = 0)
        {
            data.xishu = x;
            data.mi = y;
            next = p;//修改
        }
    };
public:
    Polynomial();
    void myfree();//释放链表各节点,由于要重载+，所以设置这个函数
    Polynomial<T>& operator=(const Polynomial<T>&);
    Polynomial<T> operator+(const Polynomial<T>&);
    Polynomial<T> operator*(const Polynomial<T>&);
    void initial();
    friend ostream& operator<< <T> (ostream& out, Polynomial<T>& a);

private:
    int highestdigit;
    Node* first;
    int num;//用来判断多项式有几项,即链表节点数,在乘法运算里也要用到
};
template<class T>
Polynomial<T>::Polynomial()
{
    first = new Node;
    num = 0;
    highestdigit = 0;
}

template<class T>
void Polynomial<T>::myfree()    //释放链表各节点
{
    Node* p = first, *q;
    while (p)
    {
        q = p->next;
        delete p;
        p = q;
    }
}

template<class T>
Polynomial<T>& Polynomial<T>::operator=(const Polynomial<T>& second)
{
    highestdigit = second.highestdigit;
    num = second.num;
    Node* p1 = first, *p2 = second.first;

    while (p2->next)
    {
        p1->next = new Node();
        p1 = p1->next;
        p2 = p2->next;
        *p1 = *p2;
    }
    return *this;
}

template<class T>
Polynomial<T> Polynomial<T>::operator+(const Polynomial<T>& second)
{
    Polynomial<T> sum;
    Node* pa = first->next, *pb = second.first->next, *pc = sum.first;
    while (pa&&pb)
    {
        if (pa->data.mi == pb->data.mi)  // 指数相等时
        {
            T x = pa->data.xishu + pb->data.xishu;
            if (x)     // 相加完的系数不为0时
            {
                pc->next = new Node(x, pa->data.mi);
                pc = pc->next;
                ++sum.num;
                sum.highestdigit = pa->data.mi;
            }
            pa = pa->next;
            pb = pb->next;
        }
        else if (pa->data.mi > pb->data.mi){
            pc->next = new Node(pa->data.xishu, pa->data.mi);
            pc = pc->next;
            pa = pa->next;
            ++sum.num;
            sum.highestdigit = pa->data.mi;
        }
        else{
            pc->next = new Node(pb->data.xishu, pb->data.mi);
            pc = pc->next;
            pb = pb->next;
            ++sum.num;
            sum.highestdigit = pb->data.mi;
        }
    }
    while (pa){
        pc->next = new Node(pa->data.xishu, pa->data.mi);
        pc = pc->next;
        pa = pa->next;
        ++sum.num;
        sum.highestdigit = pa->data.mi;
    }
    while (pb){
        pc->next = new Node(pb->data.xishu, pb->data.mi);
        pc = pc->next;
        pb = pb->next;
        ++sum.num;
        sum.highestdigit = pb->data.mi;
    }
    return sum;
}
template<class T>
Polynomial<T> Polynomial<T>::operator*(const Polynomial<T>& second){
    Polynomial<T> multi;
    Node* pa = first->next, *pb = second.first->next;
    if (num >= second.num){ //拿项数多的那个链表乘以项数少的那个
        Polynomial<T> temp;
        Node* pt;
        while(pb){          //pb是项数少的那个，
        pt = temp.first;
            while (pa){     //项数多的开始遍历
                pt->next = new Node(pa->data.xishu*pb->data.xishu, pa->data.mi*pb->data.mi);
                pt = pt->next;
                pa = pa->next;
            }
            multi= temp+multi;
            temp.myfree();
            temp.first = new Node();
            pb = pb->next;
        }
        return multi;
    }
    else{
        Polynomial<T> temp;
        Node* pt;
        while(pa){
            pt = temp.first;
            while (pb){
                pt->next = new Node(pa->data.xishu*pb->data.xishu, pa->data.mi*pb->data.mi);
                pt = pt->next;
                pb = pb->next;
            }
            multi = temp+multi;
            temp.myfree();
            temp.first = new Node();
            pa = pa->next;
        }
        return multi;
    }
}
template<class T>
void Polynomial<T>::initial()
{
    //释放链表，保留头节点
    Node* p = first->next, *q;
    while (p)
    {
        q = p->next;
        delete p;
        p = q;
    }
    p = first;

    T a;
    int b;
    num = 0; highestdigit = 0;//修改
    while (cin >> a&&a != 0 && cin >> b){   //输入a=0时结束输入
        if (b >= highestdigit) highestdigit = b;
        ++num;
        p->next = new Node(a, b);
        p = p->next;
    }
    fflush(stdin);//修改
}

template<class T>
ostream& operator<<(ostream& out, Polynomial<T>& a)
{
    Polynomial<T>::Node *p = a.first->next;

    if (p == NULL) return out;//修改

    if (p->data.xishu == 0)cout << endl;//修改
    else{
        if (p->data.xishu != 1)
            out << p->data.xishu << "x^" << p->data.mi;
        else    out << "x^" << p->data.mi;
    }
    p = p->next;
    while (p)
    {
        out << '+';
        if (p->data.xishu != 1)
            out << p->data.xishu << "x^" << p->data.mi;
        else    out << "x^" << p->data.mi;
        p = p->next;
    }
    return out;
}

测试代码：

#include "Polynomial.h"
#include
using namespace std;
int main(){
Polynomial a, b, c,d;
a.initial();
cout << "a= " << a << endl;
b.initial();
cout << "b=" << b << endl;
c = a + b;
cout << "c=" << c << endl;
d=a*b;
cout<<"d="<<d<<end;
a.myfree();
b.myfree();
c.myfree();
d.myfree();
return 0;
}

解决方案

更正项少+项多时的错误：

#include<iostream>
using namespace std;

//约定稀疏多项式输入升幂排列
template<class T>class Polynomial;
template<class T>ostream& operator<<(ostream& out, Polynomial<T>&a);

template<class T>
class Polynomial
{
private:
    class Term
    {
    public:
        T xishu;
        int mi;
    };
    class Node
    {
    public:
        Term data;
        Node* next;
        Node(T x = 0, unsigned y = 0, Node* p = 0)
        {
            data.xishu = x;
            data.mi = y;
            next = p;//修改
        }
    };
public:
    Polynomial();
    void myfree();//释放链表所有各节点
    Polynomial<T>& operator=(const Polynomial<T>&);
    Polynomial<T> operator+(const Polynomial<T>&);
    Polynomial<T> operator*(const Polynomial<T>&);
    void initial();
    friend ostream& operator<< <T> (ostream& out, Polynomial<T>& a);

private:
    int highestdigit;
    Node* first;
    int num;//用来判断多项式有几项,即链表节点数,在乘法运算里也要用到
};
template<class T>
Polynomial<T>::Polynomial()
{
    first = new Node;
    num = 0;
    highestdigit = 0;
}

template<class T>
void Polynomial<T>::myfree()    //释放链表所有节点
{
    Node* p = first, *q;
    while (p)
    {
        q = p->next;
        delete p;
        p = q;
    }
    first=NULL;//修改
    num = 0; highestdigit = 0;//修改
}

template<class T>
Polynomial<T>& Polynomial<T>::operator=(const Polynomial<T>& second)
{
    myfree();
    highestdigit = second.highestdigit;
    num = second.num;
    first = second.first;

    return *this;
}

template<class T>
Polynomial<T> Polynomial<T>::operator+(const Polynomial<T>& second)
{
    Polynomial<T> sum;
    Node* pa = first->next, *pb = second.first->next, *pc = sum.first;
    while (pa&&pb)
    {
        if (pa->data.mi == pb->data.mi)  // 指数相等时
        {
            T x = pa->data.xishu + pb->data.xishu;
            if (x)     // 相加完的系数不为0时
            {
                pc->next = new Node(x, pa->data.mi);
                pc = pc->next;
                ++sum.num;
                if(sum.highestdigit<pa->data.mi) sum.highestdigit = pa->data.mi;
            }
            pa = pa->next;
            pb = pb->next;
        }
        else if (pa->data.mi > pb->data.mi){
            pc->next = new Node(pa->data.xishu, pa->data.mi);
            if(sum.highestdigit<pa->data.mi) sum.highestdigit = pa->data.mi;
            ++sum.num;
            pc = pc->next;
            pa = pa->next;
        }
        else{
            pc->next = new Node(pb->data.xishu, pb->data.mi);
            ++sum.num;
            if(sum.highestdigit<pb->data.mi) sum.highestdigit = pb->data.mi;
            pc = pc->next;
            pb = pb->next;
        }
    }
    while (pa){
        pc->next = new Node(pa->data.xishu, pa->data.mi);
        ++sum.num;
        if(sum.highestdigit<pa->data.mi) sum.highestdigit = pa->data.mi;
        pc = pc->next;
        pa = pa->next;
    }
    while (pb){
        pc->next = new Node(pb->data.xishu, pb->data.mi);
        ++sum.num;
        if(sum.highestdigit<pb->data.mi) sum.highestdigit = pb->data.mi;
        pc = pc->next;
        pb = pb->next;
    }
    return sum;
}
template<class T>
Polynomial<T> Polynomial<T>::operator*(const Polynomial<T>& second){
    Polynomial<T> multi, temp;
    Node* pa = first->next, *pb = second.first->next, * pt;

    if (num >= second.num){ //拿项数多的那个链表乘以项数少的那个
        while(pb){          //pb是项数少的那个，
            pt = temp.first;
            while (pa){     //项数多的开始遍历
                pt->next = new Node(pa->data.xishu*pb->data.xishu, pa->data.mi+pb->data.mi);//修改
                temp.num++;//修改
                if( temp.highestdigit<pt->next->data.mi ) temp.highestdigit=pt->next->data.mi;//修改
                pt = pt->next;
                pa = pa->next;
            }
            multi= temp+multi;
            temp.myfree();
            temp.first = new Node();
            pa = first->next;
            pb = pb->next;
        }
    }
    else{
        while(pa){
            pt = temp.first;
            while (pb){
                pt->next = new Node(pa->data.xishu*pb->data.xishu, pa->data.mi+pb->data.mi);//修改
                temp.num++;//修改
                if( temp.highestdigit<pt->next->data.mi ) temp.highestdigit=pt->next->data.mi;//修改
                pt = pt->next;
                pb = pb->next;
            }
            multi = temp+multi;
            temp.myfree();
            temp.first = new Node();
            pb = second.first->next;//修改
            pa = pa->next;
        }
    }
    return multi;
}
template<class T>
void Polynomial<T>::initial()
{
    //释放链表，保留头节点
    Node* p = first->next, *q;
    while (p)
    {
        q = p->next;
        delete p;
        p = q;
    }
    first->next=NULL;//修改
    p = first;

    T a;
    int b;
    num = 0; highestdigit = 0;//修改
    while (cin >> a&&a != 0 && cin >> b){   //输入a=0时结束输入
        if (b >= highestdigit) highestdigit = b;
        ++num;
        p->next = new Node(a, b);
        p = p->next;
    }
    fflush(stdin);//修改
}

template<class T>
ostream& operator<<(ostream& out, Polynomial<T>& a)
{
    Polynomial<T>::Node *p = a.first->next;

    if (p == NULL) return out;//修改

    if (p->data.xishu == 0)cout << endl;//修改
    else{
        if (p->data.xishu != 1)
            out << p->data.xishu << "x^" << p->data.mi;
        else    out << "x^" << p->data.mi;
    }
    p = p->next;
    while (p)
    {
        out << '+';
        if (p->data.xishu != 1)
            out << p->data.xishu << "x^" << p->data.mi;
        else    out << "x^" << p->data.mi;
        p = p->next;
    }
    return out;
}

int main(){
    Polynomial<int> a, b, c,d;
    a.initial();
    cout << "a= " << a << endl;
    b.initial();
    cout << "b=" << b << endl;
    c = a + b;
    cout << "c=" << c << endl;
    d=a*b;
    cout<<"d="<<d<<endl;
    a.myfree();
    b.myfree();
    c.myfree();
    d.myfree();
    return 0;
}

运行结果：
计算器">

解决方案二：

多项式相加链表

解决方案三：

 #include<iostream>
using namespace std;

//约定稀疏多项式输入升幂排列
template<class T>class Polynomial;
template<class T>ostream& operator<<(ostream& out, Polynomial<T>&a);

template<class T>
class Polynomial
{
private:
    class Term
    {
    public:
        T xishu;
        int mi;
    };
    class Node
    {
    public:
        Term data;
        Node* next;
        Node(T x = 0, unsigned y = 0, Node* p = 0)
        {
            data.xishu = x;
            data.mi = y;
            next = p;//修改
        }
    };
public:
    Polynomial();
    void myfree();//释放链表所有各节点
    Polynomial<T>& operator=(const Polynomial<T>&);
    Polynomial<T> operator+(const Polynomial<T>&);
    Polynomial<T> operator*(const Polynomial<T>&);
    void initial();
    friend ostream& operator<< <T> (ostream& out, Polynomial<T>& a);

private:
    int highestdigit;
    Node* first;
    int num;//用来判断多项式有几项,即链表节点数,在乘法运算里也要用到
};
template<class T>
Polynomial<T>::Polynomial()
{
    first = new Node;
    num = 0;
    highestdigit = 0;
}

template<class T>
void Polynomial<T>::myfree()    //释放链表所有节点
{
    Node* p = first, *q;
    while (p)
    {
        q = p->next;
        delete p;
        p = q;
    }
    first=NULL;//修改
    num = 0; highestdigit = 0;//修改
}

template<class T>
Polynomial<T>& Polynomial<T>::operator=(const Polynomial<T>& second)
{
    myfree();
    highestdigit = second.highestdigit;
    num = second.num;
    first = second.first;

    return *this;
}

template<class T>
Polynomial<T> Polynomial<T>::operator+(const Polynomial<T>& second)
{
    Polynomial<T> sum;
    Node* pa = first->next, *pb = second.first->next, *pc = sum.first;
    while (pa&&pb)
    {
        if (pa->data.mi == pb->data.mi)  // 指数相等时
        {
            T x = pa->data.xishu + pb->data.xishu;
            if (x)     // 相加完的系数不为0时
            {
                pc->next = new Node(x, pa->data.mi);
                pc = pc->next;
                ++sum.num;
                if(sum.highestdigit<pa->data.mi) sum.highestdigit = pa->data.mi;
            }
            pa = pa->next;
            pb = pb->next;
        }
        else if (pa->data.mi > pb->data.mi){
            pc->next = new Node(pa->data.xishu, pa->data.mi);
            if(sum.highestdigit<pa->data.mi) sum.highestdigit = pa->data.mi;
            ++sum.num;
            pc = pc->next;
            pa = pa->next;
        }
        else{
            pc->next = new Node(pb->data.xishu, pb->data.mi);
            ++sum.num;
            if(sum.highestdigit<pb->data.mi) sum.highestdigit = pb->data.mi;
            pc = pc->next;
            pb = pb->next;
        }
    }
    while (pa){
        pc->next = new Node(pa->data.xishu, pa->data.mi);
        ++sum.num;
        if(sum.highestdigit<pa->data.mi) sum.highestdigit = pa->data.mi;
        pc = pc->next;
        pa = pa->next;
    }
    while (pb){
        pc->next = new Node(pb->data.xishu, pb->data.mi);
        ++sum.num;
        if(sum.highestdigit<pb->data.mi) sum.highestdigit = pb->data.mi;
        pc = pc->next;
        pb = pb->next;
    }
    return sum;
}
template<class T>
Polynomial<T> Polynomial<T>::operator*(const Polynomial<T>& second){
    Polynomial<T> multi, temp;
    Node* pa = first->next, *pb = second.first->next, * pt;

    if (num >= second.num){ //拿项数多的那个链表乘以项数少的那个
        while(pb){          //pb是项数少的那个，
            pt = temp.first;
            while (pa){     //项数多的开始遍历
                pt->next = new Node(pa->data.xishu*pb->data.xishu, pa->data.mi+pb->data.mi);//修改
                temp.num++;
                if( temp.highestdigit<pt->next->data.mi ) temp.highestdigit=pt->next->data.mi;
                pt = pt->next;
                pa = pa->next;
            }
            multi= temp+multi;
            temp.myfree();
            temp.first = new Node();
            pa = first->next;
            pb = pb->next;
        }
    }
    else{
        while(pa){
            pt = temp.first;
            while (pb){
                pt->next = new Node(pa->data.xishu*pb->data.xishu, pa->data.mi+pb->data.mi);//修改
                pt = pt->next;
                pb = pb->next;
            }
            multi = temp+multi;
            temp.myfree();
            temp.first = new Node();
            pb = first->next;//修改
            pa = pa->next;
        }
    }
    return multi;
}
template<class T>
void Polynomial<T>::initial()
{
    //释放链表，保留头节点
    Node* p = first->next, *q;
    while (p)
    {
        q = p->next;
        delete p;
        p = q;
    }
    first->next=NULL;//修改
    p = first;

    T a;
    int b;
    num = 0; highestdigit = 0;//修改
    while (cin >> a&&a != 0 && cin >> b){   //输入a=0时结束输入
        if (b >= highestdigit) highestdigit = b;
        ++num;
        p->next = new Node(a, b);
        p = p->next;
    }
    fflush(stdin);//修改
}

template<class T>
ostream& operator<<(ostream& out, Polynomial<T>& a)
{
    Polynomial<T>::Node *p = a.first->next;

    if (p == NULL) return out;//修改

    if (p->data.xishu == 0)cout << endl;//修改
    else{
        if (p->data.xishu != 1)
            out << p->data.xishu << "x^" << p->data.mi;
        else    out << "x^" << p->data.mi;
    }
    p = p->next;
    while (p)
    {
        out << '+';
        if (p->data.xishu != 1)
            out << p->data.xishu << "x^" << p->data.mi;
        else    out << "x^" << p->data.mi;
        p = p->next;
    }
    return out;
}

int main(){
    Polynomial<int> a, b, c,d;
    a.initial();
    cout << "a= " << a << endl;
    b.initial();
    cout << "b=" << b << endl;
    c = a + b;
    cout << "c=" << c << endl;
    d=a*b;
    cout<<"d="<<d<<endl;
    a.myfree();
    b.myfree();
    c.myfree();
    d.myfree();
    return 0;
}

运行结果：

解决方案四：

#include
using namespace std;

//约定稀疏多项式输入升幂排列
templateclass Polynomial;
templateostream& operator<<(ostream& out, Polynomial&a);

template
class Polynomial
{
private:
class Term
{
public:
T xishu;
int mi;
};
class Node
{
public:
Term data;
Node* next;
Node(T x = 0, unsigned y = 0, Node* p = 0)
{
data.xishu = x;
data.mi = y;
next = p;//修改
}
};
public:
Polynomial();
void myfree();//释放链表所有各节点
Polynomial& operator=(const Polynomial&);
Polynomial operator+(const Polynomial&);
Polynomial operator*(const Polynomial&);
void initial();
friend ostream& operator<< (ostream& out, Polynomial& a);

private:
int highestdigit;
Node* first;
int num;//用来判断多项式有几项,即链表节点数,在乘法运算里也要用到
};
template
Polynomial::Polynomial()
{
first = new Node;
num = 0;
highestdigit = 0;
}

template
void Polynomial::myfree() //释放链表所有节点
{
Node* p = first, *q;
while (p)
{
q = p->next;
delete p;
p = q;
}
first=NULL;//修改
num = 0; highestdigit = 0;//修改
}

template
Polynomial& Polynomial::operator=(const Polynomial& second)
{
myfree();
highestdigit = second.highestdigit;
num = second.num;
first = second.first;

return *this;

}

template
Polynomial Polynomial::operator+(const Polynomial& second)
{
Polynomial sum;
Node* pa = first->next, pb = second.first->next, *pc = sum.first;
while (pa&&pb)
{
if (pa->data.mi == pb->data.mi) // 指数相等时

{
T x = pa->data.xishu + pb->data.xishu;
if (x) // 相加完的系数不为0时

{
pc->next = new Node(x, pa->data.mi);
pc = pc->next;
++sum.num;
if(sum.highestdigitdata.mi) sum.highestdigit = pa->data.mi;
}
pa = pa->next;
pb = pb->next;
}
else if (pa->data.mi > pb->data.mi){
pc->next = new Node(pa->data.xishu, pa->data.mi);
if(sum.highestdigitdata.mi) sum.highestdigit = pa->data.mi;
++sum.num;
pc = pc->next;
pa = pa->next;
}
else{
pc->next = new Node(pb->data.xishu, pb->data.mi);
++sum.num;
if(sum.highestdigitdata.mi) sum.highestdigit = pb->data.mi;
pc = pc->next;
pb = pb->next;
}
}
while (pa){
pc->next = new Node(pa->data.xishu, pa->data.mi);
++sum.num;
if(sum.highestdigitdata.mi) sum.highestdigit = pa->data.mi;
pc = pc->next;
pa = pa->next;
}
while (pb){
pc->next = new Node(pb->data.xishu, pb->data.mi);
++sum.num;
if(sum.highestdigitdata.mi) sum.highestdigit = pb->data.mi;
pc = pc->next;
pb = pb->next;
}
return sum;
}
template
Polynomial Polynomial::operator(const Polynomial& second){
Polynomial multi, temp;
Node* pa = first->next, *pb = second.first->next, * pt;

if (num >= second.num){ //拿项数多的那个链表乘以项数少的那个
    while(pb){          //pb是项数少的那个，
        pt = temp.first;
        while (pa){     //项数多的开始遍历
            pt->next = new Node(pa->data.xishu*pb->data.xishu, pa->data.mi+pb->data.mi);//修改
            temp.num++;
            if( temp.highestdigit<pt->next->data.mi ) temp.highestdigit=pt->next->data.mi;
            pt = pt->next;
            pa = pa->next;
        }
        multi= temp+multi;
        temp.myfree();
        temp.first = new Node();
        pa = first->next;
        pb = pb->next;
    }
}
else{
    while(pa){
        pt = temp.first;
        while (pb){
            pt->next = new Node(pa->data.xishu*pb->data.xishu, pa->data.mi+pb->data.mi);//修改
            pt = pt->next;
            pb = pb->next;
        }
        multi = temp+multi;
        temp.myfree();
        temp.first = new Node();
        pb = first->next;//修改
        pa = pa->next;
    }
}
return multi;

}
template
void Polynomial::initial()
{
//释放链表，保留头节点
Node* p = first->next, *q;
while (p)
{
q = p->next;
delete p;
p = q;
}
first->next=NULL;//修改
p = first;

T a;
int b;
num = 0; highestdigit = 0;//修改
while (cin >> a&&a != 0 && cin >> b){   //输入a=0时结束输入
    if (b >= highestdigit) highestdigit = b;
    ++num;
    p->next = new Node(a, b);
    p = p->next;
}
fflush(stdin);//修改

}

template
ostream& operator<<(ostream& out, Polynomial& a)
{
Polynomial::Node *p = a.first->next;

if (p == NULL) return out;//修改

if (p->data.xishu == 0)cout << endl;//修改
else{
    if (p->data.xishu != 1)
        out << p->data.xishu << "x^" << p->data.mi;
    else    out << "x^" << p->data.mi;
}
p = p->next;
while (p)
{
    out << '+';
    if (p->data.xishu != 1)
        out << p->data.xishu << "x^" << p->data.mi;
    else    out << "x^" << p->data.mi;
    p = p->next;
}
return out;

}

int main(){
Polynomial a, b, c,d;
a.initial();
cout << "a= " << a << endl;
b.initial();
cout << "b=" << b << endl;
c = a + b;
cout << "c=" << c << endl;
d=a*b;
cout<<"d="<<d<<endl;
a.myfree();
b.myfree();
c.myfree();
d.myfree();
return 0;
}
运行结果：
图片说明

时间： 2024-04-18 02:13:54

测试-稀疏多项式C++链表的问题的相关文章

c++-稀疏多项式C++链表的问题

问题描述 稀疏多项式C++链表的问题 #include<iostream> using namespace std; #ifndef POLYNOMIAL_H #define POLYNOMIAL_H template<class T>class Polynomial; template<class T>ostream& operator<<(ostream& out, Polynomial<T>&a ); templat

数据结构 单链表-关于稀疏多项式的创建

问题描述 关于稀疏多项式的创建 算法描述如图,但是不知道这个q的作用,求大神详细解答一下. 解决方案 i=0时: pre=P;//此时pre指针指向头结点 q=P->next;//q被赋值成NULL while(....)//不满足 s->next=q;//将新插入的节点的next指针指向q,也就是被赋值成NULL了 pre->next=s;//让头结点的next指针指向了新插入的节点s i=1时: pre=P;//此时pre指针还是指向头结点 q=P->next;//q指向了第一

c语言-一元稀疏多项式计算器

问题描述 一元稀疏多项式计算器 用c语言写一个一元稀疏多项式的计算器,加减乘除,怎么写?还要用到节点什么的,是数据结构的题目 解决方案 http://wenku.baidu.com/link?url=AM6e0AkKQSuxfiL02xfKyEc-_PHhbKzn8Bo9ltCbZgk0E92ShNgAq-Al1Dvc1QzELF1zuVp5IRWaZqXB1Y5grxcGmgeBU3vW6nMlKLVX4aahttp://download.csdn.net/detail/ganshaolong

数据结构实践项目——链表

本组项目针对<数据结构基础系列(2):线性表>课程第8-15节 8. 线性表的链式存储 9. 建立单链表 10. 单链表基本操作的实现 11. 单链表应用举例 12. 双链表 13. 循环链表 14. 线性表的应用 15. 有序表 [项目1 - 建立单链表] 定义单链表存储结构,用头插法和尾插法建立单链表,并显示建立好以后的结果. 请在下面代码的基础上开展工作: #include <stdio.h> #include <malloc.h> typedef int Ele

2014秋C++第19周 项目1参考 动态链表体验

课程主页在http://blog.csdn.net/sxhelijian/article/details/39152703,课程资源在云学堂"贺老师课堂"同步展示,使用的帐号请到课程主页中查看.  [项目1 - 动态链表体验] 下面是一个建立动态链表的程序.阅读程序,在草稿纸上画出链表建立的过程,借此学会如何建立链表.然后按要求改造程序. #include <iostream> using namespace std; struct Node { int data; //结

java类的问题-java数据结构，线性表操作，C(X)=A(X)+B(X)多项式想加

问题描述 java数据结构,线性表操作,C(X)=A(X)+B(X)多项式想加 C(X)=A(X)+B(X)多项式想加.PolySLinkedList类增加C(X)=A(X)+B(X)多项式想加功能,算法实现不依赖于深拷贝,将A和B两条多项式单链表中的所以结点相加合并到新建的C多项式单链表,不改变A和B多项式单链表

《C语言及程序设计》实践参考——改造链表

返回:贺老师课程教学链接 [项目3 - 改造链表] 下面是一个建立动态链表的程序.阅读程序,然后按要求改造程序. #include <iostream> using namespace std; #include <stdio.h> #include <malloc.h> #define N 5 typedef struct NODE { int data; //结点的数据 struct NODE *next; //指向下一结点 } Node; Node *head=N

《数据结构与算法 C语言版》—— 2.3线性表的链式表示与实现

2.3线性表的链式表示与实现 线性表的顺序存储结构的特点是逻辑关系上相邻的两个元素在物理位置上也相邻,因此可以随机存取表中任一元素,它的存储位置可用一个简单.直观的公式来表示.然而,从另一方面来看,这个特点也造成了这种存储结构的弱点:在作插入或删除操作时,需移动大量元素.本节我们将讨论线性表的另一种表示方法--链式存储结构,其特点是用一组地址任意的存储单元存储线性表中的数据元素.由于它不要求逻辑上相邻的元素在物理位置上也相邻,因此它没有顺序存储结构所具有的弱点,但同时也失去了顺序表随机存取的特点

虚拟键盘-JavaScript怎样实现咋键盘上按下不同的键，页面上不同的div调用同一个css样式

问题描述 JavaScript怎样实现咋键盘上按下不同的键,页面上不同的div调用同一个css样式 这是页面上的一个虚拟键盘,我想实现的是当我在电脑的键盘上按键后,虚拟键盘上的相对应的键会有不同的显示效果(调用一个css)(虚拟键盘上的每一个小键都是一个图片),就是当我按下不同的按键,页面上相对的键所在的div就会调用同一个css 解决方案 虚拟键盘上的每个控件都增加keycode属性,然后document.onkeydown获取时间的keycode属性后获取控件添加个样式,过100ms再移除什