线性表

线性表是一种最简单、最常用的数据结构，用它可以描述各种线性放置的数据，实现相应的操作。一个线性表是n个数据元素的有限序列，表中的数据元素，除第一个和最后一个外，有且仅有一个直接前驱和一个直接后继（第一个和最后一个元素除外）。长度为n的线性表可描述为L=（D，R），D表示数据对象，R表示相邻关系。当n=0时，线性表为空表。
线性表有两种存储结构——顺序存储的顺序表（常用的数组）和链式存储的链表。接下来将会介绍线性表在两种存储结构下的一系列操作。

线性表的顺序存储结构：顺序表
需要清楚的是物理下标和逻辑下标，物理下标是从0开始的，而逻辑下标是从1开始的。有些方式可以按个人喜好，你也可以说我要查找第0个元素，但是这并不符合日常的习惯。

#include<iostream>
using namespace std;

const int MaxSize=100;    //数组最大存储容量为100

class SeqList
{
    int data[MaxSize];
    int length;    //表长 
public:
    SeqList(int a[],int n);
    ~SeqList(){}
    int GetLength()    //求线性表的长度 
    {
        return length;
    }
    int Get(int i);   //按位查找，取线性表的i个元素
    void Insert(int i,int x);    //在第i个位置插入值为x的元素
    int Delete(int i);   //删除第i个元素
    int Locate(int x);   //按值查找，求线性表中值为x的元素序号
    void PrintList();   //输出线性表各元素
    void Set(int i,int x);   //设置第i个元素的值 
};

SeqList::SeqList(int a[],int n)
{
    for(int i=0;i<n;i++)data[i]=a[i];
    length=n;
} 

void SeqList::Insert(int i,int x)    //！！！！这里的i为物理上的下标，但是实际插入时要使物理和逻辑上的顺序一致 
{
    for(int j=length;j>=i;j--)data[j]=data[j-1];    //将最后一个元素到第i个元素向后平移一个位置 
    data[i-1]=x;
    length++;    //表长加1 
} 

int SeqList::Delete(int i)
{
    int x=data[i-1];   //保存第i个位置的元素
    for(int j=i;j<length;j++)data[j-1]=data[j];   //将第i个元素到最后一个元素向前平移一个位置
    length--;
    return x;    //这个返回值可能用于其他用途 
} 

int SeqList::Get(int i)
{
    return data[i-1];
} 

int SeqList::Locate(int x)
{
    for(int i=0;i<length;i++)
    {
        if(data[i]==x)return i+1;  //返回逻辑序号 
    }
    return 0; 
}

void SeqList::Set(int i,int x)
{
    data[i-1]=x;
}

void SeqList::PrintList()
{
    for(int i=0;i<length;i++)cout<<data[i]<<" ";
    cout<<endl;
}
//主函数测试
int main()
{
    int a[6]={12,15,37,20,16,78};
    SeqList d(a,6);     //有参构造函数创建顺序表 
    cout<<"按位查找第2个元素："<<d.Get(2)<<endl;
    cout<<"按值查找20的位置："<<d.Locate(20)<<endl;
    cout<<"删除第2个元素："<<d.Delete(2)<<endl;
    cout<<"顺序表的长度为："<<d.GetLength()<<endl;
    cout<<"在第3个位置上插入元素8"<<endl;
    d.Insert(3,8);
    cout<<"插入之后顺序表的元素为：";
    d.PrintList(); 
    return 0;
}

线性表的链式存储结构：链表
我们在链表里设置了一个头结点，这和我们平常所熟悉的链表不太相同，通常的头结点放的是第一个数据，二我们的头结点是一个虚结点，并用头指针first指向它，不放置任何数据，只要一个指向第一个数据的指针域。这是为什么呢？原因是这样可以方便插入和删除操作的统一性。Insert和Delete均可在表头、表中间、表尾进行操作。这样单链表的入口点就不会改变了。要注意的是，头结点不是链表第一个结点，虽然使用了一些存储空间，但是总体还是合算的 。
（1）单链表

#include<iostream>
using namespace std;

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

template <class T>
class LinkList
{
    Node<T> *first;
public:
    LinkList();
    LinkList(T a[],int n);  //前插法构造函数 
    LinkList(int n,T a[]);  //尾插法构造函数
    ~LinkList()
    {
        Node<T> *p=first;
        while(p)
        {
            Node<T> *q=p;
            p=p->next;
            delete q;
        }
    } 
    void Set(int i,T x);    //设置第i个结点的值 
    int GetLength();    //链表长度 
    T Get(int i);      //得到第i个结点的数据 
    int Locate(T x);     //求值为x的结点在链表中的位置 
    void Insert(int i,T x);    //在第i个结点插入x 
    T Delete(int i);     //删除第i的结点 
    void PrintList();
};

template <class T>
LinkList<T>::LinkList()    //构造头结点 
{
    first=new Node<T>;
    first->next=NULL;
}

template <class T>
LinkList<T>::LinkList(T a[],int n)   //前插法建立单链表，从后面开始往头结点方向插入 
{
    first=new Node<T>;
    Node<T> *s;
    first->next=NULL;
    for(int i=0;i<n;i++)
    {
        s=new Node<T>;
        s->data=a[i];
        s->next=first->next;
        first->next=s;
    } 
}

template <class T>
LinkList<T>::LinkList(int n,T a[])    //后插法建立单链表 
{
    first=new Node<T>;
    first->next=NULL;
    Node<T> *r=first,*s;    //指针r总是指向最后一个结点 
    for(int i=0;i<n;i++)
    {
        s=new Node<T>;
        s->data=a[i];
        r->next=s;
        r=s; 
    }
    r->next=NULL;
}

template <class T>
void LinkList<T>::Set(int i,T x)
{
    Node<T> *p=first->next;
    int j=1;
    while(j<i)    
    {
        p=p->next;
        j++;
    }
    p->data=x;
} 

template <class T>
int LinkList<T>::GetLength()
{
    Node<T> *p=first;
    int j=0;
    while(p->next)
    {
        j++;
        p=p->next;
    }
    return j;
}

template <class T>
void LinkList<T>::PrintList()
{
    Node<T> *p=first->next;
    while(p)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
} 

template <class T>
T LinkList<T>::Get(int i)   //取第i个的结点的元素 
{
    Node<T> *p=first->next;
    int j=1;
    while(j<i)
    {
        p=p->next;
        j++;
    }
    return p->data;
}

template <class T>
void LinkList<T>::Insert(int i,T x)
{
    Node<T> *p=first;
    int j=0;
    while(j<i-1)
    {
        p=p->next;
        j++;
    }
    Node<T> *s=new Node<T>;
    s->data=x;      
    s->next=p->next;   //这两句不能颠倒！！！！否则数据覆盖无法访问，如果颠倒，p->next直接指向s，以后的数据将不再存在 
    p->next=s; 
} 

template <class T>
T LinkList<T>::Delete(int i)
{
    Node<T> *p=first;
    int j=0;
    while(j<i-1)
    {
        p=p->next;
        j++;
    }
    Node<T> *q=p->next;
    T x=q->data;
    p->next=q->next;
    delete q;
    return x;
} 

int main()
{
    int a1[5]={1,2,3,4,5};
    cout<<"前插法建立单链表,";
    LinkList<int> a(a1,5);
    cout<<"单链表a的元素为：";
    a.PrintList();
    cout<<endl;
    cout<<"单链表的长度为："<<a.GetLength()<<endl;

    int a2[5]={6,7,8,9,10};
    cout<<"后插法建立单链表,";
    LinkList<int> b(5,a2);
    cout<<"单链表b的元素为：";
    b.PrintList();
    cout<<endl;
    cout<<"单链表的长度为："<<b.GetLength()<<endl; 
    if(b.GetLength())
    {
        cout<<"删除单链表b的第一个元素："<<endl;
        b.Delete(1);
        cout<<"删除成功！单链表b的长度为"<<b.GetLength()<<endl; 
    }
    else cout<<"单链表b的长度为0"<<endl;
    cout<<"单链表b为：";
    b.PrintList(); 
    return 0;
}