[辉哥带我学数据结构-3] 线性表的链式表示与实现~~未完待续~~~

本节课就是传说中的链表，在顺序表中只有一个结构体，这个结构体存储了一个链表结构，在链表中有多个结构体，每一个结构体都是链表的一个元素，这种结构体类型含有两种元素，一种就是这个节点的数值data，另一种就是指向下一个结构体的指针next。data就是ElemType类型，next就是结构体指针类型而非指向ElemType类型的指针类型。

节点结构体的类型实现

typedef  int  ElemType;  //元素类型
    typedef struct node{
        ElemType data;
        struct node *next;
    }LinkNode, *LinkList;

这个结构体含有两个域，一个叫做数据域data，一个叫做指针域next，data就是该节点的元素，next就是指向下一个节点的指针。

头节点，头指针，首元节点：

首元节点就是链表内第一个其data具有实际意义的节点，也就是说首元节点在增删改查的过程中不能被忽视的节点。

头节点就是第一个节点，头节点既可以当作链表内有实际元素的一部分和首元节点是一个节点，也可以当作一个在首元节点之前的一个节点。

头指针有两种类别，如果你这个链表没有头节点，第一个节点就是首元节点，那么头指针指向的就是第一个节点——首元节点；

如果你这个链表含有头节点，那么头指针指向的就是第一个节点——头节点。

下面就是具体的实现步骤：

DS.h

DS.h
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef int Status;

LinkList.h

#include "DS.h"

typedef int Elemtype;

typedef struct Node
{
    Elemtype  data;
	struct Node *next;
}Lnode,*LinkList;

void menu();                            /*菜单*/
Status Init_Linklist(LinkList &L);           /*初始化空表*/
Status Creat_Linklist(LinkList &L);         /*尾插法建立单链表*/
void Disp_Linklist(LinkList L);             /*单链表遍历*/
int length_Linklist(LinkList L);             /*计算单链表长度*/
void Reverse_Linklist(LinkList L);         /*单链表逆置*/
void DelEven_Linklist(LinkList L);         /*删除值为偶数的结点*/
Status Insert_Linklist(LinkList L, int x);     /*在有序单链表L中插入元素x，链表仍然有序*/
Status CreatOrder_Linklist(LinkList &L);   /*创建非递减有序单链表*/
void MergeDescend_Linklist(LinkList La, LinkList Lb, LinkList &Lc);  /*两个非递减有序单链表La和Lb合并成一个非递增有序链表Lc*/
void MergeAscend_Linklist(LinkList La, LinkList Lb, LinkList &Lc); /*两个非递减有序单链表La和Lb合并成一个非递减有序链表Lc*/
void Split_Linklist(LinkList La, LinkList &Lb);  /*链表La按值分解成两个链表，La全部为奇数，Lb全部为偶数*/

LinkList.cpp

#include "LinkList.h"

void menu()
{
    printf("\t\t\t   单链表基本操作\n\n");
    printf("\t\t\t1.建  立  单  链  表\n");
    printf("\t\t\t2.遍  历  单  链  表\n");
    printf("\t\t\t3.计  算  链 表 长 度\n");
    printf("\t\t\t4.链  表  逆  置\n");
    printf("\t\t\t5.删  除  偶 数 节 点\n");
    printf("\t\t\t6.生 成 值 有 序 单 链 表\n");
    printf("\t\t\t7.合  并 生 成 降  序  链 表\n");
    printf("\t\t\t8.合  并 生 成 升  序  链 表\n");
    printf("\t\t\t9.分  解  链  表\n");
    printf("\t\t\t0.退          出\n\n");
}

/*初始化空表*/
Status Init_Linklist(LinkList &L)
{
    L=(LinkList)malloc(sizeof(Lnode));
    if(!L) return ERROR;
	L->next=NULL;
	return OK;
}

/*尾插法建立单链表*/
Status Creat_Linklist(LinkList &L)
{
    int x;
    LinkList p,rear;
    Init_Linklist(L);
    rear = L;
    printf("输入-1表示输入结束\n");
    while(scanf("%d",&x),x != -1)
    {
        p = (LinkList)malloc(sizeof(Lnode));
        if(!p) return ERROR;
        p->data = x;
        rear->next = p;
        rear = p;
    }
    rear->next = NULL;
    return OK;
}

/*单链表遍历*/
void Disp_Linklist(LinkList L)
{
    LinkList p;
    p = L->next;
    while(p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

/*计算单链表长度*/
int length_Linklist(LinkList L)
{
    int count = 0;   /*count表示单链表长度*/
    LinkList p;
    

    return count;
}

/*单链表逆置*/
void Reverse_Linklist(LinkList L)
{
    LinkList p, q ;
    

}

/*删除值为偶数的结点*/
void DelEven_Linklist(LinkList L)
{
    LinkList p, q;    

}

/*在有序单链表中插入元素，链表仍然有序，插入成功返回OK，插入失败返回ERROR*/
Status Insert_Linklist(LinkList L, int x)
{
    ;
}

/*创建非递减有序单链表，创建成功返回OK，创建失败返回ERROR*/
Status CreatOrder_Linklist(LinkList &L)
{
    
}

/*两个非递减有序单链表La和Lb合并成一个非递增有序链表Lc*/
void MergeDescend_Linklist(LinkList La, LinkList Lb, LinkList &Lc)
{
    
}

/*两个非递减有序单链表La和Lb合并成一个非递减有序链表Lc*/
void MergeAscend_Linklist(LinkList La, LinkList Lb, LinkList &Lc)
{
    LinkList pa, pb, pc;
    pa = La->next;
    pb = Lb->next;
    pc = Lc = La;
    while(pa && pb)
    {
        if(pa->data <= pb->data)
        {
            pc->next = pa; pc = pa; pa = pa->next;
        }
        else
        {
            pc->next = pb; pc = pb; pb = pb->next;
        }
    }
    pc->next = pa ? pa : pb;
    free(Lb);
}

/*链表La按值分解成两个链表，La全部为奇数，Lb全部为偶数*/
void Split_Linklist(LinkList La, LinkList &Lb)
{
    
}

main.cpp

#include "LinkList.h"

int main()
{
    int choice, length;
    LinkList L, La, Lb, Lc;
    while(1)
    {
        menu();
        printf("选择你的操作：");
        scanf("%d",&choice);
        switch(choice)
        {
            case 1:
                if(Creat_Linklist(L))
                    printf("单链表创建成功\n");
                else
                    printf("单链表创建失败\n");
                break;
            case 2:
                Disp_Linklist(L);
                break;
            case 3:
                length = length_Linklist(L);
                printf("单链表长度为：%d\n",length);
                break;
            case 4:
                Reverse_Linklist(L);
                printf("逆置后的链表为：\n");
                Disp_Linklist(L);
                break;
            case 5:
                DelEven_Linklist(L);
                printf("新链表为：\n");
                Disp_Linklist(L);
                break;
            case 6:
                if(CreatOrder_Linklist(L))
                {
                    printf("值有序链表为：\n");
                    Disp_Linklist(L);
                }
                else
                    printf("单链表创建失败\n");
                break;
            case 7:
                CreatOrder_Linklist(La);
                CreatOrder_Linklist(Lb);
                MergeDescend_Linklist(La, Lb, Lc);
                printf("合并后的新链表为：\n");Disp_Linklist(Lc);
                break;
            case 8:
                CreatOrder_Linklist(La);
                CreatOrder_Linklist(Lb);
                MergeAscend_Linklist(La, Lb, Lc);
                printf("合并后的新链表为：\n");Disp_Linklist(Lc);
                break;
            case 9:
                Creat_Linklist(L);
                Split_Linklist(L, Lb);
                printf("分裂后的新链表为：\n");
                Disp_Linklist(L);
                Disp_Linklist(Lb);
                break;
            case 0:
                return 0;
            default:
                printf("输入错误，请重新输入\n");
        }
    }
}

其中的一些功能还没有补全，未完待续~~~~~

以上只是一些单链表的实现，单链表只能按照顺序指向下一个节点，除此之外还有双链表、循环链表。双链表除了可以指向下一个节点之外，还有一个指针指向上一个节点，这样就可以去双向访问；循环链表即最后一个节点的指针并不指向空，而是指向首元节点。