数据结构考前背代码1：最小生成树，插入排序，循环队列约瑟夫

1.最小生成树

#include<iostream>
#include<vector>
using namespace std;
int grap[50][50];
typedef struct tree
{
	int weight;
	int parent;
	int flag;
}tree;
int getmin(tree* arr, int limit)
{
	int minweight = 9999;
	int ret = 0;
	for (int i = 1; i <= limit; i++)
	{
		if (arr[i].weight < minweight && arr[i].flag == 0)
		{
			minweight = arr[i].weight;
			ret = i;
		}
	}
	return ret;
}
void plm(int limit)
{
	int sum = 0;
	tree arr[100];
	vector<int>tree;
	tree.push_back(1);
	for (int i = 1; i <= limit; i++)
	{
		arr[i].parent = 1;
		arr[i].weight = grap[1][i];
		arr[i].flag = 0;
	}
	
	for (int i = 1; i <= limit; i++)
	{
		int	min = getmin(arr, limit);
		sum += arr[min].weight;
		arr[min].flag = 1;
		tree.push_back(min);
		for (int i = 2; i <= limit; i++)
		{
			if (grap[min][i] < arr[i].weight)
			{
				arr[i].weight = grap[min][i];
				arr[i].parent = min;
			}
		}
	}
	for (int i = 0; i < tree.size(); i++)
	{
		cout << tree[i] << ' ';
	}
	cout << endl << sum;
	 }
int main()
{
	int num;
	int edge;
	cin >> num >> edge;
	for (int i = 1; i <= num; i++)
	{
		for (int j = 1; j <= num; j++)
		{
			grap[i][j] = 9999;
		}
	}
	for (int i = 0; i < edge; i++)
	{
		int begin;
		int end;
		int weight;
		cin >> begin >> end >> weight;
		grap[begin][end] = grap[end][begin] = weight;
	}
	plm(num);
	return 0;
}*/

2.插入排序

#include<iostream>
#include<vector>
using namespace std;
void insert(vector<int>& s, int limit)
{
	for (int i = 0; i < limit; i++)
	{
		int end = i - 1;
		int tmp = s[i];
		while (end >= 0)
		{
			if (s[end] < tmp)
			{
				s[end + 1] = s[end];
				end--;
			}
			else
			{
				break;
			}
		}
		s[end + 1] = tmp;
	}
}
int main()
{
	vector<int>s;
	int count = 0;
	while (1)
	{
		int t;
		cin >> t;
		if (t == 0)
		{
			break;
		}
		count++;
		s.push_back(t);
	}
	insert(s, count);
	for (int i = 0; i < count; i++)
	{
		cout << s[i] << ' ';
	}
}

3.循环队列实现约瑟夫环

#include<iostream>
using namespace std;
class Queue {
private:
	int mSize;
	int front;
	int rear;
	int* queue;

public:
	Queue(int size) {
		mSize = size + 1;
		queue = new int[mSize];
		front = rear = 0;
	}
	bool enQueue(const int item) {
		if (((rear + 1) % mSize) == front)
			return false;
		queue[rear] = item;
		rear = (rear + 1) % mSize;
		return true;
	}

	bool deQueue(int& item) {
		if (front == rear)
			return false;
		item = queue[front];
		front = (front + 1) % mSize;
		return true;
	}
	bool getFront(int& item) {
		if (front == rear)
			return false;
		item = queue[front];
		return true;
	}

};
void josephus(int n, int s, int m) {

	Queue* q = new Queue(n);

	int counter = 1;

	int item = 0;
	for (int i = 0; i < n; i++) {
		q->enQueue(i + 1);
	}
	while (counter < s) {
		q->deQueue(item);
		q->enQueue(item);
		counter++;
	}

	counter = 1;

	while (1) {

		while (counter < m) {
			q->deQueue(item);
			q->enQueue(item);
			counter++;
		}

		q->deQueue(item);

		
		cout << item << " ";

	
		if (!q->getFront(item))
			break;

		counter = 1;
	}

}
int main() {
	int n, s, m;
	std::cin >> n >> s >> m;
	
	josephus(n, s, m);
	return 0;
}