带虚拟头结点的单向链表的实现

        单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点；

        链表是由结点构成，head指针指向第一个成为表头结点，而终止于最后一个指向NULL的指针。

        带虚虚拟头结点的链表定义分为结点定义和链表(头)定义;

结点定义:

struct ListNode{
    int val;    //结点的权值
    ListNode *next;
};

链表(头)定义:

struct LinkList{
    ListNode head;
};

由于虚拟头结点head里面存在一个val变量，这里的链表实现将该变量作为链表长度并维护

        一个数据结构的操作一般包含以下几个部分:

1. 容器的初始化: 这里除了需要对链表的初始化，还需要对结点初始化；

初始化一个结点并返回:

ListNode *initListNode(int val){
    ListNode *node = (ListNode *)malloc(sizeof(ListNode));
    node->val = val;
    node->next = NULL;    //为避免不必要的RE，新结点的next指针一般需要置空
    return node;
}

初始化一个表头并返回:

LinkList *initLinkList(){
    LinkList *list = (LinkList *)malloc(sizeof(LinkList));
    list->head.next = NULL;
    list->head.val = 0;    //初始链表长度为0
    return list;
}

2. 容器的清空和销毁: 同上，为避免销毁空指针RE，也需要将结点的销毁封装；

结点的销毁:

void clearListNode(ListNode *node){
    if(node == NULL) return;
    free(node);
    return;
}

链表的清空:

void clearLinkList(LinkList *list){
    if(list == NULL) return; //保证操作的合法性
    ListNode *p = list->head.next, *q;
    //注意这里*q是必须的
    //不然是访问非法空间的非法操作(指的是clearListNode(p)之后访问p->next->next)
    while(p){
        q = p->next;
        clearListNode(p);
        p = q;
    }
    
    list->head.val = 0;
    list->head.next = NULL;
    return;
}

链表的销毁:

void destroyLinkList(LinkList *list){
    if(list == NULL) return;
    clearLinkList(list);    //!!!
    free(list);
    return;
}

3. 元素的增、删、改、查；

(图片来自网络，侵删)

插入操作:

bool insert(LinkList *list, int index, int val){
	if(list == NULL) return false;
	if(index < 0 || index > list->head.val) return false;
	
	ListNode *node = initListNode(val);    //新建一个权值为val的结点; 
	ListNode *p = &(list->head);
	while(index--){
		p = p->next;
	}
	//实质上是将p点走到了待插入结点的前一个结点, 显然p->next是待插入结点的后一个结点
    //此时p就是图中的b点，p->next是c点
	node->next = p->next;
	p->next = node;
	
	list->head.val++;    //头结点的val值保存长度, 插入成功length++;
	return true;
}

删除操作:

bool erase(LinkList *list, int index){
	if(list == NULL) return false;
	if(index < 0 || index >= list->head.val) return false;
	
	ListNode *p = &(list->head);
	while(index--) p = p->next;
	
    //此时p点即是a点, q点即是c点, 而待删除的点就是p->next;
	ListNode *q = p->next->next;    //防止RE
	clearListNode(p->next);
	p->next = q;
	
	list->head.val--;    //维护链表的长度信息
	return true;
}

修改(更新)操作:        类似于删除，较容易实现

bool update(LinkList *list, int index, int val){
	if(list == NULL) return false;
	if(index < 0 || index >= list->head.val) return false;
	
	ListNode *p = list->head.next;
	while(index--){
		p = p->next;
	}
	
	p->val = val;
	return true;
}

查询操作:        查询权值为val的元素是否存在, 若存在返回其下标(从0开始), 不存在返回-1

int find(LinkList *list, int val){
	if(list == NULL) return -1;
	ListNode *p = list->head.next;
	
	int res = 0;
	while(p){
		if(p->val == val){
			return res;
		}
		res++;
		p = p->next;
	}
	
	return -1;
}
#define 

(Debug时常用)4. 容器的遍历:        这里通过输出直观感受遍历效果

void output(LinkList *list){
    if(list == NULL) return;
    printf("LinkList(%d): ", list->head.val);
    for(ListNode *p = list->head.next; p; p = p->next)
        printf("%d-> ", p->val);
    puts("NULL");
    return;
}

下面是完整代码:

#include<iostream>
#include<algorithm>
#include<ctime>
#include<vector>
using namespace std;
typedef struct ListNode{
	int val;
	ListNode *next;
}ListNode;


typedef struct LinkList{
	ListNode head, *tail;
	void output(){
		printf("LinkList(%d) : ", head.val);
		ListNode *p = head.next;
		for(int i = 0; i < head.val; i++, p = p->next){  //
			printf("%d -> ", p->val);
		}
		printf("NULL\n");
	}
}LinkList;


//void add_to_head(LinkList *list, int val){
//	if(list == NULL) return;
//	ListNode *node = initListNode(val);
//	node->next = list->head;
//	list->head = node;
//	list->head.val++;
//	return;
//}
ListNode *initListNode(int val){
	ListNode *node = (ListNode *)malloc(sizeof(ListNode));
	node->val = val;
	node->next = NULL;
	return node;
}

LinkList *initLinkList(){
	LinkList* list = (LinkList *)malloc(sizeof(LinkList));
	list->head.next = NULL;
	list->head.val = 0;
	list->tail = &(list->head);
	return list;
}

void clearListNode(ListNode *node){
	if(node == NULL) return;
	free(node);
	return; 
}

void clearLinkList(LinkList *list){
	if(list == NULL) return;
	ListNode *p = list->head.next, *q;
	while(p){
		q = p->next;
		clearListNode(p);
		p = q;
	}
	
	free(list);
	return;
}

bool insert(LinkList *list, int index, int val){
	if(list == NULL) return false;
	if(index < 0 || index > list->head.val) return false;
	
	ListNode *node = initListNode(val);
	if(index == list->head.val){
		list->tail->next = node;
		list->tail = node;
		list->tail->next = &(list->head);
		list->head.val++;
		return true;
	}
	
	ListNode *p = &(list->head);
	while(index--){
		p = p->next;
	}
	
	node->next = p->next;
	p->next = node;
	
	list->head.val++;
	return true;
}

bool erase(LinkList *list, int index){
	if(list == NULL) return false;
	if(index < 0 || index >= list->head.val) return false;
	
	ListNode *p = &(list->head);
	while(index--){
		p = p->next;
	}
	
	ListNode *q = p->next->next;
	clearListNode(p->next);
	p->next = q;
	
	list->head.val--;
	return true;
}

bool update(LinkList *list, int index, int val){
	if(list == NULL) return false;
	if(index < 0 || index >= list->head.val) return false;
	
	ListNode *p = list->head.next;
	while(index--){
		p = p->next;
	}
	
	p->val = val;
	return true;
}

int find(LinkList *list, int val){
	if(list == NULL) return -1;
	ListNode *p = list->head.next;
	
	int res = 1;
	while(p){
		if(p->val == val){
			return res;
		}
		res++;
		p = p->next;
	}
	
	return -1;
}

#define Status bool
#define OK true
#define ERROR false
typedef int ElemType;
//    获取某个索引处的元素权值
Status getElem(LinkList *list, int ind, ElemType &elem){
	if(list == NULL) return ERROR;
	if(ind < 0 || ind >= list->head.val) return ERROR;
	
	ListNode *p = list->head.next;
	while(ind--) p = p->next;
	
	elem = p->val;
	return OK;
}