Estructura de datos | Lista lineal secuencial

1. Definición de la estructura de datos

typedef int ListType;
typedef struct node {
	ListType data;
	struct node* next;
} *Node, * LinkList;

2. Resumen del método

LinkList CreateLinkList(); // 创建只有头结点的空链表
void InsertHead(LinkList L, ListType data); // 单链表表头插入
void InsertTail(LinkList L, ListType data); // 单链表表尾插入
void PrintLinkList(LinkList L);		// 打印单链表
void ReverseLinkList(LinkList L);	// 链表逆置
int DestroyLinkList(LinkList L);	// 销毁单链表
int locateAndChange(LinkList L, ListType data); // 链表中查找 与data值相等的第一个结点

3. Explicación detallada del método

// 创建只有头结点的空链表
LinkList CreateLinkList() {
	Node head = (Node)malloc(sizeof(struct node));
	if (head != NULL) {
		head->next = NULL;
		head->data = 0;
	}
	return head;
}
// 单链表表头插入
void InsertHead(LinkList L, ListType data){
	Node Head = (Node)malloc(sizeof(struct node));
	Head->data = data;
	Head->next = L->next;
	L->next = Head;
}
// 单链表表尾插入
void InsertTail(LinkList L, ListType data){
	Node p = L;
	while (p->next != NULL) p = p->next;
	Node Tail = (Node)malloc(sizeof(struct node));
	p->next = Tail;
	Tail->data = data;
	Tail->next = NULL;
}
// 打印单链表
void PrintLinkList(LinkList L) {
	Node tra = L->next;
	while (tra->next != NULL) {
		printf("%d ", tra->data);
		tra = tra->next;
	}
	printf("%d", tra->data);
}
// 链表逆置
void ReverseLinkList(LinkList L){
	Node p, q;
	p = L->next;
	L->next = NULL;
	while (p) {
		q = p;
		p = p->next;
		q->next = L->next;
		L->next = q;
	}
}
// 销毁单链表
int DestroyLinkList(LinkList L) {
	// 返回值为回收结点的个数，含头结点   
	Node p;
	int num = 0;
	while (L) {
		p = L;
		L = L->next;
		free(p);
		num += 1;
	}
	return num;
}
// 链表中查找 与data值相等的第一个结点
int locateAndChange(LinkList L, ListType data) {
	// 若能找到该结点，则将该结点的值与前驱结点的值交换
	// 若未找到与data值相等的结点，则返回值为-1
	// 若找到的结点无前驱结点，则返回值为0，否则返回值为前驱结点的值
	int temp;
	Node pre;
	pre = L;
	while (pre->next != NULL && pre->next->data != data)   pre = pre->next;
	if (pre->next->next == NULL) return -1;
	else if (pre == L) return 0;
	else {
		temp = pre->data;
		pre->data = pre->next->data;
		pre->next->data = temp;
		return pre->next->data;
	}
}

4. Ejecución de resultados

        El código del método principal es el siguiente:

int main() {
	LinkList L = CreateLinkList();
	for (int i = 1; i <= 10; i++) {
		InsertTail(L, i);
	}
	ReverseLinkList(L);
	PrintLinkList(L);
	DestroyLinkList(L);
}

        El resultado de la operación es el siguiente:

 

5. Código fuente

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

/* 单链表 */
typedef int ListType;
typedef struct node {
	ListType data;
	struct node* next;
} *Node, * LinkList;

LinkList CreateLinkList(); // 创建只有头结点的空链表
void InsertHead(LinkList L, ListType data); // 单链表表头插入
void InsertTail(LinkList L, ListType data); // 单链表表尾插入
void PrintLinkList(LinkList L);		// 打印单链表
void ReverseLinkList(LinkList L);	// 链表逆置
int DestroyLinkList(LinkList L);	// 销毁单链表
int locateAndChange(LinkList L, ListType data); // 链表中查找 与data值相等的第一个结点


// 创建只有头结点的空链表
LinkList CreateLinkList() {
	Node head = (Node)malloc(sizeof(struct node));
	if (head != NULL) {
		head->next = NULL;
		head->data = 0;
	}
	return head;
}
// 单链表表头插入
void InsertHead(LinkList L, ListType data){
	Node Head = (Node)malloc(sizeof(struct node));
	Head->data = data;
	Head->next = L->next;
	L->next = Head;
}
// 单链表表尾插入
void InsertTail(LinkList L, ListType data){
	Node p = L;
	while (p->next != NULL) p = p->next;
	Node Tail = (Node)malloc(sizeof(struct node));
	p->next = Tail;
	Tail->data = data;
	Tail->next = NULL;
}
// 打印单链表
void PrintLinkList(LinkList L) {
	Node tra = L->next;
	while (tra->next != NULL) {
		printf("%d ", tra->data);
		tra = tra->next;
	}
	printf("%d", tra->data);
}
// 链表逆置
void ReverseLinkList(LinkList L){
	Node p, q;
	p = L->next;
	L->next = NULL;
	while (p) {
		q = p;
		p = p->next;
		q->next = L->next;
		L->next = q;
	}
}
// 销毁单链表
int DestroyLinkList(LinkList L) {
	// 返回值为回收结点的个数，含头结点   
	Node p;
	int num = 0;
	while (L) {
		p = L;
		L = L->next;
		free(p);
		num += 1;
	}
	return num;
}
// 链表中查找 与data值相等的第一个结点
int locateAndChange(LinkList L, ListType data) {
	// 若能找到该结点，则将该结点的值与前驱结点的值交换
	// 若未找到与data值相等的结点，则返回值为-1
	// 若找到的结点无前驱结点，则返回值为0，否则返回值为前驱结点的值
	int temp;
	Node pre;
	pre = L;
	while (pre->next != NULL && pre->next->data != data)   pre = pre->next;
	if (pre->next->next == NULL) return -1;
	else if (pre == L) return 0;
	else {
		temp = pre->data;
		pre->data = pre->next->data;
		pre->next->data = temp;
		return pre->next->data;
	}
}

int main() {
	LinkList L = CreateLinkList();
	for (int i = 1; i <= 10; i++) {
		InsertTail(L, i);
	}
	ReverseLinkList(L);
	PrintLinkList(L);
	DestroyLinkList(L);
}