数据结构第二章线性表---课本代码

1.线性表的顺序存储

#include

using namespace std;
typedef int ElemType;
typedef int Status;

//线性表的定义
typedef struct{
    int n;      //  统计顺序表真实的容量
    int maxLength;  //统计最大容量
    ElemType *element; //顺序表的首地址
}SeqList;

//初始化
Status Init(SeqList *L,int mSize){
    L->n=0;
    L->maxLength=mSize;
    L->element=(ElemType *)malloc(sizeof(ElemType)*mSize);  //动态生成一维数组空间
    if(!L->element)
        return 0;
    return 1;
}

//查找ai的值(下标为i的数)
Status Find(SeqList L,int i,ElemType *x){
    if(i<0||i>L.n-1)
        return 0;
    *x=L.element[i];    //通过x返回待查找的值
    return 1;
}

//插入,插入的位置是i+1,插入x
Status Insert(SeqList *L,int i,ElemType x){
    if(i<-1||i>L->n-1)        //下标越界
        return 0;
    if(L->n==L->maxLength)  //线性表满
        return 0;
    for(int j=L->n-1;j>i;j--)
        L->element[j+1]=L->element[j];
    L->element[i+1]=x;
    L->n=L->n+1;
    return 1;
}

//删除,将元素ai删除
Status Delete(SeqList *L,int i){
    if(i<0||i>L->n-1)
        return 0;
    if(!L->n)           //防止空表
        return 0;
    for(int j=i+1;j<=L->n;j++)
        L->element[j-1]=L->element[j];
    L->n--;
    return 1;
}

//输出
Status Output(SeqList L){
    if(!L.n)
        return 0;
    for(int j=0;j<=L.n-1;j++)
        cout<" ";
    cout<return 1;
}

//撤销运算
void Destroy(SeqList *L){
    L->maxLength=0;
    L->n=0;
    free(L->element);
}

int main(){
    int i;
    SeqList list;
    Init(&list,10);
    for(i=0;i<9;i++)
        Insert(&list,i-1,i);    //在位置ai+1处进行插入i
    Output(list);
    Delete(&list,0);
    Output(list);
    Destroy(&list);
    return 0;
}

2.线性表的链式存储

#include<iostream>
using namespace std;
typedef int ElemType;
typedef int Status;
//定义每个结点，数据域和指针域
typedef struct node{
    ElemType element;
    struct node *link;
}node;

//定义单链表
typedef struct{
    node *first;  //头指针，只向单链表的首地址
    int n;          // 链表的真实长度
}SingleList;

//初始化
Status Init(SingleList *L){
    L->n=0;
    L->first=NULL;
    return 1;
}

//查找,查找ai
Status Find(SingleList L,int i,ElemType *x){
    node *p;
    if(i<0||i>L.n-1)
        return 0;

    p=L.first;
    for(int j=0;j<i;j++)
        p=p->link;
    *x=p->element;      //  通过x返回找到的值
    return 1;
}

//插入,插入的位置i+1,插入的数x
Status Insert(SingleList *L,int i,ElemType x){
    node *p,*q;
    if(i<-1||i>L->n-1)
        return 0;
    p=L->first;
    for(int j=0;j<i;j++) p=p->link;     //p是带插入结点的前驱结点，p指向ai
    q=(node *)malloc(sizeof(node ));    //生成结点q
    q->element=x;

    if(i>-1){                   //插入的不是头结点
        q->link=p->link;
        p->link=q;
    }
    else{
        q->link=L->first;       //新结点插在头结点前，成为新的头结点
        L->first=q;
    }
    L->n++;
    return 1;
}

//单链表的删除,删除元素ai
Status Delete(SingleList *L,int i){
    node *p,*q;
    if(!L->n)
        return 0;
    if(i<0||i>L->n-1)
        return 0;

    p=L->first;
    q=L->first;
    for(int j=0;j<i-1;j++)
        q=q->link;        //q是待删结点的前驱结点

    if(i==0){              //待删除的是头结点
        L->first=L->first->link;
    }
    else{
        p=q->link;      //p是待删结点
        q->link=p->link;
    }
    free(p);    //  释放p的存储空间
    L->n--;
    return 1;
}

//单链表的输出
Status Output(SingleList L){
    node *p;
    if(!L.n)
        return 0;
    p=L.first;
    while(p){
        cout<<p->element<<" ";
        p=p->link;
    }
    cout<<endl;
    return 1;
}

//单链表的撤销,从头到尾一个一个的撤销
Status Destory(SingleList *L){
    node *p;        //p用来保存删除当前头结点后的头结点的位置，避免造成断链
    while(L->first){
        p=L->first->link;
        free(L->first);
        L->first=p;
    }
    return 1;
}

int main(){
    int i,x;
    SingleList list;
    Init(&list);
    for(i=0;i<9;i++)
        Insert(&list,i-1,i);
    cout<<"The linklist is: "<<endl;
    Output(list);
    Delete(&list,0);
    cout<<"The linklist is: "<<endl;
    Output(list);
    Find(list,0,&x);
    cout<<"The value is: "<<endl;
    cout<<x<<endl;
    Destory(&list);
    return 0;
}

3.带表头的双链表
写代表头的双链表的时候，写到撤销那里错了，后面修改。

/*带表头的单链表
先前处理单链表，由于头结点没有直接前驱，所以需要作为特殊情况单独处理，
为了简化算法，我们在头结点前加一个表头结点*/
#include<iostream>
using namespace std;
typedef int Status;
typedef int ElemType;
typedef struct node{
    ElemType element; //数据域
    struct node *link; //指针域
}node;

typedef struct{
    struct node *head;
    int n;      //链表的真实长度
}HeaderList;

//初始化构造一个仅带有一个表头结点的空的单链表
Status Init(HeaderList *list){
    list->head=(node *)malloc(sizeof(node));
    if(!list->head)
        return 0;
    list->n=0;
    list->head->link=NULL;
    return 1;
}

//插入操作，在ai+1的位置插入x
Status Insert(HeaderList *list,int i,ElemType x){
    if(i<-1||i>list->n-1){
        return 0;
    }
    node *p,*q;
    p=list->head;
    for(int j=0;j<=i;j++) p=p->link;

    q=(node *)malloc(sizeof(node));
    q->element=x;
    q->link=p->link;
    //p是带插入位置的前驱结点，q是带插入的位置
    p->link=q;
    list->n++;
    return 1;
}

//删除操作，删除ai.p是待删结点的前驱结点，q是待删结点
Status Delete(HeaderList *list,int i){
    node *p,*q;
    if(!list->n)
        return 0;
    if(i<0||i>list->n-1)
        return 0;

    p=list->head;
    for(int j=0;j<i;j++) p=p->link;
    q=p->link;
    p->link=q->link;
    free(q);
    list->n--;
    return 1;
}

//输出
Status Output(HeaderList list){
    node *p;
    p=list.head->link;
    while(p){
        cout<<p->element;
        p=p->link;
    }
    cout<<endl;
    return 1;
}

//查找ai,通过x返回该值
Status Find(HeaderList list,int i,ElemType *x){
    if(i<0||i>list.n-1)
        return 0;
    node *p;
    p=list.head;
    for(int j=0;j<=i;j++) p=p->link;
    *x=p->element;
    return 1;
}

////撤销操作，从头到尾
//Status Destroy(HeaderList *list){
//    node *p=list->head;
//    while(p){
//        p=list->head->link;
//        free(list->head);
//        list->head=p;
//    }
//    return 1;
//}

int main(){
    int i,x;
    HeaderList list;
    Init(&list);
    for(i=0;i<9;i++){
        Insert(&list,i-1,i);
    }
    cout<<"the headlist is:";

    Output(list);
    Delete(&list,0);
    cout<<"the headlist is:";
    Output(list);

    Find(list,0,&x);
    cout<<"the value is:";
    cout<<x<<endl;

//    Destroy(&list);
    return 0;
}