顺序表与链表的c++代码对比

顺序表与单链表对比（以c++代码为例）

结构表示形式

顺序表类似数组，也可由一个结构体表示，该结构体含有一个数组和一个记录数组有效元素长度的变量。

typedef struct {   
    int number[40];
    int length;
}SqList; //typedef表示别名

用一个结构体作为单链表的一个节点，该结构体含有一个指向相同类型结构体的指针和相应数据。

typedef struct LNode{
    int data=0;
    struct LNode *next;
}Linklist;

创建方式

顺序表的创建方式较简单，给结构指针分配内存后同时给每个元素赋值即可。

//采用引用的目的是为了直接修改原对象
void createList(SqList* &L,int a[],int length){ 
    int i;
    L = (SqList*)malloc(sizeof(SqList));
    for(i=0;i<length;i++)
        L->number[i] = a[i];
    L->length = length;
}

单链表创建时需要有表头，其创建方式有两种，头插法和尾插法，两种方法区别在于头插法创建完成后为逆序，尾插法为顺序

//create a Linklist, 头插法得到逆序链表
void CreateList(Linklist* &head, int a[], int n){
    Linklist *s;
    Linklist *p;
    int i;
    head = (Linklist*)malloc(sizeof(Linklist)); 
    head->next = NULL;
    p = head;
    for(i=0;i<n;i++){
        s = (Linklist*)malloc(sizeof(Linklist)); //每次都需要分配空间
        s->data = a[i]; 
        s->next = p->next;
        p->next = s;
    }
}
//create a Linklist, 尾插法得到顺序链表
void CreateList(Linklist* &head, int a[], int n){
    Linklist *s;
    Linklist *p;
    int i;
    head = (Linklist*)malloc(sizeof(Linklist));
    p = head;
    for(i=0;i<n;i++){
        s = (Linklist*)malloc(sizeof(Linklist));
        s->data = a[i]; 
        p->next = s;
        p = s;
    }
    p->next = NULL; //让最后一个节点指向NULL
}

初始化方式

顺序表

void InitList(SqList* &L){
    L = (SqList*)malloc(sizeof(SqList));
    L->length = 0;
}

单链表，创建表头，并让其指向NULL。

void InitList(Linklist* &head){
    head = (Linklist*)malloc(sizeof(Linklist));
    head->next = NULL;
}

判断为空表

顺序表靠存储长度的整型变量判断。

bool ListEmpty(SqList* L){
    return (L->length>0);
}

单链表靠头节点所指向的是否为NULL

bool ListEmpty(Linklist* head){
    return (head->next==NULL);
}

求长度

顺序表靠存储长度的整型变量判断。

int ListLength(SqList *L){
    return L->length;
}

单链表靠遍历判断。

int Lengthlist(Linklist* head){
    Linklist *p;
    int i=0;
    p = head->next;
    while(p!=NULL){
        p = p->next;
        i += 1;
    }
    return i;
}

输出方式

顺序访问

void ShowList(SqList *L){
    int i;
    if(L->length==0) return;
    for(i=0;i<L->length;i++)
        printf("%d ",L->number[i]);
}

单链表逐个节点遍历输出

void ShowLinklist(Linklist* &head){
    Linklist* p;
    p = head->next;
    while(p!= NULL){
        cout<<p->data<<",";
        p = p->next;}
}

随机访问元素的值

顺序表访问第i个元素的值，无需遍历，复杂度为O(1)。

bool GetItem(SqList* L, int i, int &e){
    if(i>L->length || i<0) return false;
    else{
        e = L->number[i-1];
        return true;
    }
}

单链表要从头节点开始遍历，复杂度最差可能为O(n-1)。

bool GetItem(Linklist* head, int i, int &e){
    Linklist* p=head;
    int j=0;
    int length = Lengthlist(head); //返回单链表长度
    if(i<1 || i>length+1)  return false;
    //需要依节点顺序访问，不能随机读取。
    while(j<i && p!=NULL){
        p = p->next;
        j++;
    }
    if(p==NULL) return false;
    e = p->data;
    return true;
}

判断元素是否在表中

顺序遍历

bool CheckItem(SqList* L, int e){
    int i;
    for(i=0;i<L->length;i++){
        if(L->number[i] == e) return true;
    }
    return false;
}

逐个节点遍历

int CheckItem(Linklist* head, int e){
    Linklist* p=head->next;
    int j=0;
    while(p!=NULL && p->data !=e){
        p = p->next;
        j++;
    }
    if(j==0)  return false;
    else return true;
}

插入元素

顺序表，元素定位方便，但需整体移动。

bool InsertItem(SqList* &L, int i, int e){
    int j;
    if(i>0 && i<L->length+1 && 40-(L->length)>0){  //判断结构体内数组是否有剩余空间
        i -= 1;
        for(j=L->length;j>i;j--){
            L->number[j] = L->number[j-1];
            }
        L->number[i] = e;
        L->length += 1; 
        return true;
        }
    return false;
}

单链表更改指向即可，不需整体移动数据，但要逐个节点遍历进行定位。

void InsertItem(Linklist* &head, int i, Linklist* p){
    Linklist* m;
    int j=1;
    m = head->next;
    while(j<i){
        m = m->next;
        j++;
    } 
    p->next = m->next;
    m->next = p;
}

删除元素

顺序表，元素定位方便，但需整体移动。

bool DeleteItem(SqList* &L, int i){
    int j;
    if(i<1 || i>L->length+1) return false;
    i -= 1;
    for(j=i;j<L->length-1;j++)
        L->number[j] = L->number[j+1];
    L->number[L->length-1] = 0;
    L->length -= 1;
    return true;   
}

单链表更改指向即可，不需整体移动数据，但要逐个节点遍历进行定位。

void DeleteItem(Linklist* &head, int i, Linklist* p){
    Linklist* m;
    int j=1;
    m = head->next;
    while(j<i-1){
        m = m->next;
        j++;
    }     
}

销毁表

顺序表，直接释放指针内存即可

void DestroyList(SqList* &L){
    free(L);
}

单链表要逐个节点释放内存。

void DestroyItem(Linklist* &head){
    Linklist *pre=head;
    Linklist *p = pre->next;
    while(p!=NULL){
        free(pre);
        pre = p;
        p = pre->next; 
    }
    free(pre);
}

草草成稿，如果代码有问题请私信修改，更加详细的讲解请访问中国大学MOOC。