《数据结构c语言》重言式判定参考了别人的代码Word文件下载.docx

《数据结构c语言》重言式判定参考了别人的代码Word文件下载.docx

《《数据结构c语言》重言式判定参考了别人的代码Word文件下载.docx》由会员分享，可在线阅读，更多相关《《数据结构c语言》重言式判定参考了别人的代码Word文件下载.docx（7页珍藏版）》请在冰豆网上搜索。

（2）可设表达式中逻辑变量数不超过20。

真值的产生可以通过在一维数组上维

护一个“软计数器”实现，用递归算法实现更简单。

[cpp]viewplaincopyprint?

1.#include<

iostream>

2.usingnamespacestd;

3.structArr

4.{

5.charletter;

6.intweight;

7.};

8.classCys

9.{

10.public:

11.Cys（）;

12.voidGetTautology（）;

//输入表达式

13.int_CreateT（int,int）;

//虚拟创建二叉树

14.intFindMin（int,int）;

//找到weight最小的

15.intcount（）;

//计算可满足式的值

16.void_recursion（Arr*_arr,inti）;

//递归，穷举

17.voidrecursion（）;

//使用接口函数18.voidPrint（）;

//输出结果19.~Cys（）;

//析构释放空间

20.private:

21.intnum;

22.Arr*array;

23.Arr_arr[20];

//存放字母

24.int_arrNum;

25.inttrueforever;

26.intfalseforever;

27.};

28.

29.Cys:

:

Cys（）

30.{

31.trueforever=0;

32.falseforever=0;

33.array=newArr[20];

34.for（inti=0;

i<

20;

i++）{35.array[i].weight-1;

36.array[i].letter='

0'

;

37.}

38._arrNum=0;

39.num=0;

40.}

41.voidCys:

GetTautology（）

42.{

43.inthas[27]={0};

44.intweight=0;

45.charch;

46.cout<

<

"

请输入一个逻辑表达式,以#结束"

endl;

47.while（cin>

>

ch&

&

ch!

='

#'

）

48.{

49.

50.

51.if（ch=='

'

52.continue;

53.

54.switch（ch）

55.{

56.case'

（'

57.weight+=4;

58.break;

59.case'

）'

60.weight-=4;

61.break;

62.case'

'

63.array[num].letter=ch;

64.array[num++].weight=weight+2;

65.break;

66.case'

|'

67.array[num].letter=ch;

68.array[num++].weight=weight+1;

69.break;

70.case'

~'

71.array[num].letter=ch;

72.array[num++].weight=weight+3;

73.break;

74.default:

75.array[num].letter=ch;

76.if（!

has[array[num].letter-'

A'

]）{

77._arr[_arrNum++].letter=array[num].letter;

78.has[array[num].letter-'

]=1;

79.}80.array[num++].weight=0;

81.break;

82.}

83.

84.}

85.}

86.intCys:

FindMin（intlow,inthigh）

87.{

88.intmin=low;

89.while（!

array[min].weight）

90.min++;

91.

92.if（min<

high）{

93.for（inti=min;

high+1;

i++）

94.if（array[i].weight&

array[i].weight<

95.min=i;

96.returnmin;

97.}

98.else

99.return0;

100.

101.}

102.

103.intCys:

_CreateT（intlow,inthigh）

104.{

105.intMin=0;

106.//cout<

create"

107.if（low>

high）

108.return1;

109.elseif（low==high）

110.{

111.//cout<

letter"

array[low].letter<

112.inti;

113.for（i=0;

_arr[i].letter!

=array[low].letter;

i++）;

//从array[]中寻找与_arr[]中相同的字母

114.return_arr[i].weight;

//返回它的weight（1或0）

115.}

116.else{

117.Min=FindMin（low,high）;

118.//cout<

array[Min].letter:

"

array[Min].letter;

119.switch（array[Min].letter）{

120.case'

return（_CreateT（low,Min-1）&

_CreateT（Min+1,high））;

121.break;

122.case'

return（_CreateT（low,Min-1）||_CreateT（Min+1,high））;

123.break;

124.case'

return（!

_CreateT（Min+1,high））;

125.break;

126.}

127.}

128.}

129.intCys:

count（）//计算可满足式的值

130.{

131.inti=0;

132.cout<

请给字母赋值"

133.while（_arrNum--）{134.cout<

_arr[i].letter;

135.cin>

_arr[i++].weight;

136.}

137.if（_CreateT（0,num-1））

138.trueforever++;

139.else

140.falseforever++;

141.

142.}

143.

144.voidCys:

_recursion（Arr_arr[],inti）//递归调用

145.{

146.if（i<

_arrNum）{147._arr[i].weight=0;

148.//cout<

0"

149._recursion（_arr,i+1）;

150._arr[i].weight=1;

151.//cout<

1"

152._recursion（_arr,i+1）;

153.}

154.else

155.if（!

trueforever||!

falseforever）

156.{

157.switch（_CreateT（0,num-1））

158.{

159.case1:

160.//cout<

trueforever++;

161.trueforever++;

162.break;

163.case0:

164.//cout<

falseforever++;

165.falseforever++;

166.break;

167.default:

168.break;

169.}

170.}

171.}

172.

173.voidCys:

Print（）

174.{if（trueforever&

falseforever）//如果真假同时存在就判断它为satisfactible.

175.cout<

satisfactible."

176.elseif（!

trueforever）177.cout<

falseforever."

178.else

179.cout<

trueforever."

180.}

181.

182.voidCys:

recursion（）

183.{

184._recursion（_arr,0）;

185.}

186.

187.Cys:

~Cys（）

188.{

189.delete[]array;

190.}

191.

192.intmain（）

193.{

194.cout<

-------------------重言式判别--------------------"

195.Cyscys;

196.charc;

197.cys.GetTautology（）;

198.cout<

计算机穷举请按'

t'

or用户赋值请按'

n'

199.ci