单向链表的操作以及实现

一，链表的引出

1.顺序表优缺点：

①.物理上连续，知道在表中位置时查找效率高

②.按值查找效率低，需要从头开始

③.物理上连续，删除、插入需要将后面元素前移，效率低，尾插入、删除效率高

④.需要连续空间，条件苛刻（前提是裸机操作，没有操作系统，有操作系统就是操作的虚拟空间）

由于顺序表的创建需要连续空间，基于苛刻的条件我们提出了链表

2.链式结构特点：

①.用物理上的不连续来表示逻辑上的连续(通过存储下一个元素的地址可以找到下一个元素)

②.提出节点结构，数据+指针域

③.按值、位置查找效率都慢，都需要从头开始

④.增删效率不一定快

A.插入新节点：

a.通过辅助指针找到待插入位置的前一个元素

b.创建新节点

c.更新新节点next

d.更新老节点next

 B.删除节点

a.通过辅助指针找到待插入位置的前一个元素

b.定义辅助指针temp对待删除节点进行备份

c.更新待删除的节点的上一节点的next

d.释放待删除节点，通过拷贝好的指针

二.如何记录首地址

①头节点，头结点不存数据只存储下个元素的地址

②头指针:处理比较麻烦，比如当我们要插入新节点的时候，就需要判断是在节点之间还是指针和节点

三.单向链表的代码实现

1.我们的单向链表中节点只存储下一个元素地址，所以当使用辅助指针时一般停留在待操作指针的上一节点，因为一旦跳过就再也回不去了 

2.头文件中的接口

#ifndef LINKLIST_H
#define LINKLIST_H
typedef int Element_t;

typedef struct _node {
	Element_t val;
	struct _node *next;
}node_t;

typedef struct {
	node_t head;
	int count;
}linklist_t;

//创建链表
linklist_t* createlinklist();

//释放表
void releaselinklist(linklist_t*table);

//头插法
int insertlinklisthead(linklist_t*table,Element_t value);

//任意位置插入
int insertlinklistpos(linklist_t*table,int pos,Element_t value);

//删除元素
int deletelinklist(linklist_t*table,Element_t value);

//遍历
void showlinklist(linklist_t*table);
#endif //LINKLIST_H

3.按照头文件的接口一一实现

#include "linklist.h"
#include <stdio.h>
#include <stdlib.h>

linklist_t * createlinklist() {
	linklist_t *table=NULL;
	//为表头分配空间
	table = malloc(sizeof(linklist_t));
	//判断分配是否成功
	if (table==NULL) {
		fprintf(stderr,"linklist malloc failed\n");
	}
	//初始化表头成员
	table->head.val=0;
	table->head.next=NULL;
	table->count=0;
		return table;
}

void releaselinklist(linklist_t *table) {
	//1.定义指针p表示待释放的节点,再定义temp拷贝p
	node_t*p=table->head.next;
	node_t*temp=NULL;
	//2.只要节点不为空，就释放节点
	while(p!=NULL) {
		temp=p;
		p=temp->next;
		free(temp);
	}
	//3.释放链表
	free(table);
	printf("linklist released\n");
}

int insertlinklisthead(linklist_t *table, Element_t value) {
	//1.为新节点分配空间
	node_t*newnode=malloc(sizeof(node_t));
	//2.判断分配是否成功
	if (newnode==NULL) {
		fprintf(stderr,"newnode malloc failed\n");
		return -1;
	}
	//3.将新节点插入到表头
	newnode->val=value;
	newnode->next=table->head.next;
	table->head.next=newnode;
	//4.更新链表长度
	table->count++;
	return 0;
}

int insertlinklistpos(linklist_t *table, int pos, Element_t value) {
	//判断pos是否合法
	if (pos<0 || pos>table->count) {
		fprintf(stderr,"pos is invalid\n");
		return -1;
	}
	//1.定义指针p表示待插入的节点
	node_t*p=&table->head;
	//2.找到待插入的位置
	for (int i=0;i<pos;i++) {
		p=p->next;
	}
	//3.为新节点分配空间
	node_t*new_node=malloc(sizeof(node_t));
	if (new_node==NULL) {
		fprintf(stderr,"new_node malloc failed\n");
		return -1;
	}
	new_node->val=value;
	//4.将新节点插入到链表中
	new_node->next=p->next;
	p->next=new_node;
	//5.更新链表长度
	table->count++;
	return 0;
}

int deletelinklist(linklist_t *table, Element_t value) {
	node_t*p=&table->head;
	//1.找到待删除节点的位置
	for(int i=0;i<table->count;i++) {
		if (p->next->val==value||p->next->next==NULL) {
			break;
		}
		p=p->next;
	}
	//2.如果没找到，返回-1
	if (p->next->next==NULL) {
		fprintf(stderr,"deletelinklist element not found\n");
		return -1;
	}
	//3.删除节点
	node_t*temp=p->next;
	p->next=temp->next;
	free(temp);
	return 0;
}

void showlinklist(linklist_t *table) {
	//1.定义指针p表示待打印的节点
	node_t*p=table->head.next;
	//2.打印个数为count
	for (int i=0;i<table->count;i++) {
		printf("%d\t",p->val);
		//3.将p指向p的下一个节点
		p=p->next;
	}
	printf("\n");
}

 4.测试代码

#include <stdio.h>
#include "linklist.h"
void test1() {
	linklist_t*table=createlinklist();
	if (table==NULL) {
		return;
	}
	printf("create successfully\n");
	for (int i=0;i<5;i++) {
		insertlinklisthead(table,100+i);
	}
	insertlinklistpos(table,5,500);
	deletelinklist(table,600);
	showlinklist(table);
	releaselinklist(table);
}
int main() {
	test1();
	return 0;
}