数据结构-线性表-链表

1.定义

定义指针，指向头节点

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node*next;
}LNode;

2.初始化

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
	int data;
	struct node*next;
}LNode;

LNode* InitLNode(){ //LNode*类型的函数，返回值为头指针head 
	LNode*head = (LNode*)malloc(sizeof(LNode));//为头指针分配大小为一个结点的变量空间 
	head->next=NULL;                //别忘了定义next指针，头节点的data一般不用管 
	return head;                    //返回我们定义的头指针 
}

int main()
{
	LNode* head = InitLNode();
    free(head);
	return 0;
}

3.创建链表

1）头插法

插入位置固定，即头节点后第一个节点

每次插入分两步：新建节点(都用指针动态分配内存)，连接

void CreateLNode(LNode* head, int n){//头插法
	while(n--){
		LNode*p = (LNode*)malloc(sizeof(LNode));//新建一个节点 
		scanf("%d", &p->data);                  //写data
		p->next = head->next;					//将p连接到头节点后 
		head->next = p;
	}
}

void FreeLNode(LNode* head){       //依次释放每个节点的内存空间 
	LNode*p=head;               //p指针用来遍历链表 
	while(p){
		LNode*r=p;            //r指针辅助删除节点 
		p=p->next;
		free(r);
	}
}

int main()
{
	LNode* head = InitLNode();
	int n=0;
	scanf("%d", &n);        //链表长度 
	CreateLNode(head, n);
    FreeLNode(head);      //该函数用于释放内存 
	return 0;
}

2）尾插法

插入位置在末尾，需要一个尾指针来定位插入位置

每次插入分三步：新建节点，连接，更新尾指针

void CreateLNode(LNode* head, int n){//尾插法 
	LNode*last = head;     //新建尾指针
	while(n--){
		LNode*p = (LNode*)malloc(sizeof(LNode));//新建节点 
		p->next = NULL;
		scanf("%d", &p->data);               //写数据 
		last->next = p;                     //连接 
		last = last->next;                  //更新尾指针 
	} 
}

void FreeLNode(LNode* head){       //依次释放每个节点的内存空间 
	LNode*p=head;               //p指针用来遍历链表 
	while(p){
		LNode*r=p;            //r指针辅助删除节点 
		p=p->next;
		free(r);
	}
}

int main()
{
	LNode* head = InitLNode();
	int n=0;
	scanf("%d", &n);        //链表长度 
	CreateLNode(head, n);
    FreeLNode(head);      //该函数用于释放内存 
	return 0;
}

 4.释放内存，遍历

遍历

顺序表的遍历类似于数组，通过下标访问各个元素，常用for循环

链表的遍历则需要指针，常用while循环，如下

	LNode*p=head->next;
	while(p){
		printf("%d", p->data);
		p=p->next;
	}

释放内存

由于链表每个节点的内存都是malloc分配的，因此需要遍历链表，依次释放内存

void FreeLNode(LNode* head){       //依次释放每个节点的内存空间 
	LNode*p=head;               //p指针用来遍历链表 
	while(p){
		LNode*r=p;            //r指针辅助删除节点 
		p=p->next;
		free(r);
	}
}

5.指定位置插入元素

第一个有数据的节点位置为1

需要两个指针，一个创建节点，一个确定插入位置

步骤：创建节点，移动指针确定位置，插入

int InsertLNode(LNode*head, int e, int pos){
	if(!head || pos<1) return 0;//排除不合理情况 
	LNode*p = head; //p指针要到达插入位置前一个结点
	LNode*r = (LNode*)malloc(sizeof(LNode));//创建新节点
	r->data = e; 
	
	int n = pos-1;  //若插入第1个位置，p指针后移0位
	while(n--){     //若插入第2格位置，p指针后移1位
		p = p->next;//故循环pos-1次 
        if(!p->next) return 0;//排除不合理情况
	}   
	             
	r->next = p->next;
	p->next = r;
    return 1;
}

int main()
{
	LNode* head = InitLNode();
	int n=0;
	scanf("%d", &n);        //链表长度 
	CreateLNode(head, n);
	
	int e, pos;   //要插入的元素和位置 
	scanf("%d", &e);
	scanf("%d", &pos);
	InsertLNode(head, e, pos); 
	
    FreeLNode(head);      //该函数用于释放内存 
	return 0;
}

6.删除节点

int DeleteLNode(LNode*head, int pos){
	if(!head || pos<1) return 0;//排除不合理情况 
	LNode*p = head; //p指针要到达删除位置前一个节点 
	int n = pos-1;
	while(n--){
		p = p->next; 
		if(!p->next) return 0;//排除不合理情况
	}
	LNode*r = p->next;//r指向要删除位置 
	p->next = r->next;//先把r两边连起来 
	free(r);          //释放r 
	return 1;
}

int main()
{
	LNode* head = InitLNode();
	int n=0;
	scanf("%d", &n);        //链表长度 
	CreateLNode(head, n);
	
	int pos;               //要删除的位置 
	scanf("%d", &pos);
	DeleteLNode(head, pos);
	
    FreeLNode(head);      //该函数用于释放内存 
	return 0;
}