基于链表实现堆栈和队列操作(C++类的继承）

基于链表实现堆栈和队列操作(C++类的继承）

首先创建节点Node类
Node.h

#pragma once
class Node
{
public:
	int data;
	Node* next;
};

对于Node类在这里data结构最好不要使用int形扩展性太低，应该将其变为struct结构可以提升代码的拓展性。
然后创建list类对链表操作
list.h

#pragma once
#include"Node.h"
class list
{
protected:
	Node* head;
	Node* tempt;
	int length;
	list();//默认构造函数
	void apend(int num);//链表数据末尾追加
	void delete_index(int index);//按索引进行删除
	void find_index(int index);//按索引查找
	void insert_index(int index, int num);//按索引插入数据
	~list();//析构函数
public:
	void show();//链表的输出
};

list.cpp

#include<iostream>//测试代码
#include<cstdlib>
#include "list.h"

list::list()
{
	head = new Node;//参数的初始化

	tempt = head;//当前指针指向head

	head->next = nullptr;//必须添加头文件#include<cstdlib>
	length = 0;
	std::cout << "基类初始化完成" << std::endl;//确定类是否创建成功
}


void list::apend(int num)
{
	if (length == 0) {
		head->data = num;
		length++;
	}
	else {
		tempt->next = new Node;//申请空间
		tempt = tempt->next;//后挪当前指针
		tempt->data = num;//赋值
		tempt->next = nullptr;//末尾空指针
		length++;
	}
	
}

void list::show()
{
	if (length == 0)
		std::cout << "该列表为空" << std::endl;
	else if (length == 1)
		std::cout << head->data << std::endl;//在该种算法下考虑length为1的情况
	else {
		Node* temp = head;//保存head信息
		int i = 1;
		while (i<=length)//采用nullptr方式会出现问题最后一个扫描不到
		{
			std::cout << temp->data << ' ';
			temp = temp->next;
			i++;
		}
		std::cout << std::endl;
	}
}

void list::find_index(int index)
{
	if (length == 0)
		std::cout << "该列表为空" << std::endl;
	else if (index > length)
		std::cout << "超出索引值" << std::endl;
	else {
		if (index == 1)//该种链表对首部需要单独考虑
			std::cout << head->data << std::endl;
		else {
			int i = 1;
			Node* temp = head;//从首部开始移动查询
			while (i != index)
			{
				temp = temp->next;
				i++;
			}
			std::cout << temp->data << std::endl;
		}
	}
}

void list::delete_index(int index)
{
	if (length == 0)
		std::cout << "该列表为空" << std::endl;
	else if (index > length)
		std::cout << "超出索引值" << std::endl;
	else {
		if (index == 1) {
			Node* Need_delet = head;
			head = head->next;
			delete Need_delet;
			length--;
		}
		else {
			int i = 1;
			Node* temp = head;//从首部开始移动查询
			while (i != index - 1)
			{
				temp = temp->next;
				i++;
			}
			Node* Need_delet = temp->next;//保存删除的节点地址
			temp->next = Need_delet->next;//将index-1节点接入index+1
			delete Need_delet;//删除当前节点
			length--;//总体长度减一
		}
	}
}
/*
* 说明按索引后插入
* index在第几个后面插入
* num表示插入的数据
*/
void list::insert_index(int index, int num)
{
	if (index == 1) {
		Node* insert_node = new Node;//为插入的节点分配空间
		insert_node->data = num;
		insert_node->next = head->next;
		head->next = insert_node;
		length++;
	}
	else {
		int i = 1;
		Node* temp = head;//从首部开始移动查询
		while (i != index)
		{
			temp = temp->next;
			i++;
		}
		Node* insert_node = new Node;//为插入的节点分配空间
		insert_node->data = num;
		insert_node->next = temp->next;
		temp->next = insert_node;
		length++;
	}
}

list::~list()
{
	if (length == 0||length==1) {                 //当前处理模式下1也是特殊情况
		delete head;
		std::cout << "基类已经释放" << std::endl;//确定空间是否释放
	}
	else {
		while (head->next != nullptr) {
			Node* temp = head;//保留当前方便删除
			head = head->next;
			delete temp;
		}
		delete head;
		std::cout << "基类已经释放" << std::endl;
	}
}

以list类作为基类进行派生得到Stack和Queque。
Stack.h

#pragma once
#include "list.h"
class Stack :
    public list
{
public:
    Stack();
    ~Stack();
    void Pop(int num);
    void Push();
};

Stack.cpp

#include<iostream>//为测试使用
#include "Stack.h"
Stack::Stack():list()
{
	std::cout << "子类初始化完成" << std::endl;
}

void Stack::Pop(int num)
{
	if (length == 0) {
		head->data = num;
		length++;
	}
	else {
		Node* temp = new Node;//申请空间给新节点
		temp->data = num;
		temp->next = head;//将该节点插入头部
		head = temp;//移动首指针
		length++;//更新链表长度
	}
}

void Stack::Push()
{
	//std::cout << head->data << std::endl;
	delete_index(1);
}

Stack::~Stack()
{
	std::cout << "子类已释放" << std::endl;
}

Queque.h

#pragma once
#include "list.h"
class Queque :
    public list
{
public:
    Queque();
    ~Queque();
    void AddQ(int num);//入队列
    void DeleteQ();//出队列
};

Queque.cpp

#include "Queque.h"

Queque::Queque()
{
}

Queque::~Queque()
{
}

void Queque::AddQ(int num)
{
	if (length == 0) {
		head->data = num;
		length++;
	}
	else{
		insert_index(length, num);
	}
}

void Queque::DeleteQ()
{
	delete_index(1);
}

下面是测试程序
test.cpp

#include<iostream>
#include"Stack.h"
#include"Queque.h"

int main() {
	//堆栈测试程序
	std::cout << "堆栈测试程序" << std::endl;
	Stack stack;
	stack.Pop(5);
	stack.Pop(4);
	stack.Pop(3);
	stack.Pop(2);
	stack.Pop(1);
	stack.show();
	stack.Push();
	stack.show();
	//stack.~Stack();
	std::cout << "*********************************************" << std::endl;
	std::cout << "队列测试程序" << std::endl;
	Queque queque;
	queque.AddQ(1);
	queque.AddQ(2);
	queque.AddQ(3);
	queque.AddQ(4);
	queque.AddQ(5);
	queque.show();
	queque.DeleteQ();
	queque.show();
	//queque.~Queque();
	std::cout << "*********************************************" << std::endl;
	return 0;
}

测试结果如下：