单链表类定义析构函数
时间: 2023-10-19 19:09:04 浏览: 38
单链表类的析构函数定义如下:
class ListNode {
public:
~ListNode() {
cout << "节点被销毁!" << endl;
if (next != nullptr) {
delete next;
}
}
private:
int data;
ListNode* next;
};
该析构函数的作用是依次销毁链表中的节点,直到链表为空。
相关问题
已知一个有序链表类LinkSortList及main函数的部分代码如下,请完成LinkSortList类的成员函数,得到对应的运行结果,勿改动main函数。 //有序表类 template <class T> class LinkSortList { public: LinkSortList( ); //建立只有头结点的空链表 ~LinkSortList(); //析构函数 void Insert(T x); //在有序单链表中插入元素x使序列仍有序 int Length(); //求表长 int DeleteOdd(); //在单链表中删除所有奇数,返回值为奇数个数 void DispList( ); //遍历有序单链表,按序号依次输出各元素 private: Node<T> *first; //单链表的头指针 }; int main( ){ LinkSortList<int> sa; int x; while(1) { cin>>x; if(!x)break; sa.Insert(x); } sa.DispList(); int count=sa.DeleteOdd(); cout<<"Count of deleted odds:"<<count<<endl; sa.DispList(); return 0; }
已知一个有序链表类LinkSortList及main函数的部分代码如下,请完成LinkSortList类的成员函数,得到对应的运行结果,勿改动main函数。
```
#include <iostream>
using namespace std;
//定义结点类
template <class T>
class Node {
public:
T data;
Node<T> *next;
Node(T d, Node<T> *n = NULL) :data(d), next(n) {}
};
//有序表类
template <class T>
class LinkSortList {
public:
LinkSortList() :first(NULL) {} //建立只有头结点的空链表
~LinkSortList(); //析构函数
void Insert(T x); //在有序单链表中插入元素x使序列仍有序
int Length();
int DeleteOdd(); //在单链表中删除所有奇数,返回值为奇数个数
void DispList(); //遍历有序单链表,按序号依次输出各元素
private:
Node<T> *first; //单链表的头指针
};
template<class T>
LinkSortList<T>::~LinkSortList()
{
Node<T> *p;
while (first != NULL)
{
p = first;
first = first->next;
delete p;
}
}
template<class T>
void LinkSortList<T>::Insert(T x)
{
Node<T> *p = first, *q = NULL;
while (p != NULL && x >= p->data)
{
q = p;
p = p->next;
}
Node<T> *newNode = new Node<T>(x);
if (q == NULL)
{
first = newNode;
}
else
{
q->next = newNode;
}
newNode->next = p;
}
template<class T>
int LinkSortList<T>::Length()
{
int count = 0;
Node<T> *p = first;
while (p != NULL)
{
count++;
p = p->next;
}
return count;
}
template<class T>
int LinkSortList<T>::DeleteOdd()
{
int count = 0;
Node<T> *p = first, *q = NULL;
while (p != NULL)
{
if (p->data % 2 == 1)
{
count++;
if (q == NULL)
{
first = p->next;
delete p;
p = first;
}
else
{
q->next = p->next;
delete p;
p = q->next;
}
}
else
{
q = p;
p = p->next;
}
}
return count;
}
template<class T>
void LinkSortList<T>::DispList()
{
Node<T> *p = first;
while (p != NULL)
{
cout << p->data << " ";
p = p->next;
}
cout << endl;
}
int main()
{
LinkSortList<int> sa;
int x;
while (1)
{
cin >> x;
if (!x)
break;
sa.Insert(x);
}
sa.DispList();
int count = sa.DeleteOdd();
cout << "Count of deleted odds:" << count << endl;
sa.DispList();
return 0;
}
```
单链表实现
好的,单链表是一种常用的数据结构,下面是单链表的实现示例:
```c++
#include <iostream>
using namespace std;
//定义链表结点
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(nullptr) {}
};
//定义链表类
class LinkedList {
public:
//构造函数
LinkedList() {
head = nullptr;
}
//析构函数
~LinkedList() {
ListNode *curr = head;
while (curr != nullptr) {
ListNode *temp = curr;
curr = curr->next;
delete temp;
}
}
//在链表尾部添加结点
void addNode(int val) {
ListNode *node = new ListNode(val);
if (head == nullptr) {
head = node;
} else {
ListNode *curr = head;
while (curr->next != nullptr) {
curr = curr->next;
}
curr->next = node;
}
}
//删除链表中的某个结点
void deleteNode(int val) {
if (head == nullptr) {
return;
} else if (head->val == val) {
ListNode *temp = head;
head = head->next;
delete temp;
} else {
ListNode *prev = head;
ListNode *curr = head->next;
while (curr != nullptr && curr->val != val) {
prev = curr;
curr = curr->next;
}
if (curr != nullptr) {
prev->next = curr->next;
delete curr;
}
}
}
//遍历链表并打印
void printList() {
ListNode *curr = head;
while (curr != nullptr) {
cout << curr->val << " ";
curr = curr->next;
}
cout << endl;
}
private:
ListNode *head;
};
```
这里定义了一个 `ListNode` 结构体作为链表的结点,包含两个成员变量 `val` 和 `next`,分别表示当前结点的值和下一个结点的指针。`LinkedList` 类包含链表的构造函数、析构函数、添加结点、删除结点和遍历链表并打印的方法。其中,添加结点方法是在链表的尾部添加新结点,删除结点方法是删除链表中的某个值等于给定值的结点。