单链表

   单链表是一种最基本的数据结构，也是线性表中最基本的数据结构。至于什么是单链表，看官可以回忆一下大学老师的讲解或者去度娘那儿看看。下面结合代码聊一聊单链表的建立 查找 插入 删除以及整表删除。  

//单链表的初始化，建立，插入，查找，删除。//
 
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType，Status;
//定义结点类型 
typedef struct Node
{
    ElemType data;              //单链表中的数据域 
    struct Node *next;          //单链表的指针域 
}Node,*LinkList;

//单链表的建立1，头插法建立单链表
LinkList LinkListCreatH()
{
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                     //初始化一个空链表

    ElemType x;                         //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF)
    {
        Node *p;
        p = (Node *)malloc(sizeof(Node));   //申请新的结点 
        p->data = x;                        //结点数据域赋值 
        p->next = L->next;                  //将结点插入到表头L-->|2|-->|1|-->NULL 
        L->next = p; 
    }
    return L; 
} 

//单链表的建立2，尾插法建立单链表
LinkList LinkListCreatT()
{
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                 //初始化一个空链表
    Node *r;
    r = L;                          //r始终指向终端结点，开始时指向头结点 
    ElemType x;                         //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF)
    {
        Node *p;
        p = (Node *)malloc(sizeof(Node));   //申请新的结点 
        p->data = x;                        //结点数据域赋值 
        r->next = p;                    //将结点插入到表头L-->|1|-->|2|-->NULL 
        r = p; 
    }
    r->next = NULL; 

    return L;   
}

//单链表的整表删除，将整个单链表L删除
Status ClearList(LinkList *L)
{
    LinkList p,q;
    p = (*L)->next;                       /*p指向第一个结点*/
    while(p)                             /*没到表尾*/
    {
       q = p->next;
       free(p);
       p = q;
    }
    (*L)->next = NULL;                  /*把头结点指针域置空*/
    return OK;
}

//单链表的按序号查找,查找单链表L中序号为i的结点
Node* GetNode(LinkList L,int i)
{
    int j;
    Node *p; 
    p = L; j = 0;               //从头开始扫描
    while(p->next && j<i){      //依次向后扫描，直到p->next为NULL或i=j为止
    p = p-> next;
    j++;
    }
    if(i == j)
        return p;              //找到了第i个结点
    else return NULL;          //没有找到第i个结点
}

//单链表的按值查找，查找单链表L中值为key的结点
Node* LocateNode(LinkList L,ElemType key)
{
    Node* p = L->next;                //从开始结点比较
    while(p&&p->data!=x)              //直到p为NULL或p->data为key为止
        p = p->next;              //扫描下一个结点
    return p;                         //若p=NULL,则查找失败，否则p指向值为key的结点
}
//单链表的插入，在链表的第i个位置插入x的元素
LinkList LinkListInsert(LinkList L,int i,ElemType x)
{
    Node *pre;                      //pre为前驱结点 
    pre = L;
    int tempi = 0;
    for (tempi = 1; tempi < i; tempi++)
        pre = pre->next;                    //查找第i个位置的前驱结点 
    Node *p;                                //插入的结点为p
    p = (Node *)malloc(sizeof(Node));       //申请空间
    p->data = x;                            //给数据域赋值
    p->next = pre->next;                    //下面这两行代码是单链表插入算法的核心：分别修                                                             改前驱结点和待插入结点的指向
    pre->next = p;

    return L;                           
} 

//单链表的删除，在链表中删除值为x的元素
LinkList LinkListDelete(LinkList L,ElemType x)
{
    Node *p,*pre;                   //pre为前驱结点，p为查找的结点。 
    p = L->next;
    while(p->data != x)             //查找值为x的元素 
    {   
        pre = p; 
        p = p->next;
    }
    pre->next = p->next;            //删除操作，将其前驱next指向其后继。 
    free(p);
    return L;
} 
//主函数
int main()
{
    LinkList list,start;
    printf("请输入单链表的数据："); 
    list = LinkListCreatT();
    for(start = list->next; start != NULL; start = start->next)  //遍历整个单链表（可演化为查找）
        printf("%d ",start->data);
    printf("/n");
    int i;
    ElemType x;
    printf("请输入插入数据的位置：");
    scanf("%d",&i);
    printf("请输入插入数据的值：");
    scanf("%d",&x);
    LinkListInsert(list,i,x);
    for(start = list->next; start != NULL; start = start->next)
        printf("%d ",start->data);
    printf("/n");
    printf("请输入要删除的元素的值：");
    scanf("%d",&x);
    LinkListDelete(list,x); 
    for(start = list->next; start != NULL; start = start->next)
        printf("%d ",start->data);
    printf("/n");

    return 0;
} 

    每种数据结构都要考虑性能，单链表的性能主要考虑空间复杂度和时间复杂度，空间复杂度嘛结点越多占的空间越多，完全是线性的。空间复杂度在插入 查找 删除中最坏的情况无非也就是O(n)了。