【数据结构笔记】数据结构基础—链表

最新推荐文章于 2023-06-22 01:13:10 发布

DUANDAUNNN

最新推荐文章于 2023-06-22 01:13:10 发布

阅读量1.2k

点赞数 3

分类专栏：数据结构文章标签：数据结构链表

本文链接：https://blog.csdn.net/duanduann/article/details/119904760

版权

数据结构专栏收录该内容

9 篇文章 8 订阅

订阅专栏

1.线性表的链式存储结构

特点：下一节点data的起始地址存在了上一节点的next中，所以链表末尾的指针一定会指向NULL

将线性表 $L=(a_{0},a_{1},.......,a_{n-1})$ 中各元素分布在存储器的不同存储块，成为节点，通过地址或指针建立元素之间的联系。

节点的data域存放数据元素 $a_{i}$ ，而next域是一个指针，指向直接后继 $a_{i+1}$ 所在的节点。

节点类型描述：

typedef struct node{  
    data_t data;   //结点的数据域//
    struct node *next;  //结点的后继指针域//
}listnode, *linklist;

设p指向链表中节点 $a_{i}$ ，

获取 $a_{i}$ ：p->data

获取 $a_{i+1}$ ：p->next->data

若指针p的值为NULL，则它不指向任何节点，此时取p->data或p->next->data是错误的，会报段错误。

向系统申请节点的存储空间：

linklist p;
p = (linklist)malloc(sizeof(listnode));

2.单链表的基本操作

创建

①申请内存 ②赋值 ③返回头部指针

linklist list_create() {
	linklist H;

	H = (linklist)malloc(sizeof(listnode));
	if (H == NULL) {
		printf("malloc failed\n");
		return H;
	}
	
	H->data = 0;
	H->next = NULL;

	return H;
}

尾部插入

①建一个新节点

②找尾节点

③尾部插入

int list_tail_insert(linklist H, data_t value) {
	linklist p;
	linklist q;

	if (H == NULL) {
		printf("H is NULL\n");
		return -1;
	}

	//1 new node p
	if ((p = (linklist)malloc(sizeof(listnode))) == NULL) {
		printf("malloc failed\n");
		return -1;
	}
	p->data = value;
	p->next = NULL;
	
	//2 寻找尾节点，尾节点的特征是它的next指针指向NULL
// 这里最好不要理解为赋值，而是理解为q也指向了H所指向的地方
	q = H; // 这里要让q也指向头节点，后面用q去遍历链表，不能用H，因为H必须一直指向头节点
	while (q->next != NULL) {
		q = q->next;  // 挨个节点的遍历
	}

	//3 insert
	q->next = p;

	return 0;
}

输出链表中的元素值

int list_show(linklist H) {
	linklist p;

	if (H == NULL) {
		printf("H is NULL\n");
		return -1;
	}

	p = H; // p同样也指向了链表头部的指针，头部是没有值的，但它指向后一个节点的元素值

	while (p->next != NULL) {
		printf("%d ", p->next->data);
		p = p->next;
	}
	puts("");

	return 0;
}

按位置插入

注：插入时，先让q指向 $a_{i}$ ，再让p指向q，这样的话链表的逻辑关系不会断，没有风险，否则若先让p指向q，那么链表就断了，会有风险。

注：H是指向头节点的指针，头节点的值不重要，因为这个头节点中的next（即H->next）指向的才是 $a_{0}$ ，H->data是多少无所谓，这里链表的元素还没开始呢，符号->表示调用结构体指针中的成员变量。

链表查找

先考虑特殊情况：①H == NULL ②pos = -1

// 找位置索引为pos的节点，找到后，返回指向pos位置的值的指针
// 即pos位置节点的前一个节点的next
linklist list_get(linklist H, int pos) {
	linklist p;
	int i;

	if (H == NULL) {
		printf("H is NULL\n");
		return NULL;
	}

	if (pos == -1) {
		return H;
	}

	p = H;
	i = -1;  
	while (i < pos) { // 如果第一个有值的节点的索引（序号）是0的话，到pos索引需要运行pos+1次p = p->next
		p = p->next;   // 这里要计算一下，i从-1到pos的次数决定了p = p->next的次数，即最终指向的值
		if (p == NULL) {
			printf("pos is invalid\n");
			return NULL;
		}
		i++;
	}

	return p;
}

按位置插入

int list_insert(linklist H, data_t value, int pos) {
	linklist p;
	linklist q;

	if (H == NULL) {
		printf("H is NULL\n");
		return -1;
	}

	//1 locate node p (pos-1)
	p = list_get(H, pos-1); // 找到目标节点的前一个位置
	if (p == NULL) {
		return -1;
	}

	//2 new node q
	if ((q = (linklist)malloc(sizeof(listnode))) == NULL) {
		printf("malloc failed\n");
		return -1;
	}
	q->data = value;
	q->next = NULL;

	//3 insert ，这里注意顺序
	q->next = p->next;
	p->next = q;

	return 0;
}

按位置删除

即 $p\rightarrow next = p\rightarrow next\rightarrow next$ ,（其中p指向待删除节点的前驱节点），但这样做中间节点就不会被释放。要这样：

① $q = p\rightarrow next$

② $p\rightarrow next = q\rightarrow next$

③free q

int list_delete(linklist H, int pos) {
	linklist p;
	linklist q;

	//1
	if (H == NULL) {
		printf("H is NULL\n");
		return -1;
	}

	//2 locate prior
	p = list_get(H, pos-1);
	if (p == NULL) 
		return -1;
	if (p->next == NULL) { //即，此时前驱是链表的最后一个节点
		printf("delete pos is invalid\n");
		return -1;
	}

	//3 update list
	q = p->next;
	p->next = q->next;//p->next = p->next->next;

	//4 free
	printf("free:%d\n", q->data);
	free(q);
	q = NULL;

	return 0;
}

链表释放

linklist list_free(linklist H) {
	linklist p;

	if (H == NULL) 
		return NULL;

	p = H;

	printf("free:");
	while (H != NULL) { // 这里不能用H->next != NULL，因为这是释放整个链表，头节点也不能跑
		p = H;
		printf("%d ", p->data);
		free(p);
		H = H->next;
	}
	puts("");

	return NULL;
}

3.单链表的复杂操作

链表的反转

int list_reverse(linklist H) {
	linklist p;
	linklist q;

	if (H == NULL) { // 特殊情况1：链表为空
		printf("H is NULL\n");
		return -1;
	}

// 特殊情况2：链表只有头指针，或只有一个元素，H->next是指向链表第一个元素的指针，H->next->next指向第二个元素
	if (H->next == NULL || H->next->next == NULL) { 
		return 0;
	}
	
// 这里要注意先后顺序，要先复制指向第二个元素的指针，再断开该指针
// 这样链表的逻辑不会断
	p = H->next->next;
	H->next->next = NULL; 

	while (p != NULL) {
		
// p负责往后遍历节点，指向待操作节点，如果节点非空，就传给q，通过q把这个节点插到H后面
		q = p;
		p = p->next;

// 将q插入到H节点之后，这里同样注意顺序，先让q的next指针和H的next指针指向同一个地方
// 再让H的next指针指向q，就完成了节点的插入
		q->next = H->next;
		H->next = q;
	}

	return 0;
}

链表求相邻两个节点最大值

linklist list_adjmax(linklist H, data_t *value) {
	linklist p, q, r;
	data_t sum;

	if (H == NULL){  // 特殊情况：头指针都没有
		printf("H is NULL\n");
		return NULL;
	}
  // 特殊情况：1.有头指针但没元素 2.只有一个元素 3.只有两个元素
	if (H->next == NULL || H->next->next == NULL || H->next->next->next == NULL) {
		return H;
	}

	q = H->next;
	p = H->next->next;//p = q->next;
	r = q;  // r用来存放要返回的指针，即 靠前的那个
	sum = q->data + p->data;

	while (p->next != NULL) {
		p = p->next;
		q = q->next;
		if (sum < q->data + p->data) {
			sum = q->data + p->data;
			r = q;
		}
	}

	*value = sum;

	return r;
}

有序链表合并

int list_merge(linklist H1, linklist H2) {
	linklist p, q, r;

	if (H1 == NULL || H2 == NULL) {
		printf("H1 || H2 is NULL\n");
		return -1;
	}

	p = H1->next; //指向第一个元素
	q = H2->next;
	r = H1;  // 令r指向头指针，这里是指针之间的赋值，被指对象的改变，会同时影响r和H1
	H1->next = NULL; // 此时r->next也被置为了NULL，只有先断开了，才能往后面加节点
	H2->next = NULL; // 往H1里加节点，H2之后就不用了

	while (p && q) {
		if (p->data <= q->data) {
			r->next = p;
			p = p->next; 
			r = r->next; // r往下一个位置指，即r指向刚插入的节点p，p有两个参数，一个是data，一个是next，data已知，next应为NULL
			r->next = NULL; // p的next即 r->next应该设置为NULL
		} else {
			r ->next = q;
			q = q->next;
			r = r->next;
			r->next = NULL;
		}
	}

	if (p == NULL) {
		r->next = q;
	}else {
		r->next = p;
	}

	return 0;
}

相关题目

1、请简述你的解决方案：设指针变量p指向单链表中节点A，若删除单链表中的节点A，该怎么办？
2、写一个函数，实现删除单链表中的所有节点；

3.写一个函数，实现链表的排序（使链表中元素的从无序到有序，要求从小到大）；

1.方案一：首先要找到节点A的直接前驱节点B，设指针q指向节点B，其次，令q->next = p->next，最后释放节点A（freeq(p)）。

方案二：可以把下一个节点的值复制到当前节点，然后删除下一个节点，这样就不需要遍历整个链表了；

2.p和H指向同一个节点，通过p释放了，就不要再通过H访问了，H=H->next要放到free之前。

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

typedef struct node{
	int data;
	struct node* next;
}*linklist,listnode;

linklist list_free(linklist H);

int main(int argc,const char* argv[]){
	return 0;
}

linklist list_free(linklist H) {
	linklist q;
	while (H != NULL) {
		q = H;
		H = H->next;
		free(q);
		//H = H->next;
	}
	return NULL;
}

int list_sort(linklist H){
	linklist p;
	linklist q;

	p = H->next;
	q = H->next->next;

	while (p->next != NULL) {
		while (q != NULL) {
			if (p->data > q->data) {
				int temp;
				temp = q->data;
				q->data = p->data;
				p->data = temp;
				//printf("?");
			}
			q = q->next;
		}
		p = p->next;
		q = p->next;
	}
	
	return 0;
}

int list_order(linklist H){ 
    linklist p,q,r; 
    int t; 
    if(H == NULL) { 
        printf("H is NULL"); 
        return -1; 
    } 
    p = H->next; 
    H->next = NULL; 
    r = H; 
    while(p != NULL) { 
        q = p; 
        p = p->next; 
        r = H; 
        while(r->next && r->next->data < q->data) 
            r = r->next; 
            q->next = r->next; 
            r->next = q; 
    } 
    return 0; 
}

DUANDAUNNN

关注

3
点赞
踩
22

收藏

觉得还不错? 一键收藏
打赏
0
评论
【数据结构笔记】数据结构基础—链表

1.线性表的链式存储结构特点：下一节点data的起始地址存在了上一节点的next中，所以链表末尾的指针一定会指向NULL将线性表中各元素分布在存储器的不同存储块，成为节点，通过地址或指针建立元素之间的联系。节点的data域存放数据元素，而next域是一个指针，指向直接后继所在的节点。节点类型描述：typedef struct node{ data_t data; //结点的数据域// struct node *next...
复制链接

扫一扫