数据结构基础 线性表

概念

线性表是n(n>=0)个具有相同类型的数据元素的有限序列。

线性表的顺序存储结构及实现

线性表的顺序存储结构称为 顺序表。顺序表是用一段地址连续的存储单元依次存储线性表的数据元素。通常用一维数组来实现顺序表。

实现：
SeqList.h

//
// Created by 野尽 on 2020/3/28.
//

#ifndef LinkLIST_CLASSTEMPLATEINHFILE__LINKLIST_H
#define LinkLIST_CLASSTEMPLATEINHFILE__LINKLIST_H

#include <iostream>
using namespace std;

template <class DataType>
struct Node
{
    DataType data;
    Node<DataType> * next;
};

template <class DataType>
class LinkList
{
public:
    // 无参构造函数，建立只有头结点的空链表
    LinkList();

    // 有参构造函数，建立一个长度为n的单链表
    LinkList(DataType a[], int n);

    // 析构函数
    ~LinkList();

    // 求线性表的长度
    int Length();

    // 按位查找，在线性表中查找第i个元素
    DataType Get(int i);

    // 按值查找，在线性表中查找值为 x 的元素序号
    int Locate(DataType x);

    // 插入操作，在线性表中第 i 个位置插入值为 x 的元素
    void Insert(int i, DataType x);

    // 删除操作，删除线性表的第 i 个元素，并返回被删除元素
    DataType Delete(int i);

    // 遍历线性表
    void PrintList();

    // 赋值头指针
    Node<DataType> * GetFirstPointer();

private:
    
    Node<DataType> * first;
};

template<class DataType>
LinkList<DataType>::LinkList() {

    first = new Node<DataType>;
    first->next = NULL;
}

// 尾插法创建单链表
template<class DataType>
LinkList<DataType>::LinkList(DataType *a, int n) {

    first = new Node<DataType>;
    Node<DataType> * r;
    r = first;

    for (int i = 0; i < n; i++)
    {
        Node<DataType> * s;
        s = new Node<DataType>;
        s->data = a[i];
        r->next = s;
        r = s;
    }

    r->next = NULL;
}

 头插法创建单链表
//template<class DataType>
//LinkList<DataType>::LinkList(DataType *a, int n) {
//
//    first = new Node<DataType>;
//    first->next = NULL;
//
//    for (int i = 0; i < n; i++)
//    {
//        Node<DataType> * s;
//        s = new Node<DataType>;
//        s->data = a[i];
//        s->next = first->next;
//        first->next = s;
//    }
//}

template<class DataType>
LinkList<DataType>::~LinkList() {

    while (first!=NULL)
    {
        Node<DataType> * q;
        q = first;
        first = first->next;
        delete q;
    }

}

template<class DataType>
int LinkList<DataType>::Length() {

    int count = 0;

    Node<DataType> * p = first->next;
    while (p!=NULL)
    {
        p = p->next;
        count++;
    }

    return count;
}

template<class DataType>
DataType LinkList<DataType>::Get(int i) {

    int count = 1;

    Node<DataType> * p = first->next;
    while (p!=NULL && count<i)
    {
        p = p->next;
        count++;
    }

    if(p==NULL)
        throw "end of list!";
    else
        return p->data;
}

template<class DataType>
int LinkList<DataType>::Locate(DataType x) {

    int count = 1;
    Node<DataType> * p = first->next;

    while (p!=NULL)
    {
        if (p->data == x)
            return count;
        p = p->next;
        count++;
    }

    return 0;
}

template<class DataType>
void LinkList<DataType>::Insert(int i, DataType x) {

    int count = 0;
    Node<DataType> * p = first;
    while (p!=NULL && count<i-1)
    {
        p = p->next;
        count++;
    }

    if (p==NULL)
        throw "end of list!";
    else
    {
        Node<DataType> * s;
        s = new Node<int>;
        s->data = x;
        s->next = p->next;
        p->next = s;
    }
}

template<class DataType>
DataType LinkList<DataType>::Delete(int i) {

    int count = 0;
    Node<DataType> * p = first;

    while (p!=NULL && count<i-1)
    {
        p = p->next;
        count++;
    }

    if (p==NULL || p->next==NULL)
        throw "node not exist!";
    else
    {
        Node<DataType> * q;
        q = p->next;
        DataType x = q->data;
        p->next = q->next;
        delete q;
        return x;
    }
}

template<class DataType>
void LinkList<DataType>::PrintList() {

    Node<DataType> * p = first->next;
    while (p!=NULL)
    {
        cout<<" "<<p->data;
        p = p->next;
    }

    cout<<endl;
}

template<class DataType>
Node<DataType> * LinkList<DataType>::GetFirstPointer() {

    return first;
}

#endif //LinkLIST_CLASSTEMPLATEINHFILE__LINKLIST_H

main.cpp

#include "SeqList.h"

int main() {

    const int n = 10;
    int a[n] = {1,2,3,4,5,6,7,8,9,10};

    SeqList <int> seqList(a, n);
    cout<< "序列：";
    seqList.PrintList();

    int l = seqList.Length();
    cout<<"序列长度为："<< l <<endl;

    int i = 8;
    int x = seqList.Get(i);
    cout<<"第 " << i <<" 位是："<< x <<endl;

    seqList.Locate(x);
    cout<< x << " 是第 " << i <<" 位" <<endl;

    seqList.Insert(i,11);
    cout<< "执行插入后的序列：";
    seqList.PrintList();

    seqList.Delete(i);
    cout<< "执行删除后的序列：";
    seqList.PrintList();
    return 0;
}

测试结果：

序列： 1 2 3 4 5 6 7 8 9 10
序列长度为：10
第 8 位是：8
8 是第 8 位
执行插入后的序列： 1 2 3 4 5 6 7 11 8 9 10
执行删除后的序列： 1 2 3 4 5 6 7 8 9 10
object deleted!

注意：类模板的分离编译问题，看这里。
类模板的分离编译问题

线性表的链接存储结构及实现

单链表 是用一组任意的存储单元存放线性表的元素。
单链表的每个结点由数据域和指针域（链域）组成。
头指针指向头结点，之后是第一个元素，最后一个元素的指针域为空。

实现：
LinkList.h

//
// Created by 野尽 on 2020/3/28.
//

#ifndef LinkLIST_CLASSTEMPLATEINHFILE__LINKLIST_H
#define LinkLIST_CLASSTEMPLATEINHFILE__LINKLIST_H

#include <iostream>
using namespace std;

template <class DataType>
struct Node
{
    DataType data;
    Node<DataType> * next;
};

template <class DataType>
class LinkList
{
public:
    // 无参构造函数，建立只有头结点的空链表
    LinkList();

    // 有参构造函数，建立一个长度为n的单链表
    LinkList(DataType a[], int n);

    // 析构函数
    ~LinkList();

    // 求线性表的长度
    int Length();

    // 按位查找，在线性表中查找第i个元素
    DataType Get(int i);

    // 按值查找，在线性表中查找值为 x 的元素序号
    int Locate(DataType x);

    // 插入操作，在线性表中第 i 个位置插入值为 x 的元素
    void Insert(int i, DataType x);

    // 删除操作，删除线性表的第 i 个元素，并返回被删除元素
    DataType Delete(int i);

    // 遍历线性表
    void PrintList();

private:
    
    Node<DataType> * first;
};

template<class DataType>
LinkList<DataType>::LinkList() {

    first = new Node<DataType>;
    first->next = NULL;
}

// 尾插法创建单链表
template<class DataType>
LinkList<DataType>::LinkList(DataType *a, int n) {

    first = new Node<DataType>;
    Node<DataType> * r;
    r = first;

    for (int i = 0; i < n; i++)
    {
        Node<DataType> * s;
        s = new Node<DataType>;
        s->data = a[i];
        r->next = s;
        r = s;
    }

    r->next = NULL;
}

 头插法创建单链表
//template<class DataType>
//LinkList<DataType>::LinkList(DataType *a, int n) {
//
//    first = new Node<DataType>;
//    first->next = NULL;
//
//    for (int i = 0; i < n; i++)
//    {
//        Node<DataType> * s;
//        s = new Node<DataType>;
//        s->data = a[i];
//        s->next = first->next;
//        first->next = s;
//    }
//}

template<class DataType>
LinkList<DataType>::~LinkList() {

    while (first!=NULL)
    {
        Node<DataType> * q;
        q = first;
        first = first->next;
        delete q;
    }

}

template<class DataType>
int LinkList<DataType>::Length() {

    int count = 0;

    Node<DataType> * p = first->next;
    while (p!=NULL)
    {
        p = p->next;
        count++;
    }

    return count;
}

template<class DataType>
DataType LinkList<DataType>::Get(int i) {

    int count = 1;

    Node<DataType> * p = first->next;
    while (p!=NULL && count<i)
    {
        p = p->next;
        count++;
    }

    if(p==NULL)
        throw "end of list!";
    else
        return p->data;
}

template<class DataType>
int LinkList<DataType>::Locate(DataType x) {

    int count = 1;
    Node<DataType> * p = first->next;

    while (p!=NULL)
    {
        if (p->data == x)
            return count;
        p = p->next;
        count++;
    }

    return 0;
}

template<class DataType>
void LinkList<DataType>::Insert(int i, DataType x) {

    int count = 0;
    Node<DataType> * p = first;
    while (p!=NULL && count<i-1)
    {
        p = p->next;
        count++;
    }

    if (p==NULL)
        throw "end of list!";
    else
    {
        Node<DataType> * s;
        s = new Node<int>;
        s->data = x;
        s->next = p->next;
        p->next = s;
    }
}

template<class DataType>
DataType LinkList<DataType>::Delete(int i) {

    int count = 0;
    Node<DataType> * p = first;

    while (p!=NULL && count<i-1)
    {
        p = p->next;
        count++;
    }

    if (p==NULL || p->next==NULL)
        throw "node not exist!";
    else
    {
        Node<DataType> * q;
        q = p->next;
        DataType x = q->data;
        p->next = q->next;
        delete q;
        return x;
    }
}

template<class DataType>
void LinkList<DataType>::PrintList() {

    Node<DataType> * p = first->next;
    while (p!=NULL)
    {
        cout<<" "<<p->data;
        p = p->next;
    }

    cout<<endl;
}

#endif //LinkLIST_CLASSTEMPLATEINHFILE__LINKLIST_H

main.cpp

#include "LinkList.h"

int main() {

    const int n = 10;
    int a[n] = {1,2,3,4,5,6,7,8,9,10};
    
    LinkList <int> linkList(a, n);
    cout<<"单链表：";
    linkList.PrintList();

    int l = linkList.Length();
    cout<<"单链表长度："<< l <<endl;

    int i = 8;
    int x = linkList.Get(i);
    cout<<"单链表中，第 " << i <<" 位是："<< x <<endl;

    linkList.Locate(x);
    cout<<"单链表中，"<< x << " 是在第 " << i <<" 位" <<endl;

    linkList.Insert(i,11);
    cout<< "执行插入后的序列：";
    linkList.PrintList();

    linkList.Delete(i);
    cout<< "执行删除后的序列：";
    linkList.PrintList();

    return 0;
}

测试结果：

单链表： 1 2 3 4 5 6 7 8 9 10
单链表长度：10
单链表中，第 8 位是：8
单链表中，8 是在第 8 位
执行插入后的序列： 1 2 3 4 5 6 7 11 8 9 10
执行删除后的序列： 1 2 3 4 5 6 7 8 9 10

顺序表和链表的比较

（1）时间性能
按位置随机访问，顺序表的时间性能为O(1)，链表平均时间为O(n)。
插入和删除，链表不需要移动元素，用时为O(1)，但在顺序表中平均用时O(n)。

一般规律：
若线性表需频繁查找却很少进行插入和删除操作，或其他和“位置”相关的操作时，宜采用顺序表作为存储结构；若线性表需要频繁进行插入和删除操作，则宜采用链表作为存储结构。

（2）空间性能
顺序表需要预分配一定长度的存储空间，分得过大，空间得不到充分利用；分得过小，则会发生上溢造成存储空间再分配。单链表不需要为其预分配存储空间，只要有内存空间可以分配，链表中的元素个数就没有限制。

一般规律：
当线性表中元素个数变化较大或未知时，最好使用链表实现；如果事先知道线性表的大致长度，使用顺序表的空间效率更高。