单链表的定义及操作（C++）

单链表的定义

typedef int ElemType;

typedef struct LNode{
    ElemType val;
    LNode * next;
} LinkNode;

单链表的基本操作

void InitList(LinkNode *&);                    // 初始化线性表
void DestroyList(LinkNode *&);                 // 销毁线性表
bool ListEmpty(LinkNode *);                    // 判定线性表是否为空
int ListLength(LinkNode *);                    // 获得线性表长度
void ShowList(LinkNode *);                     // 输出线性表
bool GetElem(LinkNode *, int, ElemType &);     // 获得第i个元素的值，存储到e中
int LocateElem(LinkNode *, ElemType);          // 查找元素e第一次出现的位置，不存在返回0
bool ListInsert(LinkNode *&, int, ElemType);   // 再第i个位置插入元素e
bool ListDelete(LinkNode *&, int, ElemType &); // 删除第i个元素，并存储到e中

void InitList(LinkNode * &L) {
    L = (LinkNode *)malloc(sizeof(LinkNode));
    L -> next = NULL;
}

void DestroyList(LinkNode * &L) {
    LinkNode * pre = L -> next, * p;
    L -> next = NULL;
    while (pre != NULL) {
        p = pre;
        pre = pre -> next;
        free(p);
    }
    free(pre);
}

bool ListEmpty(LinkNode * L) {
    return L -> next == NULL;
}

int ListLength(LinkNode * L) {
    int i = 0;
    while (L -> next != NULL) {
        i++;
        L = L -> next;
    }
    return i;
}

void ShowList(LinkNode * L) {
    if (L -> next == NULL) {
        printf("[L]\n");
        return ;
    }
    printf("[L -> ");
    LinkNode * p = L -> next;
    while (p -> next != NULL) {
        printf("%d -> ", p -> val);
        p = p -> next;
    }
    printf("%d]\n", p -> val);
}

bool GetElem(LinkNode * L, int i, ElemType &e) {
    int j = 0;
    while (L -> next != NULL && j < i) {
        j++;
        L = L -> next;
    }
    if (j == i) {
        e = L -> val;
        return true;
    }
    return false;
}

int LocateElem(LinkNode * L, ElemType e) {
    int i = 0;
    while (L -> next != NULL) {
        i++;
        L = L -> next;
        if (L -> val == e) {
            return i;
        }
    }
    return 0;
}

bool ListInsert(LinkNode * &L, int i, ElemType e) {
    if (i < 1) return false;
    int j = 1;
    LinkNode * p = L;
    while (p != NULL && j < i) {
        p = p -> next;
        j++;
    }
    if (j == i) {
        LinkNode * target;
        target = (LinkNode *)malloc(sizeof(LinkNode));
        target -> val = e;
        target -> next = p -> next;
        p -> next = target;
        return true;
    }
    return false;
}

bool ListDelete(LinkNode * &L, int i, ElemType &e) {
    if (i < 1) return false;
    int j = 1;
    LinkNode * p = L;
    while (p != NULL && j < i) {
        p = p -> next;
        j++;
    }
    if (j == i) {
        e = p -> next -> val;
        p -> next = p -> next -> next;
        return true;
    }
    return false;
}

单链表的基本算法

void CreateListF(LinkNode *&, ElemType [], int); // 头插法建表
void CreateListR(LinkNode *&, ElemType [], int); // 尾插法建表
ElemType MidList(LinkNode *);                    // 双指针返回链表中结点的值
int MidNumList(LinkNode *);                      // 双指针返回链表中结点的位置
void Reverse(LinkNode *&);                       // 翻转链表

void CreateListF(LinkNode * &L, ElemType a[], int n) {
    L = (LinkNode *)malloc(sizeof(LinkNode));
    L -> next = NULL;
    for (int i = 0; i < n; i++) {
        LinkNode * p = (LinkNode *)malloc(sizeof(LinkNode));
        p -> val = a[i];
        p -> next = L -> next;
        L -> next = p;
    }
}

void CreateListR(LinkNode * &L, ElemType a[], int n) {
    L = (LinkNode *)malloc(sizeof(LinkNode));
    LinkNode * r = L;
    for (int i = 0; i < n; i++) {
        LinkNode * p = (LinkNode *)malloc(sizeof(LinkNode));
        p -> val = a[i];
        r -> next = p;
        r = p;
    }
    r -> next = NULL;
}

ElemType MidList(LinkNode * L) {
    LinkNode * i = L -> next;
    LinkNode * j = i -> next;
    while (j -> next != NULL) {
        j = j -> next;
        i = i -> next;
        if (j -> next != NULL) j = j -> next;
    }
    return i -> val;
}

int MidNumList(LinkNode * L) {
    LinkNode * i = L -> next;
    LinkNode * j = i -> next;
    int index = 1;
    while (j -> next != NULL) {
        index++;
        j = j -> next;
        i = i -> next;
        if (j -> next != NULL) j = j -> next;
    }
    return index;
}

void Reverse(LinkNode * &L) {
    LinkNode * p = L -> next, * q;
    L -> next = NULL;
    while (p != NULL) {
        q = p -> next; 
        p -> next = L -> next;
        L -> next = p;
        p = q;
    }
}