线性表之 单链表

为什么需要单链表：顺序表中的插入，删除，需要移动大量的元素，影响存储效率。

单链表的基本操作（都在这个案例中）：

#include<cstdio>
#include<iostream>
#include<cstdlib>
using namespace std;
typedef struct LNode///链表中的结点
{
    int data;   ///数据域
    struct LNode *next; ///指针域
} LNode,*LinkList;///struct LNode 的别名为LNode；struct LNode* 的别名为LinkList

/*
从表尾到表头逆向建立单链表L，每次均在头结点之后插入元素
*/
LinkList List_HeadInsert(LinkList &L)///函数的返回值为结点的地址；链表的头结点的地址的别名为L
{
    LinkList s;
    int x;
    L=(LinkList)malloc(sizeof(LNode));///创建头指针：分配空间+地址转换
    L->next=NULL;
    while(scanf("%d",&x)!=EOF)
    {
        s=(LNode *)malloc(sizeof(LNode));///创建新的结点
        s->data=x;
        s->next=L->next;
        L->next=s;
    }
    return L;///返回链表头结点的地址；链表最重要的就是头结点，掌握了头结点的地址就掌握了链表
}

/*
从表头到表尾正向建立单链表L，每次均在表尾插入元素
*/
LinkList List_TailInsert(LinkList &L)
{
    int x;
    L=(LinkList)malloc(sizeof(LNode));///创建头指针
    LinkList s,r=L;///r为尾指针，保存着尾结点的地址
    while(scanf("%d",&x)!=EOF)///每输入一个值就创建一个结点
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;///r->next 表示的是最后一个结点的指针域
        r=s;    ///r存s的地址，s作为尾结点
    }
    r->next=NULL;
    return L;///返回链表的头结点
}

/*
取出单链表L中第i个位置的结点指针
*/
LinkList GetElem(LinkList &L,int i)
{
    int k=1;
    LinkList p=L->next;///p中存放头结点的地址
    if(i==0) return L;
    if(i<1) return NULL;
    while(p&&k<i)
    {
        p=p->next;
        k++;
    }
    return p;
}

/*
查找单链表中数据域等于e的节点，并返回结点指针
*/
LinkList LocateElem(LinkList L,int e)
{
    LNode *p=L->next;///常规操作，先取出头结点的地址
    while(p!=NULL&&p->data!=e)
    {
        p=p->next;
    }
    return p;
}

/*
将值为x的新节点插入到单链表的第i个位置上。
（1）先检查插入位置的合法性
（2）找到待插入结点的前驱结点，在其后插入新结点
*/
LinkList List_Insert(LinkList &L,int i,int x)
{
    if(i<0) return NULL;
    LinkList p=GetElem(L,i-1);
   LinkList  s=(LinkList)malloc(sizeof(LNode));
    s->data=x;
    s->next=p->next;
    p->next=s;
    return L;
}
/*
删除链表中第i个元素，并用e返回删除元素的值
*/
LinkList List_Delete(LinkList &L,int i,int &e)
{
    if(i<0) return NULL;
    LinkList p=GetElem(L,i-1);///被删除结点的前驱结点
    LinkList q=p->next;       ///被删除的结点
    p->next=q->next;  ///p保存q的后继结点的地址，p指向q的后继结点；
    free(q);
    return L;
}

/*
求单链表的表长
*/
int List_length(LinkList L)
{
    int k=0;
    LinkList p=L->next;///p指向头结点
    while(p)///这个循环的魅力在哪：如果p不为空，k加1
    {
        k++;
        p=p->next;
    }
    return k;
}

/*
输出链表中所有元素的值，并返回元素的数量
*/
int List_Traverse(LinkList L)
{
    int Count=0;
    LinkList p=L->next;
    while(p)///如果p不为空，Count加1，然后输出p
    {
        Count++;
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
    return Count;
}
int main()
{
      LinkList LHead=List_HeadInsert(LHead);///头插法建立单链表
      cout<<List_Traverse(LHead)<<endl;///输入：1 2 3 4 5 6 7 8 9  输出：9 8 7 6 5 4 3 2 1
      LinkList LTail=List_TailInsert(LTail);///尾插法建立单链表
      cout<<List_Traverse(LTail)<<endl;  ///输入：1 2 3 4 5 6 7 8 9  输出：1 2 3 4 5 6 7 8 9
      LHead=List_Insert(LHead,3,99);///在第三个位置插入99
      cout<<List_Traverse(LHead)<<endl;
      int e;
      LHead=List_Delete(LHead,3,e);///删除第三个位置的值，并用e返回
      cout<<List_Traverse(LHead)<<endl;
}