数据结构之线性表（顺序表和单链表）

线性表的定义和特点

定义：由n个(n>=0)个数据特性相同的元素构成的有限序列被叫做线性表
特点：

1. 存在唯一的一个被称作“第一个”的数据元素
2. 存在唯一的一个被称作“最后一一个”的数据元素
3. 除了第一个元素以外，结构中的每一个元素都有一个直接前驱
4. 处理最后一个元素之外，结构中每一一个元素都有一个直接后继

线性表的顺序表示和实现

顺序表:用一组地址连续的存储单元依次存储线性表的数据元素。也叫做顺序存储结构或者顺序存储映像。

线性表的顺序存储结构是一种随机存储结构

//~~~~~顺序表的存储结构 ~~~~~~~
#define MAXSIZE 100
typedef struct
{
	int *elem;
	int length;
}SqList;

顺序表相关操作：
代码：

#include <iostream>
using namespace std;

#define MAXSIZE 100

typedef struct
{
    int *elem;
    int length;
}SqList;

//顺序表的初始化
int InitList(SqList &L)
{
    L.elem = new int[MAXSIZE];//创建一个数组来粗存放顺序表
    if(!L.elem)
        return -1;
    L.length=0;
    return 1;
}

//取出顺序表指定位置的取值
void Getelem(SqList L,int i)
{
    int e;
    if(i<1||i>L.length)//如果i取值不合理，报错
        cout<<"ERROR";
    e=L.elem[i-1];
    cout<<e;

}

//顺序表的查找
void LocateElem(SqList L,int e)
{
    int i;
    for(i=0;i<L.length;i++)
        if(L.elem[i]==e)
            cout<<i+1;
}

//顺序表的插入
int ListInsert(SqList &L,int i,int e)
{
    int j;
    if(i<1||i>L.length)
        return -1;
    if(L.length==MAXSIZE)
        return -1;
    //将要插入的位置后面每一个元素朝后移动一位
    for(j=L.length-1;j>=i-1;j--)
    {
        L.elem[j+1]=L.elem[j];
    }
    L.elem[i-1]=e;//插入位置赋予插入值
    L.length++;//插入后表长度加1
    return 1;
}

//顺序表的删除
int ListDelete(SqList &L,int i)
{
    int j;
    if(i<1||i>L.length)
        return -1;
    for(j=i;j<=L.length;j++)
        L.elem[j-1]=L.elem[j];
    L.length--;
    return 1;
}

//插入创建顺序表
void CreatList(SqList &L)
{
    int x;
    int i=0;
    cin>>x;
    while(x!=0)
    {
        L.elem[i]=x;
        i++;
        L.length++;
        cin>>x;
    }
}

//遍历输出顺序表
void ListPrint(SqList L)
{
    int i;
    for(i=0;i<L.length;i++)
        cout<<L.elem[i]<<" ";
}

int main()
{
    //在这里就不一一测试了，但经过个人测试，代码是正确无误的
    //代码参考的是严蔚敏教授的数据结构第二版
    SqList L;
    InitList(L);
    CreatList(L);
    ListPrint(L);
}

顺序表的一些特点:

1. 存储位置具有顺序性，因此结构比较简单。也很容易查找到元素在线性表中的位置。
2. 3. 插入，删除操作不方便，当顺序表表长较大的时候，插入或者删除操作移动的元素很多，导致操作不方便。
3. 数组的长度有相对的固定性当顺序表中的元素变化较多时，操作过程很复杂。而且容易导致存储空间的浪费

线性表的链式表示和实现

定义：用一组任意的存储单元存储线性表中的元素（可以连续也可以不连续，注意：不是一定不连续），用另一个区域表示他们之间的逻辑关系。这样的结构叫做链表。

链表是一种顺序存储结构

//单链表存储结构
typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode,*LinkList;

说明
（1）关于单链表的头头节点的问题：为什么会带有头节点，带一个头节点的主要目的是为了统一节点间的操作
如果一个单链表不带头结点那么单链表的第一个节点需要特殊处理。所以加入头节点。
（2）为了提高程序的可读性，对同一个结构体指针类型取了两个名字，LinkList和*LNode。两者本质上面是等价
的通常习惯上用LinkList定义单链表，强调定义的是单链表的头指针。LNode *p为指向任意节点的指针变量。但是也可以用LinkList p定义。两者本质上等价，是为了增加程序可读性定义的。
（3）单链表的表头指针是唯一确定的，因此单链表可以用头指针的名字命名

#include <iostream>
using namespace std;

typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;



void InitList(LinkList &L)
{
    L=new LNode;
    L->next=NULL;
}

//单链表的取值
int GetElem(LinkList L, int i, int &e)
{
    LNode *p;
    int j=1;
    while(p && j<i)
    {
        p=p->next;
        j++;
    }
    if(!p || j>i)
        return -1;
    e=p->data;
    return  1;

}

//单链表的按值查找
LNode *LocateElem(LinkList L, int e)
{
    LNode *p;
    p=L->next;
    while(p && p->data!=e)
        p=p->next;
    return p;
}

//单链表的插入
int ListInsert(LinkList &L,int i,int e)
{
    LNode *p;
    p=L;
    int j=0;
    while(!p||(j<i-1))
    {
        p=p->next;
        j++;
    }
    if(!p||j>i-1)
        return -1;
    LNode *s;
    s=new LNode;
    s->data=e;
    s->next=p->next;
    p->next=s;
    return 1;
}

//单链表的删除
int ListDelete(LinkList &L,int i)
{
    LNode *p=L;
    int j=0;
    while(p && j<i-1)
    {
        p=p->next;
        j++;
    }
    if(!p->next||(j>i-1))
        return -1;
    LNode *q;
    q=p->next;
    p->next=q->next;
    delete q;
    return 1;
}


//单链表的创建(前插)
void CreatList_Qian(LinkList &L)
{
    L=new LNode;
    L->next=NULL;
    LNode *p;
    int x;
    cin>>x;
    while(x!=0)
    {
        p=new LNode;
        p->data=x;
        p->next=L->next;
        L->next=p;
        cin>>x;
    }
}

void CreatList_Back(LinkList &L)
{
    L=new LNode;
    L->next=NULL;
    LNode *p;
    LNode *r=L;
    int x;
    cin>>x;
    while(x!=0)
    {
        p=new LNode;
        p->data=x;
        p->next=NULL;
        r->next=p;
        r=p;
        cin>>x;
    }
}

//打印单链表
void ListPrint(LinkList L)
{
    LNode *p;
    p=L->next;
    while(p!=NULL)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
}

int main()
{
    LinkList L;
    InitList(L);
    CreatList_Back(L);
    ListPrint(L);
    return 0;


}

TIps：循环链表和双向链表单独介绍