数据结构-单链表学习记录及常见错误

首先，设计一个链表节点结构体，再设计一个链表类，封装一些链表的操作，在下面的代码中，实现了链表的建立和链表元素的头插、尾插：

#include<iostream>
using namespace std;

struct LNode
{
	int data;				// 数据域
	struct LNode* next;		// 指针域，指向后继结点
};
using LinkNode = LNode;

class LinkList
{
public:
	LinkList()
	{
		L = NULL;
	}
	LNode* L;
	void CreatListF(int a[], int n)
	{
		LinkNode* s;
		L = new LinkNode[sizeof(LinkNode)];
		L->next = NULL;
		for (int i = 0; i < n; i++)
		{
			s = new LinkNode[sizeof(LinkNode)];
			s->data = a[i];
			s->next = L->next;
			L->next = s;
		}
	}
	void CreatListB(int a[], int n)
	{
		LinkNode* s;
		LinkNode* temp; // 借助中间变量节点结构体实现尾插法
		L = new LinkNode[sizeof(LinkNode)];
		L->next = NULL;
		temp = L;
		for (int i = 0; i < n; i++)
		{
			s = new LinkNode[sizeof(LinkNode)];
			s->data = a[i];
			temp->next = s;
			temp = s;
		}
		temp->next = NULL;
	}
	void PrintList()
	{
		for (int i = 0; i < 3; i++)
		{
			if (L->next != NULL)
			{
				cout << L->next->data << endl;
				L->next = L->next->next;
			}
		}
	}
};

void test01()
{
	int a[3] = { 1,2,3 };
	LinkList l;
	l.CreatListF(a, sizeof(a) / sizeof(a[0]));
	l.PrintList();
	int b[2] = { 22,33 };
	l.CreatListB(b, sizeof(b) / sizeof(b[0]));
	l.PrintList();
}

int main()
{
	test01();
	system("pause");
}

但是，这些代码有些bug，因为每次链表的初始化在成员函数头插、尾插中进行，所以每调用一次插入函数，都会创建一个新的链表，导致会产生多个链表，而我们只想要一个链表，解决方法就是将链表的初始化放到链表类的构造函数中，修改后代码如下：

#include<iostream>
using namespace std;

struct LNode
{
	int data;				
	struct LNode* next;
};
using LinkNode = LNode;

class LinkList
{
public:
	LinkList() // 将链表的初始化放到链表类的构造函数中
	{
		L = new LinkNode; // 用new初始化不需要给LinkNode的大小
		L->data = 0;
		L->next = NULL;
	}
	LNode* L;
	void CreatListF(int a[], int n)
	{
		LinkNode* s;
		for (int i = 0; i < n; i++) // 原头插法的逻辑并无问题，在二次头插时并不会覆盖掉第一次的链表数据
		{
			s = new LinkNode;
			s->data = a[i];
			s->next = L->next;
			L->next = s;
		}
	}
	void CreatListB(int a[], int n)
	{
		LinkNode* s;
		LinkNode* temp; 
		temp = L;
		while (temp->next != NULL) // 解决方法就是在尾插前先将中间节点指向链表最后一个元素
		{
			temp = temp->next;
		}
		for (int i = 0; i < n; i++)
		{
			s = new LinkNode;
			s->data = a[i];
			temp->next = s;
			temp = s;
		}
		temp->next = NULL; // 原尾插法的逻辑有问题
        // 由于原来的逻辑是在链表头节点后利用中间节点直接进行尾插，并且插完后将中间节点的next指向NULL，导致二次尾插会覆盖掉链表中原来的数据
	}
	void PrintList()
	{
		LinkNode* temp = L->next; // 使用一个临时指针temp来遍历链表，而不是直接修改L指针
		while (temp != NULL)
		{
			cout << temp->data << endl;
			temp = temp->next;
		}
	}
};
// 在涉及链表的操作中，尽量避免直接修改指针指向的节点，以免导致链表遍历错误或元素丢失
// 整段代码除了头插法，其余地方均未对L直接进行修改，因为头插法修改L不会改变L的指向，其还是指向头节点

void test01() // 测试代码
{
	LinkList l;
	int a[3] = { 1,2,3 };
	l.CreatListF(a, sizeof(a) / sizeof(a[0]));
	l.PrintList();
	cout << "--------" << endl;
	int c[3] = { 11,22,33 };
	l.CreatListF(c, sizeof(c) / sizeof(c[0]));
	l.PrintList();
	cout << "--------" << endl;
	int b[2] = { 22,33 };
	l.CreatListB(b, sizeof(b) / sizeof(b[0]));
	l.PrintList();
	cout << "--------" << endl;
	int d[2] = { 111,222 };
	l.CreatListB(d, sizeof(d) / sizeof(d[0]));
	l.PrintList();
}

int main()
{
	test01();
	system("pause");
}

需要注意，在上述代码中，将void PrintList()改成下面的形式也不行：

LNode* L;
LNode* head;
head = L; // 即head指向头节点，然后对head进行操作而不是L
void PrintList()
{
    while (head->next != NULL)
    {
        cout << head->next->data << endl;
        head->next = head->next->next;
    }
}
// 错误的原因在于，这种方法的本质还是使用了中间变量head，不过这个中间变量对于类LinkList来说是全局的，所以在完成一次输出之后同样无法更新head指向的位置

下面，还差一个析构函数，应该怎么写呢？如果是下面这种写法：

~LinkList()
{
	if (L != NULL)
	{
		delete L;
	}
}

肯定是不行的，此时只会释放头节点的内存空间，而不会释放链表中其他节点的内存空间。如果链表中还有其他节点，并且它们是通过 new 运算符分配的内存空间，那么这些内存空间就不会被释放，会导致内存泄漏。

正确的做法是遍历链表，逐个删除节点，并释放节点的内存空间，而不是重复释放头节点的内存空间。可以像这样来实现析构函数：

~LinkList()
{
    LinkNode* current = L->next; // 指向第一个节点
    while (current != NULL)
    {
        LinkNode* temp = current;
        current = current->next; // 移动到下一个节点
        delete temp; // 释放当前节点的内存空间
    }
    // 最后释放头节点的内存空间
    delete L;
}

结论：在涉及链表的操作中，尽量避免直接修改指针指向的节点，以免导致链表遍历错误或元素丢失，解决方法是设置一个中间变量指针。