【C++】链表

最新推荐文章于 2025-04-28 21:19:29 发布

原创最新推荐文章于 2025-04-28 21:19:29 发布 · 1.7k 阅读

72 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

120 篇文章

订阅专栏

链表相对于结构体就多了个next指针，next指针指向下一个对象就行。

链表概念

把若干个对象用指针串联起来，形成一个链状的数据结构，称之为“链表”。

链表特征

链表头：指链表中的第一个对象。

链表尾：指链表中的最后一个对象。它的next必须设为空指针NULL。

链表的构造

程序功能：一个对象学生，然后可以从第一个学生指向第二个学生，然后第二个学生可以指向第三个学生，以此类推。

struct Student 
{
	int id;
	char name[116];
	Student* next;
};

Student ss[4] =
{
	{123, "sadf", 0},
	{12, "sdf", 0},
	{13, "adf", 0},
	{23, "sad", 0},
};


int main()
{
	ss[0].next = &ss[1];
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = 0;

	return 0;
}

链表的遍历

程序功能：遍历并打印链表中的值。

#include "stdio.h"
struct Student 
{
	int id;
	char name[116];
	Student* next;
};

Student ss[4] =
{
	{123, "sadf", 0},
	{12, "sdf", 0},
	{13, "adf", 0},
	{23, "sad", 0},
};


int main()
{
	ss[0].next = &ss[1];
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = 0;

	Student* p = &ss[0];
	while (p)
	{
		printf("id:%d, name:%s \n", p->id, p->name);
		p = p->next;
	}

	return 0;
}

查找链表中的对象

其实就是遍历整个链表，然后找到满足条件的返回就行了。

struct Student 
{
	int id;
	char name[116];
	Student* next;
};

Student ss[4] =
{
	{123, "sadf", 0},
	{12, "sdf", 0},
	{13, "adf", 0},
	{23, "sad", 0},
};

Student* find(Student* head, int id)
{
	Student* p = head;
	while (p)
	{
		if (p->id == id)
			return p;
		p = p->next;
	}
	return NULL;
}

int main()
{
	ss[0].next = &ss[1];
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = 0;

	Student* p = &ss[0];
	while (p)
	{
		printf("id:%d, name:%s \n", p->id, p->name);
		p = p->next;
	}

	Student* result = find(&ss[0], 12);

	return 0;
}

有头链表与无头链表

无头链表：所有节点都包含了有效数据。（上面链表概念中所举得例子都是无头链表）

有头链表：用一个固定的头节点来指代整个链表，所有对象挂在这个头节点下面，而头节点本身不包含有效数据。

为什么会需要有头链表呢？

如果对象的个数为0，用无头链表就不好表示，这时就需要使用到有头链表。

在你学习完下面的代码，你会发现有头链表的插入删除还是比较简单的，但是无头链表的插入删除就复杂的多，特别当操作节点位于头部时，非常复杂。

无头链表

上面链表概念中所举得例子都是无头链表

有头链表

其实就是申明一个空的节点，也就是将next置为NULL，然后将该节点作为头节点就行了。

Student m_head = {0, "head", NULL};
或写作
Student m_head = {0};

有头链表的数据插入：从头部插入，从尾部插入

#include "stdio.h"
#include "stdlib.h"

struct Student 
{
	int id;
	char name[116];
	Student* next;
};

Student m_head = { 0 };
//添加到m_head后面，也就是添加到头部
void add_head(Student* obj) {
	obj->next = m_head.next;
	m_head.next = obj;
}

//插入在尾部
void add_tail(Student* obj)
{
	Student* p = &m_head;
    //遍历完所有，直到最后一个对象
	while (p->next) {  
		p = p->next;
	}
    //最后一个对象指向新对象，新对象指向NULL
	p->next = obj;
	obj->next = NULL;
}

int main()
{
	Student* obj_1 = (Student*)malloc(sizeof(Student));
	obj_1->id = 1;
	strcpy_s(obj_1->name, "X");
	add_tail(obj_1);

	Student* obj_2 = (Student*)malloc(sizeof(Student));
	obj_2->id = 2;
	strcpy_s(obj_2->name, "Y");
	add_tail(obj_2);

	return 0;
}

插入和删除

复杂点的例子：链表插入学生，并按学生id从小到大排列。根据id删除对象。

#include "stdio.h"
#include "stdlib.h"

Student m_head = { 0 };

void insert(Student* obj)
{
	Student* cur = m_head.next;
	Student* pre = &m_head;
	while (cur)
	{
		if (obj->id < cur->id)
		{
			break;
		}
		pre = cur; 
		cur = cur->next;
	}
	obj->next = pre->next; //obj->next = cur;
	pre->next = obj;
}

void remove(int id)
{
	Student* cur = m_head.next;
	Student* pre = &m_head;
	while (cur)
	{
		if (cur->id == id)
		{
			pre->next = cur->next;
			free(cur);
			break;
		}
		pre = cur;
		cur = cur->next;
	}
}


void show_all()
{
	Student* p = m_head.next;
	while (p)
	{
		printf("id:%d, name:%s\n",p->id, p->name);
		p = p->next;
	}
}

int main()
{
	Student* obj = NULL;

	obj = (Student*)malloc(sizeof(Student));
	obj->id = 1;
	strcpy_s(obj->name, "111");
	insert(obj);

	obj = (Student*)malloc(sizeof(Student));
	obj->id = 2;
	strcpy_s(obj->name, "222");
	insert(obj);

	obj = (Student*)malloc(sizeof(Student));
	obj->id = 3;
	strcpy_s(obj->name, "333");
	insert(obj);

	obj = (Student*)malloc(sizeof(Student));
	obj->id = 4;
	strcpy_s(obj->name, "444");
	insert(obj);

    remove(2);
	remove(8);

	show_all();

	return 0;
}

这里有一个奇怪的用法，我不是很理解：

Student* obj = NULL;

obj = (Student*)malloc(sizeof(Student));
obj->id = 1;
strcpy_s(obj->name, "111");
insert(obj);

obj = (Student*)malloc(sizeof(Student));
obj->id = 2;
strcpy_s(obj->name, "222");
insert(obj);

我猜测是这样：我先申请了一块内存，我叫他obj，obj指向这块内存，然后我将对象的地址传递给insert操作，这时链表中已经添加了该对象的地址，所以在我重新申请了一块内存，修改obj的指针指向这块内存，不会改变之前插入链表中的对象的地址。