4)线性表[顺序表和链表]

顺序表：

#include<iostream>
using namespace std;

enum error{rangeerror,underflow,overflow,success};
const int maxlen=1000;

class list{
public:
    list();
    int length()const;//求长度
    int get_int(const int i,int &x)const;//按序号取元素运算
    int locate(const  int x)const;//搜索元素运算对应的函数
    int insert(const int i,const int x);//插入元素运算对应的函数
    int dele(const int i);//删除元素运算对应的函数
private:
    int data[maxlen];
    int count;
};


list::list(){//初始顺序表化
    count=0;
}

int list::length()const{//求表长度的实现
    return count;
}

int list::get_int(const int i,int &x)const{//按序号求元素
    if(i<=0||i>count)return underflow;
    else {
        x=data[i-1];
        return success;
    }
}

int list::locate(const int x)const{//查找元素
    bool flags=false;
    for(int i=0;i<count;i++){
        if(data[i]==x){
            flags=true;
            return i+1;
            break;
        }
    }
    if(flags==false)return -1;
}

int list::insert(const int i,const int x){//插入元素
    if(count==maxlen)return overflow;//溢出，不能插入
    if(i<1||i>length()+1)return rangeerror;//插入范围有错
    else {
        for(int j=count-1;j>=i-1;j--){
            data[j+1]=data[j];
        }
        data[i-1]=x;
        count++;
        return success;
    }
}


int list::dele(const int i){//删除元素
    int j;
    if(length()==0)return underflow;
    if(i<1||i>length())return rangeerror;
    else {
        for(j=i+1;j<=length();j++){
            data[j-2]=data[j-1];
        }
        count--;
        return success;
    }
}


bool subset(list A,list B){//判断集合A是否是集合B 的子集
    int ia,ib,x,y;
    bool flags;
    bool suc=true;
    for(ia=0;ia<A.length();ia++){
        A.get_int(ia+1,x);
        flags=false;
        for(ib=0;ib<B.length();ib++){
            B.get_int(ib+1,y);
            if(x==y){
                flags=true;
                break;
            }
        }
        if(flags==false){
            suc=false;
            break;
        }
    }
    return suc;
}


void merge_list(list A,list B, list &C){//顺序表A,B合并
    int ia=0,ib=0,ic=1;
    int x,y;
    while(ia<A.length()&&ib<B.length()){
        A.get_int(ia+1,x);
        B.get_int(ib+1,y);
        if(x==y){
            C.insert(ic,x);
            ic++;
            ia++;
            C.insert(ic,y);
            ic++;
            ib++;
        }else if(x>y){
            C.insert(ic,y);
            ic++;
            ib++;
        }else {
            C.insert(ic,x);
            ic++;
            ia++;
        }
    }

    while(ia<A.length()){
        A.get_int(ia+1,x);
        C.insert(ic,x);
        ic++;
        ia++;
    }
    while(ib<B.length()){
        B.get_int(ib+1,y);
        C.insert(ic,y);
        ic++;
        ib++;
    }

    int i;
    for(i=0;i<C.length();i++){
        C.get_int(i+1,x);
        cout<<x<<" ";
    }
    cout<<endl;
        
}
int main(){
    list A,B,C;
    A.insert(1,1);
    A.insert(2,3);
    A.insert(3,5);
    A.insert(4,7);
    A.insert(5,9);
    A.insert(6,11);
    A.insert(7,13);
    B.insert(1,3);
    B.insert(2,4);
    B.insert(3,6);
    B.insert(4,8);
    B.insert(5,10);
    B.insert(6,12);
    B.insert(7,14);
    B.insert(8,15);

    int x,i;
    for( i=0;i<A.length();i++){
    A.get_int(i+1,x);
    cout<<x<<" ";
    }
    cout<<endl;


    for( i=0;i<B.length();i++){
    B.get_int(i+1,x);
    cout<<x<<" ";
    }
    cout<<endl;

    merge_list(A,B,C);
/*    for( i=0;i<C.length();i++){
    C.get_int(i+1,x);
    cout<<x<<" ";
    }
    cout<<endl;*/
    //cout<<subset(A,B)<<endl;
    return 0;
}

链表：

#include <iostream>
using namespace std;


enum error{rangeerror,overflow,underflow,success};
struct node{
    int data;
    node *next;
};

class list{
public:
    list();
    int length() const;//求长度的函数
//    ~list();//释放链表存储空间的析构函数
    int get_int(const int i ,int & x)const;//按序号取元素运算函数
    int locate(const  int x)const;//搜索元素运算对应的函数
    int insert(const int i,const int x);//插入元素运算对应的函数
    int dele(const int i);//删除元素对应的函数]
    void  create();//创建链表
    node *get_head(){return head;}
    bool Judge();//判断链表L中的元素是否为递增的
    void copy(list A,list &B);//复制链表A中的内容到B表中
private:
    int count;
    node * head;
};


list::list(){//初始化对应的构造函数
    head =new node;
    head->next=NULL;
    count=0;
}

int list::length() const{//求长度
    return count;
}

int list::get_int(const int i,int &x)const{//按序号取元素
    node *p=new node;
    p=head->next;
    int j=1;
    while(p!=NULL&&j!=i){//当前节点不是目标节点，并且不空时就继续搜索
        p=p->next;
        j++;
    }
    if(p==NULL)return rangeerror;
    else {
        x=p->data;
        return success;
    }
}

int list::locate(const int x)const{//搜索元素运算对应的函数
    bool flags=false;
    int j=1;
    node *p = new node;
    while(p!=NULL){
        if(p->data==x){
            cout<<"元素所在的位置为:"<<j<<endl;
            flags=true;
            break;
        }else{
            j++;
            p=p->next;
        }
    }
    if(flags==false)return -1;
    return 0;
}


int list::insert(const int i,const int x){//插入元素
    node *p=new node;
    p=head;
    int j;
    j=0;
    while(j!=i-1&&p!=NULL){
        p=p->next;
        j++;
    }

    if(i<1||i>count+1)return rangeerror;
    node *s = new node;//产生节点
    s->data=x;//装入数据
    s->next=p->next;
    p->next=s;
    count++;
    return success;
}


int list::dele(const int i){//删除元素
    node * p=new node;
    p=head;
    int j=0;
    while(j!=i-1&&p!=NULL){
        p=p->next;
        j++;
    }

    if(i<1||i>count+1)return rangeerror;
    node *u=new node;
    u=p->next;
    p->next=u->next;
    delete u;
    count--;
    return success;
}


void list::create(){//创建链表
    int x;
    cin>>x;
    node * rear=head;
    while(x!=0){
        count++;
        node *s=new node;
        s->data=x;
        rear->next=s;
        rear=s;
        rear->next=NULL;
        cin>>x;
    }
}

bool list::Judge(){//用于判断链表是否为递增的
    node *p=new node;
    p=head;
    bool flags=true;
    while(p->next!=NULL){
        if(p->data<p->next->data)p=p->next;
        else {
            flags=false;
            break;
        }
    }
    return flags;
}

void list::copy(list A,list &B){
    node *pa=new node;
    node *pb=new node;
    pa=A.get_head()->next;
    pb=head;
    while(pa!=NULL){
        node * s = new node;
        s->data=pa->data;
        pb->next=s;
        pb=s;
        B.count++;
        pa=pa->next;
        pb->next=NULL;
    }
}
int main()
{
    list l;
    l.create();
    int i,x;
    for(i=0;i<l.length();i++){
        l.get_int(i+1,x);
        cout<<x<<" ";
    }

    cout<<endl;

    cout<<l.Judge()<<endl;
/*    l.insert(5,10);
    for(i=0;i<l.length();i++){
        l.get_int(i+1,x);
        cout<<x<<" ";
    }

    cout<<endl;

    l.dele(2);
        for(i=0;i<l.length();i++){
        l.get_int(i+1,x);
        cout<<x<<" ";
    }

    cout<<endl;
    */

    return 0;
}