数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题

文章目录

  • 栈和队列上机实验
    • 1.要求
    • 2.栈的实现(以顺序栈为例)
    • 3.队列的实现(以顺序队列为例)
    • 4.利用栈实现进制转换
    • 5.利用队列解决约瑟夫环问题
    • 6.全部源码
      • Stack.h
      • Queue.h
      • test.cpp

栈和队列上机实验

1.要求

  1.利用栈的基本操作实现将任意一个十进制整数转化为R进制整数。

  2.利用循环队列实现.约瑟夫环问题:已知n个人(以编号1,2,3…n分别表示)围坐在一张圆桌周围。从编号为k的人开始报数,数到k的那个人出圈;他的下一个人又从1开始报数,数到k的那个人出圈;依此规律重复下去,直到圆桌周围的人只剩最后一个。模拟该游戏,并输出出圈顺序。

            

2.栈的实现(以顺序栈为例)

  栈的基本概念:

  栈(stack)是一种数据结构,它是一种只能在一端进行插入和删除操作的特殊线性表。这一端被称为栈顶,相对地,把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素;从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。

  
  栈的基本结构和初始化:

  我们定义了一个名为Stack的模板类,用于实现可以存储各种数据类型的栈的数据结构。我们创建了三个Stack的成员函数:_base、_top 和 _size。

  _base: 它作为动态分配的栈内存的起始位置。

  _top:表示栈顶的位置。 在构造函数中,它被初始化为指向InitStackSize个新分配的SElemType元素的数组的末尾。

  _size: 是一个整数,用于表示栈的当前大小,即栈中元素的数量。 在构造函数中,它被初始化为InitStackSize。

  构造函数: Stack()函数负责初始化这个栈。 它首先为_base和_top分配InitStackSize个SElemType大小的内存,并将_size设置为InitStackSize。

  析构函数: ~Stack()函数负责清理和释放由Stack对象持有的内存。 它首先删除_base指向的数组,然后将_base和_top设置为0,将_size设置为0。这是为了确保在对象销毁后,不会错误地引用任何内存地址。

  注意:数据结构的的实现是很灵活的,对于栈而言,顺序结构和链式结构都可以实现,当然,_base,_top等成员变量也可以设计成整型或者是指针,只要满足该数据类型的特征,就都可以设计。

template<class T>
class Stack
{
	//构造函数
	Stack()
	{
		_base = _top = new SElemType[InitStackSize];
		_size = InitStackSize;
	}

	//析构函数
	~Stack()
	{
		delete[] _base;
		_top = _base = 0;
		_size = 0;
	}

private:
	SElemType* _base, * _top;
	int _size;
};

  
  入栈和扩容操作:

  我们现在实现栈最基本的入栈操作,首先创建一个Push函数,它用于将一个元素压入栈中。如果栈满了,它会进行扩容操作。

  如果 _top 指针和 _base 指针之间的距离等于 _size(这意味着栈已经满了),那么将进行扩容操作。扩容操作包括创建一个新的数组(大小为原数组的两倍),然后复制原数组的元素到新数组中。 最后,更新 _base 指针指向新数组,_top 指针指向新数组的末尾,_size 变为新数组的大小。

  入栈操作,如果栈没有满,那么将 val 的值赋给 _top 指针所指向的位置,并将 _top 指针向前移动一位。 最后,_size 加一。

void Push(const SElemType& val)
{
	//栈满,扩容
	if (_top - _base == _size)
	{
		//转移栈中的元素
		SElemType* newbase = new SElemType[_size * 2];
		for (int i = 0; i < _size; i++)
		{
			newbase[i] = _base[i];
		}

		//删除原来栈中元素
		delete[] _base;
		_base = newbase;
		_top = newbase + _size;
		_size *= 2;
	}

	//入栈操作
	*_top = val;
	_top++;
	_size++;
}

  
  出栈操作:

  我们现在实现出栈操作,先创建一个名为Pop的函数,用于从栈中删除并返回栈顶元素。

  函数声明:Pop(SElemType& e) 是一个函数,它接受一个类型为 SElemType 的引用作为参数,命名为 e。引用的使用意味着我们可以在函数内部修改传入的参数,而不仅仅是它的副本。

  栈检查:在函数体中,首先检查栈的大小(_size),如果为0,说明栈是空的。 此时,会打印一条消息 ‘该栈为空,无法删除\n’ 并结束函数。出栈操作:如果栈非空,我们执行出栈操作。首先,将栈顶元素的值赋给参数 e。然后,将 _top 指针向前移动一位(即向下移动到栈顶元素的前一个位置),因为我们已经取出了栈顶元素。最后,_size 减一,因为栈中少了一个元素。

  这样,Pop 函数就能够从栈中删除并返回栈顶元素,同时还能处理空栈的情况。

void Pop(SElemType& e)
{
	if (_size == 0)
	{
		cout << "该栈为空,无法删除\n";
		return;
	}

	//出栈操作
	e = *_top;
	_top--;
	_size--;
}

  栈测试:

数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题_第1张图片

            

3.队列的实现(以顺序队列为例)

  队列的基本概念:

  队列是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。 和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。

  
  队列的基本结构和初始化:

  我们定义了一个名为Queue的C++模板类,用于实现可以存储不同数据类型的队列数据结构。我们创建了四个成员变量:

  _base:这是一个指向队列元素的指针。

  _front:这是队列的头部索引。

  _rear:这是队列的尾部索引。

  _capacity:这是队列的容量。

  构造函数:Queue的构造函数初始化了队列的基础元素数组。将队列的前端和后端索引设为0,并将队列的容量设为 ‘QueueSize’。这个 ‘QueueSize’ 应该是在类外部定义的常数,表示队列的最大容量。

  析构函数:当 Queue 对象被销毁时,析构函数将被调用。 这个析构函数删除了队列的基础元素数组,将 _base 设为 nullptr,将队列的前端和后端索引设为0,并将队列的容量设为0。这是为了释放队列占用的内存,并重置队列的状态。

template<class T>
class Queue
{
public:
	//构造函数
	Queue()
	{
		_base = new QElemType[QueueSize];
		_front = _rear = 0;
		_capacity = QueueSize;
	}

	//析构函数
	~Queue()
	{
		delete[] _base;
		_base = nullptr;
		_front = _rear = 0;
		_capacity = 0;
	}
	
private:
	QElemType* _base;
	int _front, _rear;
	int _capacity;
};

  
  入队和扩容操作:

  我们现在实现队列的入队函数,用于将一个元素添加到队列中。

  if (_front == (_rear + 1) % _capacity): 这是一个判断语句,它检查队列是否已满。这里的_front,_rear和_capacity可能是队列的私有成员变量。其中_front代表队列的第一个元素的位置,_rear代表队列的最后一个元素的位置(下一个插入元素的位置),_capacity代表队列的最大容量。如果_front等于_rear + 1 % _capacity,这意味着队列的下一个位置(_rear)已经被占用了,即队列已满。

  扩容:QElemType* newqueue = new QElemType[_capacity * 2];: 如果队列已满,这段代码会创建一个新的、容量是原队列两倍的队列。for (int i = _front; i < _rear; i++): 这个循环复制原队列中从_front到_rear - 1的所有元素到新的队列中。delete[] _base;: 释放原队列所占用的内存。_base = newqueue;: 将新队列的指针赋值给_base,这样原队列的指针就指向了新的队列。然后更新队列的容量即可。

  入队: 就在队列的最后一个位置插入新的元素。更新队列的最后一个位置即可。如果增加后超过了队列的容量,则取模(%)操作会将其限制在队列的范围内(0到_capacity-1)。

  顺序队列的一些操作和判断:

  空队列判断条件: rear == front

  尾指针的移动方式: rear = (rear+1)%QueueSize

  头指针的移动方式: front=(front+1)%QueueSize

  判断队列满: front == (rear+1)%QueueSize

数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题_第2张图片

void Push(const QElemType& val)
{
	//判断队列是否已满
	if (_front == (_rear + 1) % _capacity)
	{
		QElemType* newqueue = new QElemType[_capacity * 2];
		for (int i = _front; i < _rear; i++)
		{
			newqueue[i] = _base[i];
		}

		//删除原来栈中元素
		delete[] _base;
		_base = newqueue;
		_capacity *= 2;
	}

	_base[_rear] = val;
	//如果想让队列超过QueueSize的长度,一定要%_capacity;
	_rear = (_rear + 1) % _capacity;
}

  
  出队操作:

  实现队列出队操作我们先判断队列是否为空, 它检查队列的前端(_front)和后端(_rear)是否相等。如果相等,这意味着队列为空,没有元素可以删除。则输出信息直接返回,不执行任何操作。

  如果队列不为空,这行代码将_base数组中索引为_front的元素赋值给引用参数e。这意味着,当你调用Pop函数时,通过引用参数e来获取被出队的元素。当元素被删除后,前端位置需要更新以指向下一个未被删除的元素。 这里使用模运算符(%)来确保前端位置在超过队列容量时回到队列的开始位置。

void Pop(QElemType& e)
{
	if (_front == _rear)
	{
		cout << "队列为空,无法删除\n";
		return;
	}

	e = _base[_front];
	_front = (_front + 1) % _capacity;
}

  队列测试:

数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题_第3张图片

            

4.利用栈实现进制转换

  我们可以利用栈将一个十进制数转换为另一个进制数:

  函数首先声明了两个字符串变量s和table,以及两个整型量m和n。table是一个包含16个字符的字符串,用于表示16进制的数。

  然后函数要求用户输入要转换的十进制数m和目标进制数n。函数检查如果输入的数m为0,则直接输出0,因为0在任何进制下都等于0。

  接下来如果输入的数m为负数,则将其转换为正数,并标记flag为true,表示这个数之前是负数。然后我们创建了一个名为st的堆,利用堆的性质,可以存储转换后的字符。在while循环中,函数将输入的数m不断除以目标进制数n,取出每次的余数,将余数对应的字符从table中取出,并压入堆栈st中。 同时,更新输入的数m为原来的数除以目标进制数。

  如果之前标记过flag为true(即输入的数是负数),则在堆栈中压入一个’-'字符。最后,函数将堆栈中的所有字符取出并拼接到字符串s中,然后输出这个字符串。这个字符串就是转换后的数。

void Decimal_Conversion()
{
	string s, table = "0123456789ABCDEF";
	int m, n;
	cout << "请输入:m为输入的数,n为转换的进制\n";
	cout << "m=";
	cin >> m;
	cout << "n=";
	cin >> n;
	bool flag = false;
	if (m == 0) cout << "0";

	//如果是负数,则转成正数,并标记一下
	if (m < 0)
	{
		m = 0 - m;
		flag = true;
	}

	Stack<char> st;

	//按进制换算成对应的字符添加到s
	while (m)
	{
		st.Push(table[m % n]);
		m /= n;
	}
	if (flag)
	{
		st.Push('-');
	}

	while (!st.Empty())
	{
		s += st.Top();
		st.Pop();
	}
	cout << s << endl;
}

  测试:
  
10转化为2进制:1010

数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题_第4张图片  
150转化为8进制:226

数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题_第5张图片
  
100001转化为16进制:186A1

数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题_第6张图片
数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题_第7张图片
            

5.利用队列解决约瑟夫环问题

  我们可以利用队列解决约瑟夫环问题。约瑟夫环:描述了一组共m个人围成一圈,从第n个人开始报数,报到m的人出列,然后从下一个人重新开始报数,直到所有的人都出列的问题。

  首先,函数向用户提示输入约瑟夫环的两个人数m和n。然后,使用队列que来模拟人们围成的圆圈。初始时,将1到m的人依次入队。使用一个计数器count,从1开始计数,每次循环都会增加1,直到达到目标n。

  如果计数器count小于目标n,表示当前人不需要出列,将队头元素取出(即这个人),从队列中删除(模拟这个人跳过),然后将这个元素重新插入队尾(这个人回到圆圈的尾部)。 然后,计数器count加1,为下一次循环做准备。

  如果计数器count等于目标n,表示当前人需要出列,将队头元素取出并打印(这个人是出列的人),然后从队列中删除这个元素(模拟这个人完全出列),然后将计数器count重置为1,继续下一轮循环。

  当队列为空时,说明所有的人已经出列,退出循环。

void Joseph_Exchange()
{
	cout << "约瑟夫环问题:请输入一共有m人,第n人出局:\n";
	int m, n;
	cout << "m=";
	cin >> m;
	cout << "n="; 
	cin >> n;

	//填入队列中
	Queue<int> que;
	for (int i = 1; i <= m; i++)
	{
		que.Push(i);
	}

	//计数器,计到目标就输入
	int count = 1;
	while (!que.Empty())
	{
		if (count < n)
		{
			QElemType tmp = que.Head();
			que.Pop();
			que.Push(tmp);
			count++;
		}
		else if (count == n)
		{
			cout << que.Head() << " ";
			que.Pop();
			count = 1;
		}
	}
}

  测试:

数据结构上机实验——栈和队列的实现、栈和队列的应用、进制转换、约瑟夫环问题_第8张图片
            

6.全部源码

Stack.h

#pragma once

#define SElemType int
#define InitStackSize 100

template<class T>
class Stack
{
public:
	//构造函数
	Stack()
	{
		_base = _top = new SElemType[InitStackSize];
		_size = InitStackSize;
	}

	//析构函数
	~Stack()
	{
		delete[] _base;
		_top = _base = 0;
		_size = 0;
	}

	//入栈
	void Push(const SElemType& val)
	{
		//栈满,扩容
		if (_top - _base == _size)
		{
			//转移栈中的元素
			SElemType* newbase = new SElemType[_size * 2];
			for (int i = 0; i < _size; i++)
			{
				newbase[i] = _base[i];
			}

			//删除原来栈中元素
			delete[] _base;
			_base = newbase;
			_top = newbase + _size;
			_size *= 2;
		}

		//入栈操作
		*_top = val;
		_top++;
		_size++;
	}

	//出栈
	void Pop(SElemType& e)
	{
		if (_size == 0)
		{
			cout << "该栈为空,无法删除\n";
			return;
		}

		//出栈操作
		e = *_top;
		_top--;
		_size--;
	}

	//重载出栈
	void Pop()
	{
		if (_size == 0)
		{
			cout << "该栈为空,无法删除\n";
			return;
		}

		//出栈操作
		_top--;
	}

	//输出栈顶元素
	SElemType Top()
	{
		if (_base == _top)
		{
			cout << "栈空,没有元素\n";
			return -1;
		}

		return *(_top - 1);
	}

	//判断栈空
	bool Empty()
	{
		if (_base == _top)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	//打印栈中的元素
	void Print()
	{
		SElemType* cur = _base;
		if (_base == _top)
		{
			cout << "该栈为空\n";
			return;
		}
		else
		{
			cout << "该栈中的元素为:";
			while (cur != _top)
			{
				cout << *cur << " ";
				cur++;
			}
			cout << endl;
		}
	}

private:
	SElemType* _base, * _top;
	int _size;
};

            

Queue.h

#pragma once

#define QueueSize 100
#define QElemType int

template<class T>
class Queue
{
public:
	//构造函数
	Queue()
	{
		_base = new QElemType[QueueSize];
		_front = _rear = 0;
		_capacity = QueueSize;
	}

	//析构函数
	~Queue()
	{
		delete[] _base;
		_base = nullptr;
		_front = _rear = 0;
		_capacity = 0;
	}

	//入队操作
	void Push(const QElemType& val)
	{
		//判断队列是否已满
		if (_front == (_rear + 1) % _capacity)
		{
			QElemType* newqueue = new QElemType[_capacity * 2];
			for (int i = _front; i < _rear; i++)
			{
				newqueue[i] = _base[i];
			}

			//删除原来队列中元素
			delete[] _base;
			_base = newqueue;
			_capacity *= 2;
		}

		_base[_rear] = val;
		//如果想让队列超过QueueSize的长度,一定要%_capacity;
		_rear = (_rear + 1) % _capacity;
	}

	//出队操作
	void Pop(QElemType& e)
	{
		if (_front == _rear)
		{
			cout << "队列为空,无法删除\n";
			return;
		}

		e = _base[_front];
		_front = (_front + 1) % _capacity;
	}

	//重载出队操作
	void Pop()
	{
		if (_front == _rear)
		{
			cout << "队列为空,无法删除\n";
			return;
		}

		_front = (_front + 1) % _capacity;
	}

	//输出队头元素
	QElemType Head()
	{
		if (_front == _rear)
		{
			cout << "队列为空,无队头元素\n";
			return -1;
		}
		
		return _base[_front];
	}

	//判断是否为空队列
	bool Empty()
	{
		if (_front == _rear)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	//打印队列中的元素
	void Print()
	{
		if (_front == _rear)
		{
			cout << "该队列为空\n";
			return;
		}
		else
		{
			cout << "该队列中的元素为:";
			for (int i = _front; i < _rear; i++) 
			{
				std::cout << _base[i] << " ";
			}
			cout << endl;
		}
	}

private:
	QElemType* _base;
	int _front, _rear;
	int _capacity;
};

            

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include
using namespace std;

#include"Stack.h"
#include"Queue.h"

void stack_test()
{
	Stack<int> st;
	st.Print();
	cout << "该栈是否为空:" << st.Empty() << endl;
	st.Push(1);
	st.Push(2);
	st.Push(3); 
	st.Push(4);
	st.Print();
	cout << "栈顶元素为:" << st.Top() << endl;
	st.Pop();
	st.Pop();
	st.Print();
	cout << "该栈是否为空:" << st.Empty() << endl;
	st.Push(5);
	st.Push(6);
	st.Push(7);
	st.Push(8);
	st.Print();
	cout << "栈顶元素为:" << st.Top() << endl;
	st.Pop();
	st.Pop();
	st.Print();
}

void queue_test()
{
	Queue<int> que;
	que.Print();
	cout << "该队列是否为空:" << que.Empty() << endl;
	que.Push(1);
	que.Push(2);
	que.Push(3);
	que.Push(4);
	que.Print();
	cout << "队头元素为:" << que.Head() << endl;
	que.Pop();
	que.Pop();
	que.Print();
	cout << "该队列是否为空:" << que.Empty() << endl;
	que.Push(5);
	que.Push(6);
	que.Push(7);
	que.Push(8);
	que.Print();
	cout << "队头元素为:" << que.Head() << endl;
	que.Pop();
	que.Pop();
	que.Print();
}

void Decimal_Conversion()
{
	string s, table = "0123456789ABCDEF";
	int m, n;
	cout << "请输入:m为输入的数,n为转换的进制\n";
	cout << "m=";
	cin >> m;
	cout << "n=";
	cin >> n;
	bool flag = false;
	if (m == 0) cout << "0";

	//如果是负数,则转成正数,并标记一下
	if (m < 0)
	{
		m = 0 - m;
		flag = true;
	}

	Stack<char> st;

	//按进制换算成对应的字符添加到s
	while (m)
	{
		st.Push(table[m % n]);
		m /= n;
	}
	if (flag)
	{
		st.Push('-');
	}

	while (!st.Empty())
	{
		s += st.Top();
		st.Pop();
	}
	cout << s << endl;
}

void Joseph_Exchange()
{
	cout << "约瑟夫环问题:请输入一共有m人,第n人出局:\n";
	int m, n;
	cout << "m=";
	cin >> m;
	cout << "n="; 
	cin >> n;

	//填入队列中
	Queue<int> que;
	for (int i = 1; i <= m; i++)
	{
		que.Push(i);
	}

	//计数器,计到目标就输入
	int count = 1;
	while (!que.Empty())
	{
		if (count < n)
		{
			QElemType tmp = que.Head();
			que.Pop();
			que.Push(tmp);
			count++;
		}
		else if (count == n)
		{
			cout << que.Head() << " ";
			que.Pop();
			count = 1;
		}
	}
}

int main()
{
	//stack_test();
	//queue_test();
	//Decimal_Conversion();
	Joseph_Exchange();
	return 0;
}

你可能感兴趣的:(数据结构,数据结构,c++,课程设计)