深入理解数据结构——堆栈应用（背包体积）

#include <iostream>
#include <string>

using namespace std;



typedef char Etype;

/************************背包问题*************************/
#define PRODUCTS EType

struct PRODUCTS {
	char name[8];
	int weight;
	int number;
	char place[20];
};



struct LinearList {
	EType* element;
	int length;
	int maxsize;
};

struct SType {
	int index;
};

struct Stack {
	SType* element;
	int top;
	int maxsize;
};



//创建空堆栈
void CreateStack(Stack& S, int MaxStackSize) {
	S.maxsize = MaxStackSize;
	S.element = new SType[S.maxsize];//创建数组元素
	S.top = -1;//top指向的是数据空间的第一个元素，本身的值代表数据元素的下表，空表设top为-1
}

//判断堆栈是否为空
bool IsEmpty(Stack& S) {
	if (S.top == -1) return true;
	else return false;
}

//判断堆栈是否满了
bool IsFull(Stack& S) {
	if (S.top >= S.maxsize - 1) return true;
	else return false;
}

//返回栈顶元素的值
bool GetTop(Stack& S, SType& result) {
	if (IsEmpty(S)) return false;
	result = S.element[S.top];
	return true;
}

//出栈操作，将栈顶元素取出，并且将top指向下一个元素的位置
bool Pop(Stack& S, SType& result) {
	if (IsEmpty(S)) return false;
	result = S.element[S.top];
	S.top--;//栈顶指向下一个元素地址
	return true;
}

//进栈操作，将top+1，输入元素存入新的栈顶
bool Push(Stack& S, SType& x) {//传入的是x的地址
	if (IsEmpty(S)) return false;
	S.top++;
	S.element[S.top] = x;
	return true;
}



void TraverseStack(Stack& S, LinearList& L) {
	//逐个输出堆栈的数据元素
	int k;
	for (int i = S.top; i > -1; i++) {
		cout << "Record-" << i + 1 << ":";
		k = S.element[i].index;
		cout << L.element[k].number << " " << L.element[k].weight << endl;
	}
	cout << "该方案有：" << S.top + 1 << "件货物" << endl << endl;

}
void Knapsack(LinearList& L, int T) {
	//T为背包体积，n个物品的体积存在w[]中，求解装满背包的所有解
	int k;
	int MaxStackSize = 50;
	SType x;
	Stack S;

	CreateStack(S, MaxStackSize);

	do {
		while (T > 0 && k < L.length) {
			if (T - L.element[k].weight >= 0) {//按顺序选取物品，如果装入背包不满，则将物体压入堆栈
				x.index = k;
				Push(S, x);//把满足条件的背包压入S
				T = T - L.element[k].weight;//背包体积减去这个物体体积
			}
			k++;//继续选择下一个物体
		}//堆栈S中是已装入背包的物体
		if (T == 0)  TraverseStack(S, L);//如果经过一轮循环，，就输出栈中所有的物品编号
		Pop(S, x);//推出栈顶数据
		k = x.index;//从退出的编号的下一个编号物品开始尝试，直到堆栈为空，达到最大编号为止
		T = T + L.element[k].weight;
		k++;
			
	} while (!IsEmpty(S));


}