单链表定义及增删改查操作

1. 单链表结点表示

typedef struct LNode {
	int data;				// 数据域
	struct LNode* next;		// 指针域
}LNode,*LinkList;

2. 初始化单链表

// 初始化单链表(带头结点)
bool InitList(LinkList &L) {
	LNode* p = (LNode*)malloc(sizeof(LNode));
	if (!p) {	// 创建失败，返会false
		printf("INITE FAIL\n");
		return false;
	}

	p->next = NULL;		// 初始为空链表
	L = p;
	return printf("INITE OK\n");
}

3. 创建单链表

3.1 头插法创建单链表

// 创建单链表（头插法）
bool List_HeadInsert(LinkList& L, int len=0) {
	if (len < 0) {	// 插入结点个数检验
		printf("ERROR:'len' < 0\n");
		return false;
	}

	int data;	// 新结点的值	
	while (len ) {
		LNode* p = (LNode*)malloc(sizeof(LNode));
		if (!p) {	// 创建新结点失败，返回false
			printf("HEAD INSERT FAIL\n");
			return false;
		}

		printf("No.%d NODE VALUE:", len);
		scanf_s("%d", &data);

		p->data = data;
		p->next = L->next;
		L->next = p;		
		
		len--;
	}
	
	return printf("HEAD INSERT OK\n");
}

3.2 尾插法创建单链表

/* 创建单链表 (尾插法) */
bool List_TailInsert(LinkList& L, int len = 0) {
	if (len < 0) {	// 插入结点个数检验
		printf("ERROR:'Len' > 0\n");
		return false;
	}

	int count = 1;
	int data;			// 新结点的值
	LNode* r = L;		// 尾指针
	while (len) {
		LNode* p = (LNode*)malloc(sizeof(LNode));
		if (!p) {	// 创建新结点失败，返回false
			printf("TAIL INSERT FAIL\n");
			return false;
		}
		
		printf("No.%d NODE VALUE:", count);
		scanf_s("%d", &data);
		count++;

		p->data = data;
		p->next = r->next;
		r->next = p;
				
		r = p;	// r指向新的表尾结点
		len--;		
	}

	return printf("TAIL INSERT OK\n");
}

4. 打印单链表

/* 打印单链表 */
bool PrintList(LinkList L) {
	if (!L->next) {		// 空表		
		return printf("NULL LIST\n");
	}	
	printf("LIST:Head");

	LNode* p = L->next;		
	while (p) {
		printf("->[%d]", p->data);
		p = p->next;
	}
	return printf("\nPRINT OK\n");
}

5. 单链表的查找

5.1 按序号查找结点

/* 按序号查找结点 */
LNode* GetElem(LinkList L, int i) {

	if (i < 1) {		// 若i无效，则返回NULL
		return NULL;
	}
	
	int j = 1;				// 计数，初始值为1
	LNode* p = L->next;		// 第一个结点指针赋给指针p
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}

	return p;	// 返回指向第i个结点的指针；若i大于表长，则返回NULL
}

5.2 按值查找结点

/* 按值查找结点 */
LNode* LocateElem(LinkList L, int e) {
	if (!L->next) {	// 若为空表，返回NULL
		return NULL;
	}

	LNode* p = L->next;

	while (p !=NULL && p->data != e) {
		p = p->next;
	}

	return p;	// 若找到，这返回改结点指针；否则，返回NULL
}

6. 求表长

/* 求表长 */
int List_Length(LinkList L) {

	LNode* p = L;		// 初始为头结点指针
	int count = 0;		// 初始值为0


	while (p->next) {
		p = p->next;
		count++;
	}

	return count;
}

7. 插入结点

7.1 按位序插入结点

/* 按位序插入结点（单个完整的结点） */
bool ListInsertNode(LinkList& L, int i,LNode *insertNode) {
	if (i < 1) {		// 检测插入位置的合法性[1,length+1]
		return false;
	}

	LNode* p = L;	// 指针p指向当前扫描到的结点
	int j = 0;		// 当前指针p指向的是第几个结点
	p = L;			// 指针p初始指向头结点

	while (p != NULL && j < i - 1) {	// 循环找到第i-1个结点（前驱结点）
		p = p->next;
		j++;
	}

	if (!p) {	// i值不合法(其前驱结点不存在)
		return false;
	}
	else {	// 进行插入
		insertNode->next = p->next;
		p->next = insertNode;
	}

	return true;
}

/* 按位序插入结点（只有数据域） */
bool ListInsertData(LinkList& L, int i, int e) {
	if (i < 1) {		// 检查插入位置的合法性[1,length+1]
		return false;
	}

	LNode* p = L;	// 指针p指向当前扫描到的结点
	int j = 0;		// 当前指针p指向的是第几个结点
	p = L;			// 指针p初始指向头结点

	while (p != NULL && j < i - 1) {	// 循环找到第i-1个结点（前驱结点）
		p = p->next;
		j++;
	}


	if (!p) {	// i值不合法(其前驱结点不存在)
		return false;
	}
	
	/* 进行插入 */
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (!s) {		// 创建新结点失败，返回false
		return false;
	}
	else {	// 创建成功
		s->data = e;
		s->next = p->next;
		p->next = s;
	}

	return true;
}

8. 删除结点

8.1 按位序删除结点

/* 按位序插入结点（只有数据域） */
bool ListInsertData(LinkList& L, int i, int e) {
	if (i < 1) {		// 检查插入位置的合法性[1,length+1]
		return false;
	}

	LNode* p = L;	// 指针p指向当前扫描到的结点
	int j = 0;		// 当前指针p指向的是第几个结点
	p = L;			// 指针p初始指向头结点

	while (p != NULL && j < i - 1) {	// 循环找到第i-1个结点（前驱结点）
		p = p->next;
		j++;
	}


	if (!p) {	// i值不合法(其前驱结点不存在)
		return false;
	}
	
	/* 进行插入 */
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (!s) {		// 创建新结点失败，返回false
		return false;
	}
	else {	// 创建成功
		s->data = e;
		s->next = p->next;
		p->next = s;
	}

	return true;
}