链表的基本操作，用链表实现线性表

链表

增删改查

指针指向等于地址赋值

定义一个链表结构体

c 复制代码

typedef struct _NODE_ {
	int number;
	struct _NODE* next; 
}Node,*Lintlist;

这里的node是对节点命名时的数据类型

Linklist是对该链表命名时的数据类型

初始化

1.建立一个链表

2.申请一个头节点

c 复制代码

Linklist init(Linklist l) {
	Node* head = (Node*)malloc(sizeof(Node));
	if (head == NULL) {
		printf("内存分配失败");
		return NULL;
	}
	head->next = NULL;
	return head;
}

在主函数中调用是

c 复制代码

Linklist l=NULL;
l = init(l);

也可以
Linklist l=init(l);

当然在这里也可以这样来

在这里函数的参数有没有都可以，因为其本质要的是申请的这个节点的地址也就是head的值

在主函数中他会把这个返回值赋值给l；

包括这里的函数类型也可以换成Node*如下

c 复制代码

Node* init() {
	Node* head = (Node*)malloc(sizeof(Node));
	if (head == NULL) {
		printf("内存分配失败");
		return NULL;
	}
	head->next = NULL;
	return head;
}

在主函数中调用就是
Linklist l=init();

增加操作

分为三种，分别为头插法，尾插法，以及在指定位置增加，

这里分为三种操作的一个原因就是增加可读性

还有一个原因是这样能帮助我们写代码

不需要判断各种临界情况

代码不会复杂，相对简单。

头插法

c 复制代码

Linklist head_add(Linklist l, int m) {
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("内存分配失败");
		return l;
	}
	s->next = l->next;
	s->number = m;
	l->next = s;
	return l;
}

在这里有两个点需要注意

第一点，头指针的指针域数值在改变的时候不能让链表断裂，比如

c 复制代码

l->next = s;
s->next = l->next;

在这里我们先让头指针的指针域指向了s

但这里就会导致一个问题，我们原本在这个指针域里面存储的地址丢了

我们再执行
s->next = l->next;

就会让s的next指向自己

就会导致后续链表的断裂

所以我们在改变链表的指针域时，最重要的就是不能让链表断裂，即不能让数据丢失

第二点

在返回值上，我们其实可以让返回值为void

因为在这个函数里面其实我们没有动l的值

l里面是一个指针，而这个指针指向了一个我们声明的结构体类型的数据

我们是根据这个指针访问这个结构体类型的数据，然后更改这个结构体内的一些数据

我们并没有对l这个变量里面存储的数据进行改变

所以我们可以用void

而在上面我们用Link list这个作为返回值的原因是

在我们对l的理解中，l指的是这个链表

对于这个链表实际上是发生了变化的

所以我们在这里用了返回值

接下来的尾插法和指定位置插入都有这个问题。

尾插法

1.找到未节点

2.构建一个节点插在为节点后面

c 复制代码

Linklist rear_add(Linklist l, int m) {
	Node* p = l;
	while (p->next) {
		p = p->next;
	}
	
	
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("内存分配失败");
		
		return l;
	}
	s->number = m;
	s->next = NULL;
	p->next = s;
	return l;
}

指定位置插入

1.找到指定位置（这里可以来一个find函数）

接下来的操作是基于find函数进行的

find函数在后面紧挨着

2.通过find函数的返回值确认后续操作

3，如果是NULL则没有找的该数据，无法执行插入操作

4.找到之后，就构建新的节点插入

c 复制代码

Linklist rear_add(Linklist l, int m) {
	Node* p = l;
	while (p->next) {
		p = p->next;
	}
	
	
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("内存分配失败");
		return l;
	}
	s->number = m;
	s->next = NULL;
	p->next = s;
	return l;
}

查，

找到指定数据的节点，然后根据查找结果确定返回值

c 复制代码

Node* find(Linklist l, int k) {
	
	Node* q = l->next;
	while (q && q->number != k) {
	
		q = q->next;
	}
	return q;
}

删，

删除指定数据，在这里不能通过查找函数，是因为在删除操作里我们要涉及前面的一个节点的指针域

在双向链表中就可以通过find函数进行查找了，因为在双向链表中，节点内包含着前节点的地址

c 复制代码

Linklist delet(Linklist l, int k) {
	//k为删减的值
	Node* p = l;
	Node* q = l->next;
	while (q && q->number != k) {
		p = q;
		q = q->next;
	}
	if (q==NULL) {
		printf("未找到该数据，不能执行删除操作\n");
		return l;
	}
	p->next = q->next;
	
	free(q);
	q = NULL;
	return l;
}

改，

最简单的操作，可以选择通过find函数也可以直接查找，因为这个函数不涉及指针的改变

c 复制代码

Linklist change(Linklist l, int k,int m) {
	Node* p = find(l, k);
	if (p == NULL) {
		printf("未找到该数据，不能实行数据更改操作\n");
		return l;
	}
	p->number = m;
	return l;
}

输出函数

输出链表值

c 复制代码

void printff(Linklist l) {
	Node* p = l->next;
	while (p) {
		printf("%d ", p->number);
		p = p->next;
	}
	printf("\n");
}

下面时主函数的调用

c 复制代码

int main() 
{
	Linklist l=NULL;
	l = init(l);
	l = head_add(l, 3);
	l = head_add(l, 9);
	l = head_add(l, 5);
	printff(l);
	l = rear_add(l, 8);
	l = rear_add(l, 4);
	l = rear_add(l, 6);
	printff(l);
	l = inadd(l,3, 15);
	l = inadd(l, 10, 16);
	l = inadd(l, 9, 12);
	printff(l);
	l = delet(l, 4);
	l = delet(l, 8);
	l = delet(l, 16);
	printff(l);
	l = change(l, 4, 43);
	printff(l);
	return 0;
}