数据结构——栈（c++版）

栈

• 同c语言一样，可以复用链表中的代码，通过链表创建栈。

#include<iostream>
#include<string>

using namespace std;

typedef struct Vivo
{
	//用户数据域
	int price;
	string name;
}vivo;

struct car
{
	string name;
	int num;
};

template<typename T>
struct node
{
	T t;
	node* next;
};

template<class T>
class Car;

template<typename T>
class Phone
{
public:
	Phone();
	~Phone();
	void insert_list(T*input, int pos);
	T* find_list(int pos);
	T* delete_list(int pos);
	void cls_list();
	int length_list();

	//定义友元函数，用作打印输出
	friend void print_top(Car<car>& p);

private:
	node<T>* head;
	int length;
};

template<typename T>
Phone<T>::Phone()
{
	cout << "开始初始化链表！\n\n";
	head = new node<T>;
	length = 0;
	head->next = nullptr;
}

template<typename T >
Phone<T>::~Phone()
{
	if (head == nullptr)
	{
		cout << "链表为空！析构退出！\n\n";
		return;
	}
	delete head;
	length = 0;
	head = nullptr;
	cout << "链表清除成功！\n\n";
}

template<typename T>
void Phone<T>::insert_list(T * input, int pos)
{
	if (pos < 0)
	{
		cout << "位置错误！\n\n";
		return;
	}
	if (pos > length)
	{
		pos = length;
	}
	//做两个辅助正在变量：
	node<T>*current = head;
	node<T>*temp_in = (node<T>*)input;

	for (int i = 0; i < pos; i++)
	{
		current = current->next;
	}
	temp_in->next = current->next;
	current->next = temp_in;
	length++;
	cout << "插入成功！\n\n";
}

template<typename T>
T * Phone<T>::find_list(int pos)
{
	if (pos < 0 || pos > length)
	{
		cout << "位置错误！\n\n";
		return nullptr;
	}
	if (head == nullptr)
	{
		cout << "链表为空！\n\n";
		return nullptr;
	}
	node<T>* current = head;
	for (int i = 0; i < pos; i++)
	{
		current = current->next;
	}
	cout << "找到啦！\n\n";
	return (T*)current->next;
}

template<typename T>
T* Phone<T>::delete_list(int pos)
{
	if (pos < 0 || pos >= length)
	{
		cout << "位置错误！\n\n";
		return nullptr;
	}
	if (head == nullptr)
	{
		cout << "链表尾空！\n\n";
		return nullptr;
	}
	cout << "开始删除位置：" << pos << "处的节点！\n\n";
	node<T>*current = head;
	for (int i = 0; i < pos - 1; i++)
	{
		current = current->next;
	}
	node<T>*buf_del = current->next;
	current->next = buf_del->next;
	length--;
	return (T*)buf_del;
}

template<typename T>
void Phone<T>::cls_list()
{
	if (head == nullptr)
	{
		cout << "链表为空！析构退出！\n\n";
		return;
	}
	delete head;
	head = new node<T>;
	length = 0;
	head = nullptr;
	cout << "链表重置成功！\n\n";

	/*创建临时变量保存删除元素：
	node<T>* temp_cls = nullptr;

	while (head->next != nullptr)
	{
		//从当前位置开始依次往后循环删除
		temp_cls = head->next;
		head = temp_cls->next;
		//delete temp_cls;
		//head = head->next;
	}
	*/
}

template<typename T>
int Phone<T>::length_list()
{
	return length;
}

template<class T>
class Car
{
public:
	Car();
	~Car();
	 void insert_stack(T*t);
	 T*top_stack();
	 T*pop_stack();
	 void cls_stack();
	 int length_stack();
private:
	//以可以用继承的方式private
	Phone<T> *list;
};

//print_list本身并不是模板函数，而只是使用了一个模板参数。
//这意味着必须要为友元定义显示具体化。
void print_top(Car<car>& p)
{
	car* find_;
	if (p.length_stack() > 0)
	{
		find_ = p.top_stack();
		cout << "name: " << find_->name << " , num: " << find_->num << endl << endl;
	}
	else
	{
		cout << "链表为空！无法遍历！\n\n";
		return;
	}
}

int main()
{
	Car<car> bmw;

	car* c1 = new car;
	c1->name = "BMW";
	c1->num = 666;
	bmw.insert_stack(c1);
	print_top(bmw);
	
	car* c2 = new car;
	c2->name = "AUDI";
	c2->num = 777;
	bmw.insert_stack(c2);
	print_top(bmw);

	car* c3 = new car;
	c3->name = "布加迪";
	c3->num = 888;
	bmw.insert_stack(c3);
	print_top(bmw);

	bmw.pop_stack();
	print_top(bmw);

	car* c4 = new car;
	c4->name = "奔驰";
	c4->num = 999;
	bmw.insert_stack(c4);
	print_top(bmw);
	return 0;
}

template<class T>
Car<T>::Car()
{
	//先创建空链表
	list = new Phone<T>;
}

template<class T>
Car<T>::~Car()
{
	if (list == nullptr)
	{
		cout << "栈为空，退出析构！\n\n";
		return;
	}
	cout << "开始析构！\n\n";
	list->cls_list();
}

template<class T>
void Car<T>::insert_stack(T*t)
{
	if (list == nullptr)
	{
		cout << "栈为空！已退出！\n\n";
		return;
	}
	list->insert_list(t,0);
}

template<class T>
T * Car<T>::top_stack()
{
	if (list == nullptr)
	{
		cout << "栈为空！已退出！\n\n";
		return nullptr;
	}
	return list->find_list(0);
}

template<class T>
T * Car<T>::pop_stack()
{
	if (list == nullptr)
	{
		cout << "栈为空！已退出！\n\n";
		return nullptr;
	}
	return list->delete_list(0);
}

template<class T>
void Car<T>::cls_stack()
{
	if (list == nullptr)
	{
		cout << "栈为空！已退出！\n\n";
		return nullptr;
	}
	list->cls_list();
}

template<class T>
int Car<T>::length_stack()
{
	return list->length_list();
}