算法导论第十章-基本数据结构-Cpp代码实现

实现了3个基本的数据结构：栈，队列和双向链表。

basic_data_struct.h

#pragma once

/*************************************************
Author:董小歪
Date:2016-06-10
Description:算法导论第十章-基本数据结构-Cpp代码实现
**************************************************/

#ifndef BASIC_DATA_STRUCT_H
#define BASIC_DATA_STRUCT_H

#include <iostream>
#include <vector>

using namespace std;

//*************************************************栈*************************************************
template <typename T>
class MyStack
{
public:
	MyStack(unsigned _max_size);						//构造函数确定栈的大小
	inline bool stack_empty() { return p_top < 0; }		//是否为空栈
	bool push(T e);										//入栈
	bool pop();											//出栈
	T top();											//返回栈顶元素
	void print_data();									//打印所有栈内元素
private:
	vector<T> data;										//元素数组
	const unsigned max_size;							//栈的最大值
	int p_top;											//栈顶下标
};

template <typename T>
MyStack<T>::MyStack(unsigned _max_size) :max_size(_max_size), p_top(-1) //栈顶初始化为-1
{
	data.resize(_max_size);
}

template <typename T>
bool MyStack<T>::push(T e)
{
	if (p_top + 1 < max_size)  //开始犯了一个错误，这里不能用 （p_top < max_size - 1），因为max_size是unsigned的。可能会出现溢出
	{
		data[++p_top] = e;
		return true;
	}
	else
		return false;	
}

template <typename T>
bool MyStack<T>::pop()   
{
	if (stack_empty())
		return false;
	--p_top;     //弹出栈顶元素并不是真的清空，而是改变栈顶下标
	return true;
}

template <typename T>
T MyStack<T>::top()
{
	if (stack_empty())
		return 0;
	return data[p_top];
}

template <typename T>
void MyStack<T>::print_data()
{
	if (stack_empty())
		cout << "stack is empty!!!" << endl;
	else
	{
		for (int i = 0; i <= p_top; ++i)
			cout << data[i] << " ";
		cout << endl;
	}
}


//*************************************************队列*************************************************
template <typename T>
class MyQueue
{
public:
	MyQueue(unsigned _max_size);											//构造函数，必须指定队列大小
	inline bool queue_empty() { return tail == head; }						//是否队空
	inline bool queue_isfull() { return (tail + 1) % max_size == head; }	//是否队满
	bool enqueue(T e);														//元素入队
	bool dequeue();															//元素出队
	void print_data();														//打印队列元素
private:
	vector<T> data;				//元素
	int tail, head;				//头尾下标
	const unsigned max_size;	//队列最大元素个数
	int data_num;				//当前元素个数
};

template <typename T>
MyQueue<T>::MyQueue(unsigned _max_size) :max_size(_max_size + 1), tail(0), head(0), data_num(0)  
{
	data.resize(max_size);//这里是为了能同时判断队空和队满两种情况，所以要空一个位置出来。所以max_size = _max_size + 1
}

template <typename T>
bool MyQueue<T>::enqueue(T e)
{
	if (queue_isfull())
		return false;
	tail = (tail + 1) % max_size;
	data[tail] = e;
	++data_num;
	return true;
}

template <typename T>
bool MyQueue<T>::dequeue()
{
	if (queue_empty())
		return false;
	head = (head + 1) % max_size;
	--data_num;
	return true;
}

template <typename T>
void MyQueue<T>::print_data()
{
	for (int index = (head + 1) % max_size, i = 1; i <= data_num; ++i, index = (index + 1) % max_size)
		cout << data[index] << " ";
	cout << endl;
}

//*************************************************双向链表*************************************************

template <typename T>				//链表结点定义
struct ListNode {
	T key;
	ListNode<T>* prev;
	ListNode<T>* next;
	ListNode(T _key) :key(_key), prev(nullptr), next(nullptr) { }
};

template <typename T>
class MyList {
public:
	MyList() :head(nullptr) {}			//构造函数
	ListNode<T>* list_search(T key);	//元素搜索
	bool list_insert(T key);			//元素插入
	bool list_delete(T key);			//元素删除
	void print_list();					//打印元素
private:
	ListNode<T>* head;					//表头
};

template <typename T>
ListNode<T>* MyList<T>::list_search(T key)
{
	ListNode<T>* cur = head;
	while (cur && cur->key != key)
		cur = cur->next;
	return cur;					//如果不存在，则返回的是空指针
}

template <typename T>
bool MyList<T>::list_insert(T key)
{
	ListNode<T>* x = new ListNode<T>(key);
	if (head)
	{
		ListNode<T>* temp = head;
		x->next = temp;
		temp->prev = x;			//如果存在头元素，别忘了改变prev
	}
	head = x;
	return true;
}

template <typename T>
bool MyList<T>::list_delete(T key)
{
	if (head && head->key == key)  //如果删除的是头元素
	{
		head = head->next;
		head->prev = nullptr;
		return true;
	}
	ListNode<T>* find = list_search(key);
	if (!find)
		return false;
	else
	{
		if (find->next)						//如果不是链表尾，测需要改变删除结点下一结点的prev指针
			find->next->prev = find->prev;
		find->prev->next = find->next;		//因为已经排除了链表头的情况，所以prev肯定存在
		return true;
	}
}

template <typename T>
void MyList<T>::print_list()
{
	if (!head)
		cout << "List is empty!!!" << endl;
	else
	{
		ListNode<T>* cur = head;
		while (cur)
		{
			cout << cur->key << " ";
			cur = cur->next;
		}
		cout << endl;
	}
}

#endif //!BASIC_DATA_STRUCT_H

测试：

main_entrance.cpp

#include "basic_data_struct.h"

int main()
{
	
	cout << "创建栈对象，大小为5" << endl;
	MyStack<int> mystk(5);
	cout << "栈是否为空？" << boolalpha << mystk.stack_empty() << endl;
	cout << "栈内元素：";mystk.print_data();
	cout << "压入3" << endl;	mystk.push(3);
	cout << "栈是否为空？" << boolalpha << mystk.stack_empty() << endl;
	cout << "压入4" << endl;	mystk.push(4);
	cout << "压入2" << endl;	mystk.push(2);
	cout << "栈内元素：";mystk.print_data();
	cout << "压入1" << endl;	mystk.push(1);
	cout << "压入5" << endl;	mystk.push(5);
	cout << "栈内元素：";mystk.print_data();
	cout << "压入6" << endl;	mystk.push(6);
	cout << "栈内元素：";mystk.print_data();
	cout << "栈顶元素是：" << mystk.top() << endl;	
	cout << "弹出栈顶元素后："; mystk.pop(); mystk.print_data();

	cout << endl << "创建队列对象，大小为5" << endl;
	MyQueue<int> myque(5);
	cout << "队列是否为空？" << boolalpha << myque.queue_empty() << endl;
	cout << "元素4入队" << endl;	myque.enqueue(4);
	cout << "队列是否为空？" << boolalpha << myque.queue_empty() << endl;
	cout << "元素2入队" << endl;	myque.enqueue(2);
	cout << "元素3入队" << endl;	myque.enqueue(3);
	cout << "队列内元素：";	myque.print_data();
	cout << "队列是否满？" << boolalpha << myque.queue_isfull() << endl;
	cout << "元素5入队" << endl;	myque.enqueue(5);
	cout << "元素7入队" << endl;	myque.enqueue(7);
	cout << "队列是否满？" << boolalpha << myque.queue_isfull() << endl;
	cout << "队列内元素：";	myque.print_data();
	cout << "元素11入队" << endl;	myque.enqueue(11);
	cout << "队列是否满？" << boolalpha << myque.queue_isfull() << endl;
	cout << "队列内元素：";	myque.print_data();
	cout << "元素出队" << endl;	myque.dequeue();
	cout << "队列内元素：";	myque.print_data();
	cout << "队列是否满？" << boolalpha << myque.queue_isfull() << endl;
	cout << "元素1入队" << endl;	myque.enqueue(1);
	cout << "队列是否满？" << boolalpha << myque.queue_isfull() << endl;
	cout << "队列内元素：";	myque.print_data();
	cout << "元素出队" << endl;	myque.dequeue();
	cout << "元素出队" << endl;	myque.dequeue();
	cout << "元素出队" << endl;	myque.dequeue();
	cout << "元素出队" << endl;	myque.dequeue();
	cout << "队列内元素：";	myque.print_data();
	cout << "元素出队" << endl;	myque.dequeue();
	cout << "队列是否为空？" << boolalpha << myque.queue_empty() << endl;
	

	cout << "创建链表" << endl; MyList<int> ml;
	cout << "当前元素："; ml.print_list();	
	cout << "插入元素5："; ml.list_insert(5); ml.print_list();	
	cout << "插入元素10："; ml.list_insert(10); ml.print_list();
	cout << "插入元素20："; ml.list_insert(20); ml.print_list();
	cout << "插入元素40："; ml.list_insert(40); ml.print_list();
	cout << "搜索元素10：" << endl;
	if (ml.list_search(10))
		cout << "元素存在：" << ml.list_search(10)->key << endl;
	else
		cout << "元素不存在" << endl;
	
	cout << "搜索元素15：" << endl;
	if (ml.list_search(15))
		cout << "元素存在：" << ml.list_search(15)->key << endl;
	else
		cout << "元素不存在" << endl;

	cout << "删除元素10："; ml.list_delete(10); ml.print_list();
	cout << "删除元素40："; ml.list_delete(40); ml.print_list();
	cout << "删除元素5："; ml.list_delete(5); ml.print_list();

	system("pause");
}

测试结果：