精华内容
下载资源
问答
  • OpenStack存储管理功能介绍 技术创新变革未来 前言 OpenStack提供多种类型的存储服务用户可以根据业务需求自由选择存储服 务 本章节重点介绍OpenStack中的块存储服务Cinder 简单介绍对象存储服务Swift 本章节分为两...
  • 下列不能用作存储容量单位的是

    千次阅读 2020-03-05 20:25:11
    下列不能用作存储容量单位的是 A) Byte B) KB C) MIPS D) GB c 存储容量单位是Byte、KB、MB、GB、TB,而MIPS是运算速度单位。

    下列不能用作存储容量单位的是

    A) Byte
    B) KB
    C) MIPS
    D) GB

    c

    存储容量单位是Byte、KB、MB、GB、TB,而MIPS是运算速度单位。

    展开全文
  • 问题抛出:利用广义表解决下列多项式的存储问题实验内容 实验4 用广义表表示和存储m元多项式一个m元多项式的每一项,最多有m个变元。如果用线性表来表示,则每个数据元素需要m+1个数据项,以存储一个系数值和m个...

    问题抛出:利用广义表解决下列多项式的存储问题


    实验内容
    实验4 用广义表表示和存储m元多项式

    一个m元多项式的每一项,最多有m个变元。如果用线性表来表示,则每个数据元素需要m+1个数据项,以存储一个系数值和m个指数值。这将产生两个问题,一是无论多项式中各项的变元数是多是少,若都按m个变元分配存储空间,将造成浪费;反之,若按各项实际的变元数分配存储空间,就会造成结点的大小不匀,给操作带来不便。二是对m值不同的多项式,线性表中的结点大小也不同,这同样会引起存储管理的不便。因此,m元多项式不适于用线性表表示和存储。
    任何一个m元多项式都可先分解出一个主变元,随后再分解出第二个变元,等等。由此,一个m元的多项式首先是它的主变元的多项式,而其系数又是第二变元的多项式,由此可用广义表来表示m元多项式。如

    x^10 * y^3 * z^2 + 2 * x^6 * y^3 * z^2 + 3 * x^5 * y^2 * z^2 + x^4 * y^4 * z + 6 * x^3 * y^4 * z + 2 * y * z + 15

    可表示为

    (( x^10 + 2 * x^6 ) y^3 + 3 * x^5 * y^2 ) * z^2 + (( x^4 + 6 * x^3 ) * y^4 + 2 * y ) * z + 15

    要求:
    1、 用广义表设计实现多项式类,存储和表示m元多项式;
    2、 实现两个多项式的相加;
    3、 求取多项式是几元多项式,以及多项式的次数、项数。

    注意:
    1) m元多项式的输入和输出格式为

    (( x^10 + 2 * x^5 ) y^3 + 3 * x^5 * y^2 ) * z^2 + (( x^4 + 6 * x^3 ) * y^4 + 2 * y ) * z + 15

    2) 次数和项数输出格式为

    3元多项式次数:3
    3元多项式项数:3

    3) 提交源代码必须包含测试代码。


    《数据结构》(殷人昆)有关于广义表部分内容源码

    广义表的基本类定义及其具体函数的实现

    GenList.h

    #ifndef GENLIST_H
    #define GENLIST_H
    #include <iostream>
    #include <cassert>
    #include <cstdlib>
    #include "SeqList.h"
    // 广义表结点的类结构定义
    template <typename T>class GenListNode{
    public:
        int utype;                  // =0/1/2
        int mark;                   // 访问标记
        GenListNode<T> *tlink;      // 指向同一层下一个结点的指针
        union{
            int ref;                // utype=0: 表头,存放引用计数
            T value;                // utype=1: 元素,存放原子结点数值
            GenListNode<T> *hlink;  // utype=2: 子表,存放子表头指针
        }info;
        GenListNode(){
            mark = 0;
            utype = 0;
            tlink = NULL;
            info.ref = 0;
        }
        GenListNode(GenListNode<T> &RL) {
            mark = RL.mark;         //复制构造函数
            utype = RL.utype;
            tlink = RL.tlink;
            info = RL.info;
        }
    };
    
    // 广义表返回值的类结构定义
    template <typename T>class Items{
    public:
        int utype;                  // =0/1/2
        int mark;                   // 访问标记
        union{
            int ref;                // utype=0: 表头,存放引用计数
            T value;                // utype=1: 元素,存放数值
            GenListNode<T> *hlink;  // utype=2: 子表,存放子表头指针
        }info;
        Items(){                    //构造函数
            utype = 0;
            mark = 0;
        }
        Items(Items<T> &RL){
            utype = RL.utype;
            mark = RL.mark;
            info = RL.info;
        }
    };
    
    // 广义表类的定义
    template <typename T>class GenList{
    public:
        GenList();
        ~GenList();
        bool Head(Items<T> &x);              //返回表头元素x
        bool Tail(GenList<T> &lt);           //返回表尾,除了首元素以外剩下的元素
        GenListNode<T> *First();
        GenListNode<T> *Next(GenListNode<T> *elem);
        void Copy(const GenList<T> &R);      //广义表的复制
        int Length();                        //计算广义表的长度
        int depth();                         //计算非递归表的深度
        void delvalue(const T &x);
        void Print(ostream &out = cout) {Print(first, out);}
        bool equal(GenList<T>& t){
            return equal(first,t.first);
        }
        friend istream& operator >> (istream &in, GenList<T> &L){
            SeqList<T> Ls1;
            SeqList<GenListNode<T> *> Ls2;
            L.CreateList (in, L.first, Ls1, Ls2);   //建立存储结构
            GenListNode<T> *p = L.first;            //删除广义表头部多出来的子表结点
            L.first = L.first->info.hlink;
            delete p;
            return in;
        }
        friend ostream& operator << (ostream &out, GenList<T> &L){
            L.Print(out);
            return out;
        }
    private:
        GenListNode<T> *first;                      //头指针
        GenListNode<T> *Copy(GenListNode<T> *ls);   //复制一个ls指示的无共享非递归表
        int Length(GenListNode<T> *ls);             //求广义表的长度
        int depth(GenListNode<T> *ls);              //求广义表的深度
        bool equal(GenListNode<T> *s, GenListNode<T> *t);//判断s和t指示的广义表是否相等
        void delvalue(GenListNode<T> *ls, const T &x);  //删除含定值x的结点
        void Remove(GenListNode<T> *ls);                 //释放以ls为附加头结点的广义表
        void Print(GenListNode<T>* p, ostream &out);  //实现广义表的整体输出
        void CreateList(istream &in, GenListNode<T> *& ls,//利用输入流中已知的字符串建立一个广义表
                SeqList<T> &L1, SeqList <GenListNode<T> *> &L2);
    };
    
    template <typename T>GenList<T>::GenList(){    //构造函数,创建一个起始结点@
        first = new GenListNode<T>;
        assert(first);
    }
    
    template <typename T>GenList<T>::~GenList(){   //析构函数~Genlist()调用函数Remove(GenListNode<T>);
        Remove(first);
    }
    
    template <typename T>bool GenList<T>::Head(Items<T> &x){//返回表头元素值,只需返回标记以及信息域的值即可
        if (first!=NULL){
            x.utype = first->tlink->utype;
            x.info = first->tlink->info;
            return true;
        }
        else    return false;
    }
    
    template <typename T>bool GenList<T>::Tail(GenList<T> &lt){//返回表尾
        if (first->tlink!=NULL){
            lt.first->utype = 0;
            lt.first->info.ref = 0;
            lt.first->tlink = Copy(first->tlink->tlink);
            return true;
        }
        else    return false;
    }
    
    template <typename T>GenListNode<T> *GenList<T>::First(){//返回第一个元素的地址
        return first->tlink;
    }
    
    template <typename T>GenListNode<T> *GenList<T>::Next(GenListNode<T> *elem){//返回直接后继元素的地址
        return elem->tlink;
    }
    
    template <typename T>
    void GenList<T>::Copy(const GenList<T> &R){//广义表复制,函数的形参为一个广义表的子表
        first = Copy(R.first);                 //调用另一个Copy()函数,将广义表R复制给调用该函数的广义表
    }
    
    template <typename T>GenListNode<T>* GenList<T>::Copy(GenListNode<T> *ls){//副本实际未共享,但ref标识不变,equal()判相同,Remove()因ref>1漏删
        GenListNode<T> *q = NULL;                                             //函数的形参为一个指向广义表结点的指针
        if (ls!=NULL){ //if(ls==NULL)递归调用的终止条件
            q = new GenListNode<T>;
            q->utype = ls->utype;
            switch (ls->utype){
            case 0:
                q->info.ref = ls->info.ref;
                break;
            case 1:
                q->info.value = ls->info.value;cout<<q->info.value<<endl;
                break;
            case 2:
                q->info.hlink = Copy(ls->info.hlink);//下一层:递归调用Copy(GenListNode<T> *ls)实现子表的复制
                break;
            }
            q->tlink = Copy(ls->tlink);//同一层:复制q的后继结点
        }
        return q; //最后返回的q为复制后所得的广义表的头指针
    }
    
    template <typename T>int GenList<T>::Length(){//广义表长度,即求第一层次所含有的元素的个数
        return Length(first)-1;                   //嵌套调用Length()调用Length(GenListNode<T>)函数
    }
    
    template <typename T>int GenList<T>::Length(GenListNode<T> *ls){
        return (ls == NULL)?0:(1+Length(ls->tlink));//利用递归算法,在同一层元素中沿着tlink向后压栈求解广义表的长度
    }
    
    template <typename T>int GenList<T>::depth(){   //嵌套调用depth()调用depth(GenListNode<T>)函数
        return depth(first);
    }
    
    template <typename T>int GenList<T>::depth(GenListNode<T> *ls){//广义表深度:从广义表的最深处开始往上求解广义表的深度
        if (ls==NULL){                                             //递归调用栈中每一次调用函数时m为每一个被调用的函数的局部变量
            return 1;                                              //m每一次的值通过return m+1语句建立联系
        }
        GenListNode<T> *temp = ls->tlink;//temp为当前指针
        int m = 0, n;
        while (temp!=NULL){
            if (temp->utype == 2){//当标记为子表类型时
                n = depth(temp->info.hlink);//利用递归算法求解子表的深度
                if (m < n){//m用于记录当前所查找完的广义表的深度
                    m = n;//m用于记录同层所查到的广义表的子表的最大深度
                }
            }
            temp = temp->tlink;//查找同一层的下一个元素
        }
        return m+1;//该层元素已经查找完,跳回到上一层的元素当中进行查找
    }
    
    template <typename T>bool GenList<T>:: equal(GenListNode<T> *s, GenListNode<T> *t){//广义表是否相等,不适用共享表副本
        bool x;
        if (s->tlink == NULL && t->tlink == NULL)   return true;//两个表均为空表,相等返回true
        if (s->tlink!=NULL && t->tlink!=NULL && s->tlink->utype == t->tlink->utype) {//均为非空表,且第一个元素的信息域类型相同
            if (s->tlink->utype == 0){//信息域为头指针
                if(s->tlink->info.ref== t->tlink->info.ref) x=true;
                else x=false;
            }
            if (s->tlink->utype == 1){//信息域为原子类型
                x = (s->tlink->info.value == t->tlink->info.value)?true:false;
            }
            if (s->tlink->utype == 2){//信息域为子表类型
                x = equal(s->tlink->info.hlink, t->tlink->info.hlink);//利用递归(向深处递归)判断子表是否相等
            }
    
            if (x!=0)   {//前面所进行的Remove(GenListNode<T> *ls)操作(第一层的第一个元素)过程两个表均相等
                return equal(s->tlink, t->tlink);//(向后递归)判断后续结点对应的元素是否相等
            }
        }
        return false;
    }
    
    template <typename T>void GenList<T>::delvalue(const T &x){//删除含定值x的结点
        delvalue(first, x);     //利用函数delvalue(const T &x)调用函数delvalue(GenListNode<T> *ls, const T &x)
    }
    template <typename T>void GenList<T>::delvalue(GenListNode<T> *ls, const T &x){
        if (ls->tlink!=NULL)    {//递归的终止条件,到了该层的最后一个结点
            GenListNode<T> *p = ls->tlink;//p指向ls所指的下一个元素
            while (p!=NULL && (p->utype == 1 && p->info.value == x)){
                cout<<p->info.value;
                ls->tlink = p->tlink;
                delete p;
                p = ls->tlink;
            }
            if (p!=NULL){
                if (p->utype == 2){//当p所指的结点存在子表时
                    cout<<'#'<<endl;
                    delvalue(p->info.hlink, x);//进入下一层次
                }
                delvalue(p, x);//当p所指的结点不存在子表时,由本结点开始向着同一层的尾指针向后搜索
            }
        }
    }
    
    template <typename T>void GenList<T>::Remove(GenListNode<T> *ls){//删除指定子表,不适用共享表副本
        ls->info.ref--;                                          ///疑问:如果调用一次Remove(GenListNode<T> *ls)函数那么引用计数-1
        if (ls->info.ref <= 0){                                  ///那么,当引用计数仍不为0时就不进行任何操作,怎么知道-1之后是撤
            GenListNode<T> *q;                                   ///销了哪一个子表对其的引用?
            while (ls->tlink){
                q = ls->tlink;
                if (q->utype == 2){
                    Remove(q->info.hlink);
                    if (q->info.hlink->info.ref <= 0){
                        delete q->info.hlink;
                    }
                }
                ls->tlink = q->tlink;
                delete q;
            }
        }
    }
    ///********************************************有 ******************************************//
    ///*********************************************待 ******************************************//
    ///********************************************* 解 ******************************************//
    ///*********************************************  决******************************************//
    // 从广义表的字符串描述s出发, 建立一个带头结点的广义表,要求T为char型。
    // 在表L1存储大写字母的表名, 在表L2存储表名对应子表结点的地址。
    template <typename T>void GenList<T>::CreateList(istream& in, GenListNode<T> *& ls,
                SeqList<T> &L1, SeqList <GenListNode<T> *> &L2){
        T chr;
        in >> chr;  //以 D(B(a,b),C(u,(x,y,z),B),A(#)) 为例
        cout<<chr;
        //读入一个字符,只可能读入#、左括号和字母
        if (isalpha(chr) && isupper(chr) || chr == '('){ //大写字母或'('
            bool b=true;
            ls = new GenListNode<T>;          //建子表结点
            cout<<'&';
            ls->utype = 2;
            if (isalpha(chr) && isupper(chr)){ //表名处理,有名子表
                int n = L1.Length();
                int m = L1.Search(chr);
                if (m != 0){                  //该表已建立
                    b=false;                  //共享
                    ls->info.hlink = *L2.getData(m);//查子表地址
                    ls->info.hlink->info.ref++;     //引用计数加1
                    cout<<'@';
                    in >> chr;
                    if (chr != '('&&chr!=','&&chr != ')') exit(1);  //表名后必跟'('或','或')'
                    if(chr=='(')
                        do{
                            in>>chr; //共享表可以只输入表名,其它内容程序忽略
                        }while(chr!=')');
                    else if(chr==','||chr == ')') in.putback(chr);//逗号或')'送回缓冲区
                }
                else{       //该表未建立
                    ls->info.hlink = new GenListNode<T>;         //建附加头结点
                    L1.Insert(n, chr);                           //保存表名及地址
                    L2.Insert(n, ls->info.hlink);
                    in >> chr;
                    cout<<chr;
                    cout<<'%';
                    ls->info.hlink->utype = 0;
                    ls->info.hlink->info.ref = 1;
                    if (chr != '(') exit(1);    //表名后必跟'('
                    CreateList(in, ls->info.hlink->tlink, L1, L2);//递归建子表
                }
            }
            else{//无名子表
                ls->info.hlink = new GenListNode<T>;
                cout<<'%';
                ls->info.hlink->utype = 0;         //建头结点
                ls->info.hlink->info.ref = 1;
                CreateList(in, ls->info.hlink->tlink, L1, L2);//递归建子表
            }
            CreateList(in, ls, L1, L2);                   //递归建后继表
        }
        else if (isalpha(chr) && islower(chr)){ //建原子结点。本程序现在仅在T为char时有效
                ls = new GenListNode<T>;
                cout<<'*';
                ls->utype = 1;
                ls->info.value = chr;//这里应该有将字符与T类型具体数据一一对应的表,最终把具体数据存入info.value
                CreateList(in, ls, L1, L2);
            }
        else if (chr == ','){       //建后继结点
                if (ls->tlink) delete ls->tlink;
                ls->tlink = new GenListNode<T>;
                CreateList(in, ls->tlink, L1, L2);
            }
        else if (chr == ')')    ls->tlink = NULL;  //链收尾
        else if (chr == '#')    ls = NULL; //空表, 链收尾
    }
    
    //打印数据
    template<typename T>
    void GenList<T>::Print(GenListNode<T>* p, ostream &out){ //共用一个out,out可以看作是一个全局变量
        if (p==NULL)
            return;                           //p为NULL结束
        if (p->utype==1)                      //原子结点
            out << (p->info).value << "   ";   //输出原子结点内的value的值
        else if (p->utype == 0)               //附加表头结点
                while (p->tlink!=NULL){           //关注此句,因为无返回指针,必须由while显式循环
                    Print(p->tlink, out);         //以循环来代替通过返回值进行递归的操作
                    p=p->tlink;               //返回指向同一层的下一个结点
                }
            else    Print(p->info.hlink, out);//子表结点
    }
    
    #endif
    

    顺序表的相关头文件

    SeqList.h

    #ifndef SEQLIST_H
    #define SEQLIST_H
    
    #include <iostream>
    #include <cstdlib>
    #include <cassert>
    using namespace std;
    
    const int defaultSize = 100;
    
    template <typename T>class SeqList
    {
    protected:
        T *data;
        int maxSize;
        int last;
    public:
        SeqList(int sz = defaultSize);
        SeqList(SeqList<T> &L);
        ~SeqList(){
            delete []data;
        }
        void reSize(int newSize);
        int Size() const{
            return maxSize;
        }
        int Length()const{
            return last+1;
        }
        int Search(T &x) const;
        int Locate(int i) const;
        T* getData(int i) const{
            return (i>0 && i<=last+1)?&data[i-1]:NULL;
        }
        void setData(int i, T &x){
            if (i>0 && i<=last+1){
                data[i-1] = x;
            }
        }
        bool Insert(int i, T &x);
        bool Remove(int i, T &x);
        bool IsEmpty(){
            return (last == -1);
        }
        bool IsFull(){
            return (last == maxSize-1);
        }
        void Sort();
        void input();
        void output();
        SeqList<T> operator = (SeqList<T> &L);
        friend istream& operator >> (istream &in, SeqList<T> &R)    {
            R.last = -1;
            while (!in.eof()){
                R.last++;
                if (R.last == R.maxSize){
                    R.reSize(2*R.maxSize);
                }
                assert(in >> R.data[R.last]);
            }
            return in;
        }
        friend ostream& operator << (ostream &out, SeqList<T> &R){
            for (int i = 0; i <= R.last; i++){
                cout << "#" << i+1 << ":\t" << R.data[i] << endl;
            }
            return out;
        }
    };
    
    template <typename T>SeqList<T>::SeqList(int sz){
        if (sz > 0){
            maxSize = sz;
            last = -1;
            data = new T[maxSize];
            if (data == NULL){
                cerr << "Memory allocating error!" << endl;
                exit(1);
            }
        }
    }
    
    template <typename T>SeqList<T>::SeqList(SeqList<T> &L){
        maxSize = L.Size();
        last = L.Length() - 1;
        data = new T[maxSize];
        if (data == NULL){
            cerr << "Memory allocating error!" << endl;
            exit(1);
        }
        for (int i = 1; i <= last+1; i++){
            data[i-1] = *(L.getData(i));
        }
    }
    
    template<typename T>void SeqList<T>::reSize(int newSize){
        if (newSize <= 0){
            cerr << "Invalid array index!" << endl;
            return;
        }
        if (newSize != maxSize){
            T *newarray = new T[newSize];
            if (newarray == NULL){
                cerr << "Memory allocating error!" << endl;
                exit(1);
            }
            int n = last + 1;
            T *srcptr = data;
            T *destptr = newarray;
            while (n--){
                *destptr++ = *srcptr++;
            }
            delete []data;
            data = newarray;
            maxSize = newSize;
        }
    }
    
    template<typename T>int SeqList<T>::Search(T &x)const{
        for (int i = 0; i <= last; i++){
            if (data[i] == x){
                return i+1;
            }
        }
        return 0;
    }
    
    template<typename T>int SeqList<T>::Locate(int i)const{
        if (i >= 1 && i <= last+1){
            return i;
        }
        else    return 0;
    }
    
    template<typename T>bool SeqList<T>::Insert(int i, T &x){
        if (last == maxSize-1)  return false;
        if (i < 0 || i > last+1) return false;
        for (int j = last; j >= i; j--)     data[j+1] = data[j];
        data[i] = x;
        last++;
        return true;
    }
    
    template<typename T>bool SeqList<T>::Remove(int i, T &x){
        if (last == -1){
            return false;
        }
        if (i < 1 || i > last+1){
            return false;
        }
        x = data[i-1];
        for (int j = i; j <= last; j++){
            data[j-1] = data[j];
        }
        last--;
        return true;
    }
    
    template<typename T>void SeqList<T>::Sort(){
        for (int i = 1; i <= last; i++){
            for (int j = last; j >= i; j--){
                if (data[j-1] > data[j]){
                    T tmp = data[j-1];
                    data[j-1] = data[j];
                    data[j] = tmp;
                }
            }
        }
    }
    
    template<typename T>void SeqList<T>::input(){
        cout << "Input the size of the list which will be created:";
        while (1){
            assert(cin >> last);
            last--;
            if (last < 0){
                cout << "Input error, the size must be positive!\n";
                cout << "Input the size again:";
            }
            else if (last > maxSize-1){
                cout << "Input error, the size must be less than maxSize!\n";
                cout << "Input the size again:";
            }
            else    break;
        }
        cout << "\nInput the data for each element to create the list:" << endl;
        for (int i = 0; i <= last; i++){
            cout << "#" << i+1 << ":";
            assert(cin >> data[i]);
        }
    }
    
    template<typename T>void SeqList<T>::output(){
        cout << "\nThe size of the list is:" << last+1 << endl;
        for (int i = 0; i <= last; i++){
            cout << "#" << i+1 << ":\t" << data[i] << endl;
        }
    }
    
    template<typename T>SeqList<T> SeqList<T>::operator = (SeqList<T> &L){
        maxSize = L.Size();
        last = L.Length()-1;
        data = new T[maxSize];
        if (data == NULL){
            cerr << "Memory allocating error!" << endl;
            exit(1);
        }
        for (int i = 1; i <= last+1; i++){
            data[i-1] = L.getData(i);
        }
    }
    
    #endif
    

    main.cpp测试函数

    #include "GenList.h"
    #include <fstream>
    #include <string>
    #include <cassert>
    using namespace std;
    #include<iostream>
    int main(){
        ifstream fin1("data.txt");
        assert(fin1);
        string str;
        fin1 >> str;
        cout << "The genlist in the file is: \n" << str << endl;
        GenList<char> gl1;
        fin1.close();
        ifstream fin("data.txt");
        assert(fin);
        fin >> gl1;
        cout << "\nSome information about Genlist gl1:\n";
        cout << "\nThe data of GenList is:" << endl;
        cout << gl1 << endl;
    
        cout << "\nThe depth of the GenList is: " << gl1.depth() << endl;
        cout << "The length of the GenList is: " << gl1.Length() << endl;
    
        cout << "The First Element is: ";
        int temp = 0;
        if (gl1.First()){
            temp = gl1.First()->utype;
            if (temp == 1){
                cout << "AtomNode: " << gl1.First()->info.value << endl;
            }
            else if (temp == 0){
                cout << "HeadNode." << endl;
            }
            else{
                cout << "SubListNode." << endl;
            }
        }
        else{
            cout << "NULL!" << endl;
        }
    
        cout << "The Second Element is: ";
        if (gl1.Next(gl1.First())){
            temp = gl1.Next(gl1.First())->utype;
            if (temp == 1){
                cout << "AtomNode: " << gl1.First()->info.value << endl;
            }
            else if (temp == 0){
                cout << "HeadNode! " << endl;
            }
            else{
                cout << "SubListNode!" << endl;
            }
        }
        else{
            cout << "NULL!" << endl;
        }
    
    //  GenList<char> gl2(gl1);//浅复制
        GenList<char> gl2;
        gl2.Copy(gl1);
        cout << "\ngl2 is a copy of gl1:\n";
        cout << "The data of gl2 is: " << endl;
        cout << gl2 << endl;
    
        if(gl1.equal(gl2)) cout<<"gl1 equals gl2.";
        else cout<<"gl1 do not equals gl2.";
    
        char rem;
        cout << "\nInput the data that you want to Remove: " << endl;
        cin >> rem;
        gl2.delvalue(rem);
        cout << "The current GenList gl2 is: " << endl;
        cout << gl2<< endl;
    
        cout << "\nInput the data that you want to Remove: " << endl;
        cin >> rem;
        gl1.delvalue(rem);
        cout << "The current GenList gl1 is: " << endl;
        cout << gl1<< endl;
        return 0;
    }
    

    今天对广义表的基本类定义以及函数的实现进行了统一的源码阅读,并标注了相应的注释,
    主要收获是理解了一些和递归相关的问题。但还有一个最为重要的函数没有看懂CreateGenList()
    函数,这个问题留着下一次解决
    下一次将会对上面所抛出的实验问题进行代码的实行。
    2017/4/23/ 11:47
    问题的解决未完—-待续

    展开全文
  • 下列( )与数据的存储结构无关的是 A栈 B双向链表 C散列表 D线索树 E循环队列 答案A 栈 是逻辑结构 线性表 加了点约束 双向链表 链表 就是存储结构的体现 散列表 顺序存储结构的扩展 线索树 建立在二叉链表的存储...

    下列( )与数据的存储结构无关的是
    A栈
    B双向链表
    C散列表
    D线索树
    E循环队列

    答案A

    栈 是逻辑结构 线性表 加了点约束

    双向链表 链表 就是存储结构的体现

    散列表 顺序存储结构的扩展

    线索树 建立在二叉链表的存储结构

    循环队列 建立在顺序存储结构的队列

    展开全文
  • 在Collection中存储一个元素,满足下列条件:不重复存储存储元素可以按照自然顺序取到。那么我们需要选择哪个接口作为存储类型?() A、java.util.Map B、java.util.Set C、java.util.List D、java.util....

    题目:

    在Collection中存储一个元素,满足下列条件:不重复存储,存储元素可以按照自然顺序取到。那么我们需要选择哪个接口作为存储类型?()

    A、java.util.Map

    B、java.util.Set

    C、java.util.List

    D、java.util.SortedSet

    E、java.util.SortedMap

    F、java.util.Collection

    答案:D

    解释:

    A:Map接口的键不重复,但是值可以重复,但是元素存储无序,A错误

    B:Set接口里面存储的值确实不重复,但是元素存储无序,B错误

    C:List接口里面存储的值可以重复,存储顺序和插入顺序一致,不会按照自然顺序排序,C错误

    D:SortedSet接口作为存储类型可以确保元素处于排序状态,并且满足下列条件:不重复排序、存储元素可以按照自然顺序取到(首先自然数是0、1、2……,所以自然顺序就是升序排序),D正确

    E:SortedMap接口可以根据键排序,键也不会重复,但是值会重复,存储元素可以按照键的自然顺序取到,E错误

    F:Collection接口不会排序,可以重复存储,F错误

    展开全文
  • 存储过程的应用程序具有下列优点

    千次阅读 2007-03-16 23:43:00
    存储过程包含带有 SQL 语句的过程构造。存储过程存储在 DB2? 数据库中,并在 DB2 服务器上运行...使用存储过程的应用程序具有下列优点:减少了网络流量 使用存储过程会减少网络流量和提高总体应用程序性能,原因是存储
  • 表结构为(col1,col2为联合主键) col1 col2 col3 1 1.1 2.5 1 1.3 2.6 1 1.5 2.8 2 1.1 1 2 1.2 2.6 2 1.4 3.7 3 1.5 3.5 查出来的结果为 1 2.5 0 2.6 0 2.8 2 1 2.6 0 2.7 0 ...跪求解答
  • 今天使用USB安装2003 在一台lenovo笔记本 ...发现提示安装程序在计算机中识别出下列大容量存储设备 解决方案:BIOS 硬盘更改为兼容or ide即可 转载于:https://blog.51cto.com/vn98z/905299...
  • C++存储类别

    2016-04-26 00:26:54
    C++程序存储类定义的范围...有下列存储类型可以在C++程序中使用 auto register static extern mutable 自动(auto)存储类 自动存储类是默认的存储类别在所有局部变量。 { int mount; auto int month; } 上面
  • C++ 变量存储

    2019-01-30 09:21:34
    程序中的所有对象拥有下列存储期之一: 自动存储期 对象的存储在外围代码块开始时分配,而在结束时解分配。 除了声明为 static 、 extern 或 thread_local 的所有局部对象拥有此存储期。 静态存储期 ...
  • 写了一个如下的存储过程,执行的时候报错,如图PROCEDUREAXJJ_STAND_BOND_DETAIL(P_DATA_SETOUTREDATASET.DS,P_CALC_KEYINTCALC_KEY_TREE.CALC_KEY%TYPE,--计算KEYP_PORT_LISTINVARCH...写了一个如下的存储过程,...
  • 虚拟存储的容量受到下列哪一个因素的限制影响最大? 正确答案: B 你的答案: B (正确) 磁盘空间大小 物理内存大小 数据存放的实际地址 计算机地址位数 添加笔记 求解答(11) 收藏...
  • 注意事项 1、在创建oracle表时,表名、字段名如果用了“”,则表名、字段名是大小写敏感的;...参考下列存储过程实例创建存储过程;  CREATE OR REPLACE PROCEDURE pr_for_lulu IS rcount number; BEGIN
  • The number of clients that were disconnected because of aninput or output error.The network address which X Plugin is bound to. If thebind has failed, or if theskip_networking option hasbeen used, the...
  • Oracle中编写一存储过程:出现如下错误, PLS-00103:出现符号“/”在需要下列之一时:( 经过各种谷歌百度,在存储过程中定义变量不允许使用关键字,而我定义了变量sum,导致错误。 ...
  • 将三元组按行优先的顺序,同一行中列号从小到大的规律排列成一个线性表,称为三元组表,采用顺序存储方法存储该表。如图5.11 稀疏矩阵对应的三元组表为图5.12。显然,要唯一的表示一个稀疏矩阵,还需要存储三元组表...
  • 一、 背景  由于公司业务需要动态配置一些存储过程来生成数据,之前尝试过使用jpa来完成,或多或少都存在一些问题,最后使用了spring的Jdbctemplate。... 说明:为方便表示,下列存储过程在代码中...
  • 在oracle数据库创建可自动执行的存储过程中,编译时,出现如下错误: PLS-00103: 出现符号 "end-of-file"在需要下列之一时: ( begin case declare end exception exit for goto if loop mod null pragma raise ...
  • 申明:下列存储过程适合表已经有数据,需要为某字段赋值(国,省,市,区,县等)数据时使用。1.创建regionAdd存储过程,查询国表信息传入参数到reg存储过程中 /*删除存储过程regionAdd*/ DROP PROCEDURE regionAdd;...
  • ![图片](https://img-ask.csdn.net/upload/201704/12/1491986452_924592.png)
  • 已知head为单链表的表头指针,链表中存储的都是整形数据,实现下列运算的递归算法: (1)求链表中的最大值。 (2)求链表中的结点个数。 (3)求所有整数的平均值。
  • 一、问题描述:有一个PC技嘉的主板,安装系统时提示如下问题:************************************************安装程序在计算机中识别出了下列大容量存储设备:.无.指定其他供windows使用的scsi适配器、cd-rom...
  • --编存储过程 create or replace procedure prc_job_test is t_type varchar2(10); t_code varchar2(20); begin t_type :='1'; t_code :='YYYY-MM-DD'; --注意 :=一定是英文的 update ZHYY_TK_BASE...
  • 写完存储过程编译的过程中,爆错如下:  出现符号 "END"在需要下列之一时:  错误:PLS-00103: 出现符号 "END"在需要下列之一时:  begin case declare exit for  goto if loop mod null pragma raise return ...
  • 1. 在存储过程或函数中,不能直接写sql删除表,应该: create procedure testProcedure is sql varchar(100); begin sql:='drop table tableName'; execute immediate sql; commit; end testProcedure; 2. 在...
  • CREATEORREPLACEPROCEDUREUNFOLD_STANDBOM_FINAL_SEQ(CODEVARCHAR2,GROSS_TYPEVARCHAR2,--'N'表示使用净耗;'G'表示使用总耗COMPANYvarchar2)... 请高手帮忙解决下,我得瑟所有存储过程最后都是报这个错误。。。 展开
  • PLS-00103:出现符号“/”在需要下列之一时:( 经过各种谷歌百度,在存储过程中定义变量不允许使用关键字,而我定义了变量sum,导致错误。 经过编译后的过程代码为: create or replace procedure avg_sal...
  • 一、进入数据库,选择master数据库,执行下列存储过程 create procedure sp_tablespace as   create table #spt_space  (  id int null,  type char(10) null,  name sysname null,  rows int ...
  • createorreplaceprocedureUP_cc_stand_bom_IOASCURSORCORisSELECTitem,item_class,item_d,item_d_class,net_qty,start_date,end_date,remarkFROMcc_stand_bom_temp_io;itemvarchar2(1...create or replace procedure...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,470
精华内容 1,788
关键字:

下列存储