数据结构-单链表基础操作

1 头插法建立单链表（带头结点）：

LinkList List_HeadInsert(LinkList &L){      //逆向建立单链表
    LNode *s; int x;                        
    L = (LinkList)malloc(sizeof(LNode));    //创建头结点
    L->next = NULL;                         //初始化空链表
    scanf("%d", &x);                        //输入结点的值
    while(x != 9999){                       //输入9999表示结束
        s = (LNode*)malloc(sizeof(LNode));  //创建新结点
        s->data = x;
        s->next = L->next;
        L->next = s;                        //将新结点插入表中，L为头指针
        scanf("%d", &x);    
    }
    return L;
}

（不带头结点）

LinkList List_HeadInsert(LinkList &L){      //逆向建立单链表
    LNode *s; int x;                        
    L = NULL;                               //初始化空链表
    scanf("%d", &x);                        //输入结点的值
    while(x != 9999){                       //输入9999表示结束
        s = (LNode*)malloc(sizeof(LNode));  //创建新结点
        s->data = x;
        s->next = L;
        L = s;                              //将新结点插入表中，L为头指针
        scanf("%d", &x);    
    }
    return L;
}

2 尾插法建立单链表（带头结点）

LinkList List_TailInsert(LinkList &L){        //正向建立单链表
    int x;                                    //设置元素类型为整型
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;                     
    LNode *s,*r = L;                          //r为表尾指针
    scanf("%d", &x);                          //输入结点的值
    while(x ！= 9999){                        //输入9999表示结束
        s = (LNode *)malloc(sizrof(LNode));  
        s->data = x;
        r->next = s;
        r = s;                                //r指向新的表尾结点
        scanf("%d", &x);    
    }
    r->next = NULL;                           //尾结点指针置空
    return L;
}

（不带头结点）

LinkList List_TailInsert(LinkList &L){        //正向建立单链表
    int x;                                    //设置元素类型为整型
    L = NULL;                     
    LNode *s,*r = NULL;                       //r为表尾指针
    scanf("%d", &x);                          //输入结点的值
    while(x ！= 9999){                        //输入9999表示结束
        s = (LNode *)malloc(sizrof(LNode));  
        s->data = x;
        if(r == NULL){
            L = s;
            r = s;
        }
        else{
            r->next = s;
            r = s;                            //r指向新的表尾结点
        }                            
        scanf("%d", &x);    
    }
    r->next = NULL;                           //尾结点指针置空
    return L;
}

3 按序号查找结点值

LNode *GetElem(LinkList L, int i){
    int j = 1;                       //计数，初始为1
    LNode *p = L->next;              //头结点指针赋给p
    if(i == 0){
        return L;                    //若i等于0，则返回头结点
    }
    if(i < 1){
        return NULL;                 //若i无效，则返回NULL
    }
    while(p && j < i){               //从第1个结点开始找，查找第i个结点
        p = p->next;
        j++;
    }
    return p;                        //返回第i个结点的指针，若i大于表长，则返回NULL
}

4 按值查找表结点

LNode *LocateElem(LinkList L,ELemType e){
    LNode *p = L->next;
    while(p != NULL && p->data != e){        //从第1个结点开始查找data为e的结点
        p = p->next;
    }
    return p;                                //找到后返回该节点指针，否则返回NULL
}

5 插入结点（带头结点）

bool ListInsert(LinkList &L, int i, ElemType e){
    if(i < 1)
        return false;
    LNode *p;                                      //指针p指向当前扫描到的结点
    int j = 0;                                     //当前p指向的是第几个结点
    p = L;                                         //L指向头结点，头结点是第0个几点
    while(p != NULL && j < i-1){                   //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL)                                  //i值不合法
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = a;
    s->next = p->next;
    p->next = s;                                   //将结点s连到p之后
    return true;                                   //插入成功
}

（不带头结点）

bool ListInsert(LinkList &L, int i, ElemType e){
    if(i < 1)
        return false;
    if(i == 1){                                    //插入第1个结点的操作与其他结点操作不同
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        L = s;                                     //头指针指向新结点
        return true;
    }
    LNode *p;                                      //指针p指向当前扫描到的结点
    int j = 0;                                     //当前p指向的是第几个结点
    p = L;                                         //L指向头结点，头结点是第0个几点
    while(p != NULL && j < i-1){                   //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL)                                  //i值不合法
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = a;
    s->next = p->next;
    p->next = s;                                   //将结点s连到p之后
    return true;                                   //插入成功
}

6 指定结点的前插

bool InsetPriorNode(LNode *p, ElemType e){
    if(p == NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s == NULL)                                //内存分配失败
        return false;
    s->next = p->next;
    p->next = s;                                 //将结点s连到p之后
    s->data = p->data;                           //将p中元素复制到s中
    p->data = e;                                 //p中元素覆盖为e
    return true;
}

7 删除结点（带头结点）

bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i < 1)
        return false;
    LNode *p;                                 //当前指针扫描到的结点
    int j = 0;                                //当前p指向的是第几个结点
    p = L;                                    //L指向头结点，头结点是第0个节点
    while(p != NULL && j < i-1){              //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL)                             //i值不合法
        return false;
    if(p->next == NULL)                       //第i-1个结点之后已无其他结点
        return false;
    LNode *q = p->next;                       //令q指向被删除结点
    e = q->data;                              //用e返回元素的值
    p->next = q->next;                        //讲*q结点从链中断开
    free(q);                                  //释放结点的存储空间
    return true;                              //删除成功
}

（不带头结点）

bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i < 1)
        return false;
    if(i == 1){
        LNode *q = L;
        L = q->next;
        e = q->data;
        free(q);
        return true;
    }
    LNode *p;                                 //当前指针扫描到的结点
    int j = 0;                                //当前p指向的是第几个结点
    p = L;                                    //L指向头结点，头结点是第0个节点
    while(p != NULL && j < i-1){              //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if(p == NULL)                             //i值不合法
        return false;
    if(p->next == NULL)                       //第i-1个结点之后已无其他结点
        return false;
    LNode *q = p->next;                       //令q指向被删除结点
    e = q->data;                              //用e返回元素的值
    p->next = q->next;                        //讲*q结点从链中断开
    free(q);                                  //释放结点的存储空间
    return true;                              //删除成功
}

8 求表长（带头结点）

int Length(LinkList L){
    int len = 0;              //统计表长
    LNode *p = L; 
    while(p->next != NULL){
        p = p->next;
        len++;   
    }
    return len;
}

（不带头结点）

int Length(LinkList L){
    int len = 0;              //统计表长
    LNode *p = L; 
    if(p == NULL){            //表为空
        return len;
    }
    while(p != NULL){
        p = p->next;
        len++;   
    }
    return len;
}