帐前卒专栏

code, software architect, articles and novels.
代码,软件架构,博客和小说

本来这篇文章想自己写写的。

可是怕被某人骂语言白痴…

当然这不是主要原因…
所以索性决定转帖别人的。

反正被骂也不是我写的…嘿嘿…
不过很可笑的是,虽然是儿童读物,有人却必须要写成论文。以大人的眼光看待整个问题。

想想这的确是与原著相悖,假若让一个孩子来写。貌似更加有趣。

如果真的是那样…那还能批准毕业吗?
…毕业论文…

还是不妄加评论…
转自: http://blog.sina.com.cn/s/blog_49f37f7301000c9x.html

** 浅析《小王子》的象征意蕴 ** (2007-07-29 11:24:31)

标签: 小王子

[ 圣埃克苏佩里 ](http://uni.sina.com.cn/c.php?t=blog&k=ʥ�������%E
5%C0%EF&ts=bpost&stype=tag) [ 毕业论文 ](http://uni.sina.com.cn/c.php?t=blog&k=�
%CF%D2%B5%C2%DB%CE%C4&ts=bpost&stype=tag)

分类: 有的没的

摘 要

法国著名作家安东尼·德·圣-埃克苏佩里的《小王子》一书自问世以来,深受儿童甚至成人的喜爱。这部作品之所以具有如此魅力,主要是因为作者充分运用和体
现了象征主义写作方法,并通过童话这种文学体裁及二元对立的写作方式体现了各种象征,从而使整部作品具有象征性。《小王子》不是一部简单的童话,而是一部
融入了作者生命哲学体验的哲理童话,具有深广的哲学内涵和美学意义。本文通过对作者圣-埃克苏佩里的生活经历及当时时代背景的剖析,从整体的象征、意象的
象征及具体象征意象之间的对应关系切入,浅析《小王子》中蕴涵的深刻意蕴。

关键词:《小王子》 象征  象征意蕴

Abstract

The famous French writer Antoine de Saint-Exupéry 's _ The Little _ _ Prince _
has been loved by children and even adults,since it was presented to the
public.The author has made full use of the Symbolist Writing, and by the
literary genre fairy tale and the writing style reflects the various
symbols,so the symbolic pass through the whole work.It’s the most important
reason that this work is so charming. _ The Little Prince _ is not a simple
fairy tale, but a philosophical novel because the author has devoted his
philosophy of life experience to it so that there is full of deep
philosophical connotations and aesthetic significance in it. This article trys
to seek the symbolic meaning of this work from three factors:the overall
symbols,the imageries’ symbols and the relationship between the comcrete
symbolic images,based on analyze the author Saint-Exupéry’s life experience
and the background of the times.

** Key words ** : _ The Little Prince _ Symbol  Symbolic meaning

在法国文学史上,安东尼·德·圣-埃克苏佩里(Antoine de Saint-Exupéry
1900-1944)是一位特殊的作家,他的人生与他最著名的作品《小王子》(Le Petit
Prince)一样,充满了传奇色彩。圣-埃克苏佩里1900年6月29日出生于法国里昂的一个没落贵族家庭,1921-1923年在法国空军服
役,1927年春加入飞行员的行列,与著名飞行员梅尔莫兹、吉约梅、艾基安等人开辟了从法国南部的图卢兹到摩洛哥的卡萨布兰卡以及塞内加尔首府达喀尔的邮
政航线。1939年德国法西斯入侵法国,他不顾自己曾多次负伤,毅然参加了抗德战争。1940年法国战败,他所在的部队损失惨重。他随后复员,只身流亡美
国。1943年,首版《小王子》在纽约出版之际,已经43岁的圣-埃克苏佩里经强烈要求再次入伍,回到了法国在北非的抗战基地阿尔及尔。1944年7月
31日上午,他出航执行第九次飞行任务,竟然神秘失踪,成为法国文学史上的传奇。

圣-埃克苏佩里一生热爱冒险和自由。除了飞行,写作是他另一终生所爱。他短暂的一生中创作了小说《南方邮
件》(1928)、《夜航》(1931)、散文《人的大地》(1939,英译名《风沙星辰》)、小说《空军飞行员》(1942,英译名《飞向阿拉斯》)、
《给一个人质的信》(1943)、童话《小王子》(1943),以及他死后才出版的《城堡》等作品。其中《夜航》获费米娜文学奖,《人的大地》获法兰西学 院文学大奖
。然而真正让圣-埃克苏佩里享誉世界的,则是《小王子》这部童话。

《小王子》(Le Petit
Prince)自1943年在纽约问世以来,多次再版,经久不衰。它不但被誉为有史以来阅读率仅次于《圣经》的书籍,而且还被翻译成100多种文字,成为
译本最多的法国文学作品(本文所采用的是马振骋先生的译本)。《小王子》还多次被改编成电影、电视剧、木偶剧、话剧、音乐剧、卡通片等,风靡全球。构成这
部作品的成功因素很多,作者对于象征主义手法的成功运用便是其中之一。法国作家安德烈·莫洛瓦对这部作品有非常中肯的评价:“《小王子》在其富有诗意的淡
淡哀愁中也蕴涵着一整套哲学思想。” ① “这本给成人看的儿童书处处包含着象征意义,这些象征看上去既明确又隐晦,因此也就格外的美。” ② 圣-埃克苏佩
里将自己的作品置于现实生活中,通过象征这一艺术手段,使自己对人生的思考得以升华,使之更具哲理性。整部作品充满了诗意、忧伤与孤独,在浅显的文字背后,隐藏着对人
类生存体验和生存意义的深刻反思。

一、 整体的象征

象征模式的常见类型之一是整体的象征。在这些象征中,象征涵义并非来自特定的意象,而是来自形象体系的整体。

从整体来看,《小王子》笼罩着一种孤独的氛围。小王子生活在B612号小行星上,而这个星球上只有三座到他膝盖的火山,小得刚刚容得下他。他孤独地生活
着,直到有一天一朵玫瑰花出现在他的星球上。但是不久小王子就因为和玫瑰发生争执而负气出走,独自一人在星际间旅行。小王子在来到地球之前,游历的星球都
非常小。如第一颗星球的表面被国王豪华的鼬皮长袍遮得不留一点空隙,第五颗星球的面积是群星中最小的一个,仅够容纳一盏路灯和一个点灯人。这些星球上的人
之间没有沟通和联系,他们所在的星球也各自有着不同的运行轨道。这些星球上无法同时容下两个人,这象征着人类个体精神的孤独。离开自己的星球时,小王子还
不明白生命的意义。他在旅行时遇到的生命几乎都无法与他沟通,因而他不得不一再失望地离开,继续到其它星球探寻。直到他来到地球,通过与充满智慧的狐狸的
交谈,他才明白了对自己驯养的东西要永远负责,要用心去看才看得清楚,本质的东西眼睛是看不见的。

《小王子》写于20世纪中期,正是二战期间。这一时期人们失去了原有的精神支柱,人的心灵被所谓的现代文明污染,原来人与自然、人与社会、人与人之间呈现
的和谐关系被破坏。人类文明越来越向与人对立的形态发展,人们寻求不到生命的意义,变得颓丧孤独。“人的孤独感,部分地是由于人需要与他人的关系以确定自
己的方位。” ③ 童话中的小王子是孤独的,他从自己星球的负气出走更像是一场自我放逐。这种作为个体精神的孤独,也许正是20世纪人们精神孤独的体现。或者可以
说,是人对自我的反思与批判。

二、意象的象征

意象的象征是指以某种意象集中地象征某种哲理、观念或唤起某种情感、意绪的象征。“象征主义要强调整部作品的象征性,不是仅仅体现在作品的部分环节中,而是体现在作品
的最主要部分和各个环节之中。” ④ 从具体意象象征来看,
《小王子》蕴涵的意义也极为丰富。按照象征的客观对应物的范围划分,具体的意象象征大致有以下几类:

(一)  以人物为意象的象征

《小王子》中的人物可分为儿童和成人,儿童的代表显然是小王子,而成人的代表则是各个星球上稀奇古怪的人物以及飞行员“我”。

1.小王子:童年原型的象征

小王子是全书最有情致的人物,在他的身上,呈现出的是生命初始的状态。他的价值观与成人世界的世俗功利格格不入,对“正经事”有和大人们完全不同的概念。
他以爱与诗意为价值中心,对那些“正经人”有很尖锐的嘲讽,“我到过一个星球,那里有一位红脸先生。他从来没有嗅过一朵花。从来没有望过一颗星星。从来没
有爱过一个人。除了加法以外,从来没有做过别的事。整天像你一样反复说:‘我是个正经人!我是个正经人!’神气活现,自命不凡。但他不是个人,是个蘑 菇!” ⑤
作品以很大篇幅描写了小王子在星际间的游历,进一步展示了成人们的滑稽和荒唐。用小王子的话说,大人们真是怪得太没治了。以外星的小王子为视角,成人世界的荒诞被夸张
和变形,产生了陌生化的效果。

小王子的人生观可以说体现了圣-埃克苏佩里本人的人生观。在圣-
埃克苏佩里看来,小王子的行为与思想比成人世界的庸俗人物高明得多。小王子这一天真无邪的形象体现出生命原初时期的质朴,是作者人生理想的象征。

而从小王子的生命历程来看,大致模式如下:

离家远游(先后到七个星球游历)——寻求答案(在前六个星球未能找到人生的真谛,继续前行)——找到答案(来到地球后,终于找到了答案)——结局(小王子之死)。

上述模式与普洛普在《童话形态学》中提出的追寻模式很相似,即英雄远走——寻求奇迹——经历磨难——结局。但与之不同的是,小王子执着追寻的不是什么奇
迹,而是道德与哲学的秘密——人生的真谛。小王子并未经历普通意义上的磨难,而是遇到了各种有心理缺陷的人,因此感到失望,不得不到其它星球探寻。作者将
小王子塑造得忧伤而又脆弱,因为他懂得,美好单纯的思想在这个成人的世界太难生存了。结局部分一反童话中英雄找到幸福的大团圆结局的常规,而是在凄婉的气
氛中以小王子之死结束一切。从小王子游历的过程来看,是离家——怀念——回家的模式,小王子的生命历程实质上意味着回归。从结束游历的方式来看,小王子之
死是以再生的方式结束游历,回到自己的星球,意味着更高层次的回归。可见,小王子是童年原型的象征,经过“死亡——再生”的童年不再是过去意义上的实际的
童年,而是经历了岁月和心灵塑造的理想层面上的童年。童年原型,实质上是人类在精神上的回归。

2.前六个星球的居民:成人世界的众生相

小王子造访的前六个星球上,分别生活着国王、爱虚荣的人、酒鬼、商人、点灯人、地理学家。这些人物都是现实社会中成人世界的典型写照,而且至今仍具有普遍意义。

国王显然是政治权力的象征。他认为所有的人都只不过是他的子民,他统治着一切。但从更深的层次来看,国王更多地象征着理性权威。他不允许别人违抗自己的命
令,是个专制的君王。但是他下达的都是一些合理的命令。他对小王子说,权威首先要建立在理性的基础上。在二战之前,欧洲人信仰理性,并认为其足以解决一切
问题。可是战争摧毁了这一信仰,并使人们对理性失望。国王的权威无法控制小王子打呵欠还是不打,也无法让太阳提前下山,只能宣判星球上唯一的一只耗子死
刑。而为了使这种权威能够继续,只好不断地赦免它。国王象征着理性权威的虚伪与无能。这种对理性的失望反映了二战给人们带来的精神创伤。

爱虚荣的人为了在别人为他鼓掌的时候向人敬礼,戴了一顶奇怪的帽子。可是他那里平时根本没什么人去。他认为其他人都是崇拜者,听见的只是一片赞扬声。爱虚
荣的人希望小王子承认他是星球上长相最俊、衣着最美、家财最富、头脑最灵的人,但是他的星球上本来就只有他一个人。小王子觉得奇怪,即使自己崇拜他,在他
又有什么可高兴的呢?这正讽刺了虚荣的可笑。

商人忙得根本没时间抬头,他住在自己的星球五十四年,只有三回中断了计算星星的数目。他不停地做着加法,想通过这种方式占有星星。但是如果没有小王子的提
醒,他几乎已经忘记了要占有的是星星,而把它们叫做让闲人想入非非的金色小东西。他占有星星后所能做的也只是把它们的数目记在一张纸上,然后把这张纸锁在
抽屉里。商人占有只是为了占有,他在遇到小王子之前甚至没想过占有星星后能对星星做些什么,只是一遍又一遍地数星星。商人这一形象象征了人性的贪婪。

另外,为了忘记自己的难为情喝酒、又为自己喝酒难为情的酒鬼象征着荒唐;终日忙碌、循规蹈矩,却毫无目的的点灯人象征着盲目;脱离实际、自命清高的地理学
家象征着教条。大人们是如此功利、虚荣、盲目、荒唐,缺乏想象力和浪漫情怀。这些星球上只有点灯人做事不是为了自己,但他对命令的盲目服从令人难以理解和 接受。

成人世界通过小王子的视角被陌生化,作者以极其夸张的手法写出了成人们扭曲的生命形态。当夸张失常的描写被作为有意为之的艺术手段使用时,读者便能较为自
由地摆脱实有生活的局限,从人生哲理的高度去认识作品。这些病态的生命形态实际上是现代文明社会的产物,作者以此抨击了现实生活中的某种价值观。

3.飞行员:圣-埃克苏佩里的写照

飞行员属于成人世界,拥有成人的思维,但他仍然记得自己曾是个孩子。飞行员懂得生活,不在乎“数目字”,醉心于飞行而抛开功利,因此在大人们中间感到非常
孤单,找不到一个说话投机的人。圣-埃克苏佩里和书中的飞行员一样,对成人世界常常感到无所适从。1935年12月,圣-埃克苏佩里和一名机械师试图创造
巴黎——西贡的直飞纪录,在离开罗二百公里的沙漠上空迷失了方向,降落到了沙漠中,在死亡线上挣扎了三天。正是在面临死亡威胁的孤独处境下,圣-埃克苏佩
里领悟到了生活的真正价值。这段经历促使他开始重新思考人生,也使他对沙漠产生了特殊的感情。这次沙漠历险结束后,他开始喜欢在餐馆、咖啡酒吧的提花餐巾
纸上,任意涂抹一个“孤独的小人儿”。飞行员的身上也有圣-埃克苏佩里的影子,他们的职业、经历,以及对生活的感悟都有相同之处。

(二)  以动植物为意象的象征

作者在书中描绘了玫瑰花、猴面包树、蛇、狐狸等形象,与其它童话中的动植物形象相比,这些形象具有更深广的内涵和哲学意义,隐喻的对象相对较为复杂,这正体现了象征的
多义性特点。正是这种不确定性,才使文本增添了内涵与神秘的美感。

玫瑰花首先象征了爱情。它光彩夺目,而又娇憨、任性、狡黠。它向小王子耍的那些小把戏,俨然 是初涉爱河的少女的种种表现。如果从圣-
埃克苏佩里的生活经历来看,玫瑰似乎也象征着他的妻子康素爱罗·森琴。他曾警告过康素爱罗:“你要是老那么疯来疯 去,你将来会成一朵只剩茎杆而无花瓣的玫瑰了。”
⑥ 书中的玫瑰让小王子苦恼、伤心,康素爱罗也同样让圣-埃克苏佩里无可奈何。我们可以猜想,在某种意义上玫瑰象征了作者的妻子。

猴面包树刚发芽时与玫瑰十分相似,但是如果任它繁殖,它的枝叶就会布满整个星球,树根甚至会把星球撑裂。猴面包树象征了一种潜伏在身边的危险,如果任其发
展,后果将是毁灭性的。这种危险的主体是多方面的,也许是当时猖獗的法西斯势力,也许是现代文明中被扭曲了的价值观,也许是人自身的恶习。为了加强人们的
紧迫感,不爱说教的飞行员“我”向孩子们发出警告,要他们小心猴面包树,并将它画得气势恢弘。从中可以看出作者对现实社会的危机感以及富有的责任感。

蛇是小王子来到地球后遇到的第一个生物。它神秘诡异,拥有强大的力量,并且能够猜破一切谜底。蛇象征着恐怖而又充满诱惑的死亡。它告诉小王子,跟人在一起
也是孤独的,“你那么娇弱,来到这花岗岩的地球上,叫我动了恻隐之心。有一天你实在想念你的星球,我可以帮助你。我可以……” ⑦
当小王子渴望回到他的玫瑰身边时,蛇用自己的毒液帮助了他,使小王子的躯壳与灵魂分离,从而使小王子回到了他遥远的星球。

狐狸是以循循善诱的智者形象出现的。它提出了“驯养”这一概念,并解释说“驯养”就是“建立联系”。在建立驯养关系之前,小王子对狐狸来说只不过是跟成千
上万个男孩子毫无两样的一个男孩子,狐狸对小王子来说也跟成千上万头狐狸毫无两样,二者谁也不需要谁。但是小王子驯养了狐狸,于是他们开始需要彼此。狐狸
感悟到了生活的本质,用简单直白的话语对小王子道破了爱与责任的真谛。狐狸是象征智慧的生物,通过与狐狸的交谈,小王子明白了他的玫瑰之所以重要,是因为
他为他的玫瑰花费了时间,他必须对他的玫瑰花负责,即使要付出一些眼泪。在狐狸身上似乎也有圣-埃克苏佩里的影子。在圣-埃克苏佩里从前的自传性作品中,
他的价值观已经有所体现,在《小王子》中则借狐狸之口,进一步表达了“人的幸福不在自由之中,而在责任的承担之中” ⑧ 这一对爱与责任的认识。

(三)  其它意象的象征

带着失望与好奇,小王子最终来到了“遐迩闻名”的地球。书中介绍道:“地球可是个不同凡响的星球!地球上有一百一十一位国王(当然没有忘记算上黑人国王),七千位地理
学家,九十万个商人,七百五十万个酒鬼,三亿一千一百万个爱虚荣的人,也就是说差不多二十亿个大人。” ⑨ 结
合上文的描写,这样的介绍等于是说地球比前六个星球糟糕得多。小王子在遇到飞行员之前,见过另外两个地球人。一个是扳道工,小王子在与他的对话中得知,那
些来去匆匆的旅客自己也不知道他们在寻找什么,他们对自己呆的地方永远不满意,只有孩子把鼻子贴在玻璃窗上张望。成人们就这样盲目地生活,找不到生命的意
义。另一个是商贩,贩卖改良的解渴药。只要每周吞服一丸这种解渴药,就不需要再喝水。商贩的广告词说,服了这种解渴药可以节省大量时间,专家做过统计,一
星期可节省五十三分钟。这种发明是向着高效节时的方向努力的,可是小王子问,省下的这五十三分钟干什么用呢?商贩回答他,爱干什么就干什么。小王子自言自
语地说,要是他省下五十三分钟,他就悠闲自得地朝一口水井走去。有时科技的发明是与人诗意的栖居背道而驰的,现代文明使人性遭到污染,人越来越失去了人的 本质。

在这种情况下,现实生活中要实现最本质的人生观是非常艰难的。只有尚未被现代文明所侵袭,脱离尘世污染的沙漠,才是小王子最适合出现的地方。沙漠对圣-埃
克苏佩里来说,意义非凡。沙漠人迹罕至,地域广阔,人在这里更容易感到孤独。但小王子在这里找到了爱的真谛和生活的本质,因为沙漠是一个纯净的空间,适合
思考爱与责任。这片净土没有欲望、没有冲突、没有矛盾,只有在这里,飞行员“我”才能忘却俗世的纷扰,去体会人的本真。在沙漠中,爱的真谛和生活的本质显
得更为纯粹。正是在这里,小王子结束了自己的旅程,让纯粹的心灵和圣洁的净土完成了融合。

小王子攀上一座高山,渴望一眼就能看到整个星球和所有的人。但当他说出:“做我的朋友吧,我是一个人” ⑩ 时,
回答的只有冰冷的回声。书中的回声体现了人类想象力的缺乏,以及人与人之间关系的冷漠,象征着心灵的孤寂。水可以给飞行员解渴,是他生命的源泉。但对小王
子来说,水对心也是有好处的,水只是他的精神食粮。水的洗礼可以使人达到思想的净化,而井是水的承载体,因为水井的存在,长途跋涉的人们有了向前迈进的力
量。沙漠中的水井是理想的象征,是生命与精神的源泉。为了防止绵羊吃掉小王子的玫瑰,飞行员给绵羊画了一只嘴套。可是当小王子离开后,飞行员才发现自己忘
了给那只嘴套配一根皮带。于是羊究竟有没有吃花,就成了永远难解的谜题。嘴套在这里,成了人因一时疏忽而造成未知后果的见证。

三、具体意象间的对应关系

《小王子》中的每个具体意象都不是孤立的,例如童年的“我”与大人们、小王子与玫瑰、小王子与蛇、小王子与狐狸、小王子与各个星球上稀奇古怪的人、以及小
王子与飞行员“我”之间,都存在着相互对应的关系。作者通过这些对应关系展示了自己的价值观,营造了文本的象征氛围,解释世界和人生,展示自己的人生观和
审美定式。如“我”童年时和大人们的矛盾,小王子与各个星球上的人物的关系,就象征了儿童与成人世界的对立。大人们把
“我”画的画误当成一顶帽子,他们不但不能理解“我”画的是一条正在消化大象的蟒蛇,反而要“我”把心思放到地理、历史、算术和语法上去。小王子在成人的
世界提出的问题得不到满意的答案,探求真理的执着遭到了荒诞世界的抵触,为此他感到忧郁不安,甚至悲伤地哭泣。儿童没有大人那么多的清规戒律,看待事物的
眼光是最简单质朴的。成人则充满了对金钱和权力的欲望,讲求实际和功利。书中举例说:

大人喜欢数字。你跟他们谈起一位新朋友,他们决不会问本质的东
西。他们不会对你说:“他的声音怎么样?他爱好什么游戏?他搜不搜集蝴蝶?”而是问:“他岁数多大?几个兄弟?体重多少?他父亲挣多少钱?”这样问过之
后。他们认为对他有所了解。如果你对大人说:“我看到一幢漂亮的房子,红砖砌的,窗前有天竺葵,屋顶上有鸽子……”他们想象不出这幢房子是什么样的。要是
说:“我看到一幢房子,价值十万法郎,”他们会惊呼:“多漂亮呀!” 11

这个例子表明,儿童的精神世界和成人的精神世界无法相通,是因为成人判断事物价值的标准与儿童完全不同。成人以金钱和实用为价值中心,他们在一座花园里培
植了五千朵玫瑰,却找不到自己寻求的东西,而那些生活中最重要的东西可能就包含在一朵玫瑰花里、少量的水中。正如小王子说的:“他们蜷缩在快车车厢里,但
是不知道寻求什么。于是焦躁不安,团团打转……” 12

在种种对应关系中,小王子和飞行员的关系最为特殊。飞行员仍然保持着一些童稚和想象力,但他“不幸得很,不会透过箱子看到里面的绵羊。” 13
他认为自己“也许有点像大人了,我一定是老了。” 14 小
王子与飞行员之间难以沟通,飞行员认为把飞机发动机上的螺栓拧下来是件重要的事,小王子则认为羊与花的战争比修飞机要重要得多。小王子认为飞行员说话像个
大人,就是说不清楚,就是不会区分;而飞行员则不知道怎样才能打动、接近小王子。作者通过描写他们对许多具体事物的不同看法及各自价值观的冲突,展示了两
者的对立关系。这种难以沟通,正是儿童与大人们的内心世界之间格格不入的象征。飞行员已经属于成人世界,因此他需要通过小王子才能发现生活的本质及深层含
义。但他尚未忘记,自己曾是个孩子。正是这一点,才使小王子和飞行员之间的对立被打破,让两个人有沟通的可能。作者对那些被成人世界同化了的大人表示了同
情,似乎也暗示了只要拥有童心,儿童与成人世界的鸿沟并不是不可逾越的。

正如法国文艺批评家阿·爱华德所指出的:“象征是一种艺术形式,它既满足我们描写现实的愿望,同时也满足我们超越现实界限的愿望。它给我们具体的东西,同时也给我们抽
象的东西。” 15 圣
-埃克苏佩里坚持喻象创造,从而实现了象征功能。他“视现实世界为可鄙的、不真实的,力图超越现实而进入超验的心灵世界和内在生命的实体。只有大自然和生
命的某些面貌以及人类的某些作品所赋予的激情才让他们感到真切的存在,作者能从中汲取珍贵的感觉、无限丰富的思想以及思想、情感、严谨和幻想的奇妙组合。 ” 16
直接取材于现实生活中的具体原型,并对其进行加工处理,借助象征这一艺术形式,使用暗示的手法在《小王子》一书中融入了他全部的人生哲学。

综上所述,《小王子》的象征意义和象征功能是以儿童的视角,通过童话这一文学体裁完成的。作者承袭了希腊、罗马文化传统中的叙事模式,并对其加以发展,以童话为载体,
展示了人生经验的本质和意义,“又展示了一个延绵不断的经验流中的人生本质” 17
。《小王子》中的象征具有全方位、多层次的特点,将“人生经验的本质和意义传示给他人” 18 。
全书中的象征既相互独立,又相互联系。作者使用二项对立关系为其象征营造了有利的氛围,解释爱与责任对人生的意义,传递了具有深层含义的象征意义,展示了
作者的人生观、价值观。书中的诸多象征直到今天仍有其现实意义,这也正是圣-埃克苏佩里“不喜欢人家不当一回事地读我这本书” 19
的原因。圣-埃克苏佩里作为一个有着强烈责任感的、大写的人,“他笔下的每一个字都发出真实的鸣响。” 20

注  释

①②20  安德烈·莫洛瓦. 安东尼·德·圣-埃克苏佩利.袁树仁,译.漓江:漓江出版社,1987:83、83、67.

③  罗洛·梅.罗洛·梅文集.冯川、陈刚,译.北京:中国言实出版社,1996:465.

④16  凌学东.浅析《小王子》中的象征主义.零陵学院学报,2005,(1):93,94.

⑤⑦⑨⑩11 12 13 14 19  圣埃克苏佩里.人的大地: 圣埃克苏佩里小说选.马振骋,译.
北京:外国文学出版社,1999:344-345、364、362、366、338、374、339、339、339.

⑥⑧  李清安编. 圣埃克苏佩里研究:编者选序.北京:中国社会科学出版社,1992:482、8.

15  普列汉诺夫. 普列汉诺夫著作选集.姜其煌,译.北京:文化艺术出版社,1987:461.

17 18  普安迪.中国叙事学. 陈珏,译.北京:北京大学出版社,1996:7、6.

参考文献

[1]  安德烈·莫洛瓦.从普鲁斯特到萨特.袁树仁,译.漓江:漓江出版社,1987:67-83.

[2]  圣埃克苏佩里.人的大地:圣埃克苏佩里小说选.马振骋,译.北京:外国文学出版社,1999:331-385.

[3]  罗洛·梅.罗洛·梅文集.冯川、陈刚,译.北京:中国言实出版社,1996.

[5]  凌学东.浅析《小王子》中的象征主义.零陵学院学报,2005,26(1):93-95.

[6]  李清安.圣爱克苏贝里研究.北京:中国社会科学出版社,1992.

[7]  胡玉龙.《小王子》的象征意义.外国文学评论,1998,(1):34-39.

[8]  石海燕.儿童精神家园的回归与守望:试论《小王子》中“儿童本位”的儿童观.山西大学师范学院学报,2002,(2):57-59.

[9]  廖莎莎.一部留有时代烙印的畅销书:浅析法国作家圣·埃克苏佩利作品《小王子》的象征意义.新疆石油教育学院学报,2005,(1):137-145.

[10]  姜海涛.在星群中找到的真理:试论《小王子》中的意蕴.伊犁教育学院学报,2004,(1):59-62.

[11]  保罗·韦伯斯特.小王子的爱与死:圣埃克苏佩里传.黄喻麟,译.8版.上海:上海人民出版社,2003.

[12]  龚苏萝·德·圣·埃克苏佩里.玫瑰的回忆.黄荭,译.上海:上海译文出版社,1999.

[13]  Antoine de Saint-Exupery.The Little Prince. London: William Heinemann
Ltd, 1962.

[14]  Paul Webster.The Life and Death of The Little Prince.London:Macmillan
Press,1993.

源代码工程文件(vs2005) http://d.download.csdn.net/down/1018461/cctt_1

过去在网上找了段代码,发现写的代码要改些地方,而且也想顺便练习下自己的c++编码。

首先我要建立一个真正的树形结构。于是使用了自己过去的 GeneralTree.h

(当然这里还是改动些GeneralTree的代码例如增添了些函数,另外把有些私有函数变成了公有函数)。

训练文本格式如下:并命名为decision2.txt 并发在自己的工程目录下。当然你也可以改改相关源代码
概念  颜色 形状 轻重
苹果   红   球   一般
苹果   绿   球   一般
香蕉   黄   弯月  一般
草莓   红   球    轻
草莓   绿   球    轻
西瓜   绿   椭球  重
西瓜   绿   球    重
桔子   桔黄 椭球  轻

测试格式文本格式如下:命名为test.txt并放在工程目录下(试试改改源代码)

颜色 形状 轻重
红   球   一般
绿   球   一般
黄   弯月  一般

这里应该考虑各个类分开的。不过为了看起来方便,就合在一起了。
下面是具体代码:

/* created by chico chen * date 2009/02/02 * 如需转载注明出处 */ #include “stdafx.h”
#include #include #include #include
#include #include #include #include “D://Tools//not
Finished//TreeTest//TreeTest//GeneralTree.h” using namespace std; // this
class is for computing attribute entropy class AttribDiff { public: string
attribName; // 属性名 map<string,int> attribNum; //具体属性和个数对
map<string,map<string,int>> typeNumber; // 第一个string为具体属性名,第二个为类型, //
int是类型在具体属性中的个数. // 例如:是否可见 类型 形状 // 1 西瓜 圆 // 1 冬瓜 扁 // 0 橘子 圆 //
其中具体属性为圆,类型为西瓜等个数为形状为圆的类型为西瓜的个数 AttribDiff(string& attribName) {
this->attribName = attribName; } // in order to computer entropy of an
attribute double AttribDifferComputer(vector<vector> infos,int
i_attrib,int i_types, vector& visible) { double probability = 0; double
entropy = 0; double attribG = 0; map<string,int> temp; int tempNum = 0;
for(int i =0 ; i < infos.size(); i++) { if(visible[i] != 0 ) { tempNum =
attribNum[infos[i][i_attrib]]; attribNum[infos[i][i_attrib]] = tempNum; temp
= typeNumber[infos[i][i_attrib]]; tempNum = temp[infos[i][i_types]];
temp[infos[i][i_types]] = tempNum; typeNumber[infos[i][i_attrib]] = temp; }
} map<string,int>::iterator i_number; map<string,int>::iterator i_type;
for(i_number = attribNum.begin(); i_number != attribNum.end(); i_number
) {
probability = (*i_number).second/(double)infos.size(); cout
<<(*i_number).first <<“概率为:”<< probability<<endl; entropy = 0; for(i_type =
typeNumber[(*i_number).first].begin(); i_type !=
typeNumber[(*i_number).first].end(); i_type
) { entropy +=
ComputerEntropyHelp((*i_type).second/(double)(*i_number).second); } attribG +=
(-1)probability * entropy; } return attribG; } // compute the entropy double
ComputerEntropyHelp(double pi) { return pi
log(pi)/log((double)2); } }; //
this class is create a data struct for general tree node class NodeInfo {
public: // 颜色 // 红 // 蓝 string attribName; // the attribute name, such as 颜色
vector detailAttrib; // all of detail attributes under one of
attribute name, for example, 红 NodeInfo() { attribName = “”; } NodeInfo(string
& attribName) { this->attribName = attribName; } NodeInfo(NodeInfo & ni) {
this->attribName = ni.attribName; this->detailAttrib = ni.detailAttrib; } //
add detail attributes in NodeInfo void NodeDetailInfoAdd(string & detailA) {
if(!CheckIsHas(detailA)) { this->detailAttrib.push_back(detailA); } } // If
detail attribute is in the detailAttrib list, return true; // else return
false; bool CheckIsHas(string & name) { for(int i = 0; i <
detailAttrib.size(); i++) { if(strcmp(name.c_str(),detailAttrib[i].c_str())
==0) { // the same attribute return true; } } return false; } // this is print
control for printing NodeInfo static void Print(NodeInfo& info) { cout <<
info.attribName<< “(”; for(int i = 0; i < info.detailAttrib.size() ; i++) {
cout << info.detailAttrib[i]<<" "; } cout << “)/n”; } }; // this class is
decision tree class DT { protected: const string filename; // the data file
name vector<vector> infos; // the array for storing information
vector attribs; // the array for storing the attributes
GeneralTreegt; // the general tree for storing the decision tree
const int START; // which column is the start attribute, except the type
column const int I_TYPE;// the column index of type const int MAX_ENTROPY; //
set an max entropy to find the minimal entropy private: // to help print void
PrintHelp(int helpPrint) { for(int i = 0; i < helpPrint; i++) { cout << “…”;
} } // to find the index of the attribName in attribs array int Find(string&
attribName,vector& attribs) { for(int i = 0; i < attribs.size(); i++)
{ if(strcmp(attribName.c_str(),attribs[i].c_str()) == 0) { // the same return
i; } } return -1; } // this function is used for detecting if the arithmetic
is over bool CheckOver(vector& visible,string& type) { map<string,int>
types; int temp = 0; for(int i = 0; i < infos.size(); i++) { if(visible[i] !=
0) { type = infos[i][I_TYPE]; temp = types[infos[i][I_TYPE]]; if(temp == 0) {
types[infos[i][I_TYPE]] = 1; } if(types.size() > 1) { return false; // there
are more than one types } } } return true; // there is only one type } // to
create a Decision Tree void DTCreate(GeneralTreeNode *parent,
vector visible,vector visibleA, int i_attrib,string& detailA, int
helpPrint) { if(i_attrib >= START) { for(int i = 0; i < infos.size(); i++) {
if(strcmp(infos[i][i_attrib].c_str(),detailA.c_str()) !=0) { // not same
detail attribute visible[i] = 0; } } } string type = “”;
if(CheckOver(visible,type)) { // the arithmetic is over and add the type node
into the general tree NodeInfo n(type); GeneralTreeNode * node = new
GeneralTreeNode(n); gt.Insert(node,parent); PrintHelp(helpPrint);
cout << “decision type:”<<n.attribName<<endl; return; } map<string,double>
attribGs; // this is for deciding which attrib should be used for(int i =
START; i < attribs.size(); i++) { // iterate attribs if(visibleA[i] != 0) {
AttribDiff ad(attribs[i]); attribGs[attribs[i]] =
ad.AttribDifferComputer(infos,i,I_TYPE,visible); cout <<attribs[i] <<“的G为:”<<
attribGs[attribs[i]]<<endl; } } // to find the decision attribute double min =
MAX_ENTROPY; string attributeName; for(map<string,double>::iterator i =
attribGs.begin(); i != attribGs.end(); i++) { if(min >= (*i).second) {
attributeName = (*i).first; min = (*i).second; } } NodeInfo n(attributeName);
int i_max = Find(attributeName,attribs); for(int i = 0; i<infos.size() ; i++)
{ n.NodeDetailInfoAdd(infos[i][i_max]); } GeneralTreeNode * node =
new GeneralTreeNode(n); gt.Insert(node,parent); visibleA[i_max] = 0;
PrintHelp(helpPrint); cout << “choose attribute:”<< attributeName<<endl;
for(int i = 0; i < node->data.detailAttrib.size(); i++) {
PrintHelp(helpPrint); cout << “go into the
branch:”<data.detailAttrib[i]<<endl; // go to every branch to decision
DTCreate(node,visible,visibleA,i_max,node->data.detailAttrib[i],helpPrint+1);
} } public: // 要注意的一点是这里的decision2.txt要放在工程目录下。当然如果你愿意可以写绝对路径 // 注意文件的格式: //
首先一列为类别,然后是各个属性 // 例如: 类型 形状 // 西瓜 圆 // 冬瓜 扁 // 橘子 圆
DT():filename(“decision2.txt”),START(1),I_TYPE(0),MAX_ENTROPY(10000) {
GetInfo(attribs,infos,filename); DTCreate(); } // this function is used for
read data from the file // and create the attribute array and all information
array // post: attribs has at least one element // infos has at least one
element // pre: filename is not empty and the file is exist void
GetInfo(vector& attribs,vector<vector>& infos,const string&
filename) { ifstream read(filename.c_str()); int start = 0; int end = 0;
string info = “”; getline(read,info); istringstream iss(info); string attrib;
while(iss >> attrib) { attribs.push_back(attrib); } while(true) { info = “”;
getline(read,info); if(info == “” || info.length() <= 1) { break; }
vector infoline; istringstream stream(info); while(stream >> attrib) {
infoline.push_back(attrib); } infos.push_back(infoline); } read.close(); } //
create the DT void DTCreate() { vector visible(infos.size(),1);
vector visibleA(attribs.size(),1); // to judge which attribute is useless
string temp = “”; DTCreate(NULL,visible,visibleA,START-1,temp,0); } // print
the DT void Print() { gt.LevelPrint(NodeInfo::Print); } void Judge(const
string& testFilename,vector& types,const string& testResultFileName) {
vector attribs_test; vector<vector> infos_test;
GetInfo(attribs_test,infos_test,testFilename);
if(!CheckFileFormat(attribs_test)) { throw “file format error”; }
GeneralTreeNode * root = gt.GetRoot(); for(int i = 0; i <
infos_test.size(); i++) {
types.push_back(JudgeType(root,infos_test[i],attribs_test)); }
WriteTestTypesInfo(testResultFileName,types); } void WriteTestTypesInfo(const
string& filename, vector& types) { ofstream out(filename.c_str()); out
<< “类别”<<endl; for(int i = 0 ; i < types.size(); i++) { out << types[i]<<endl;
} out.close(); } string JudgeType(GeneralTreeNode * node,
vector& info,vector& attribs_test) {
if(gt.GetChildNodeNum(node) == 0) { return node->getData().attribName; } int
index = Find(node->getData().attribName,attribs_test); int branch_index =
Find(info[index],node->getData().detailAttrib); if(branch_index == -1) { // is
not find this detail attribute in this node detailAttrib // there are two way
to deal with this situation // 1. every branch has possibility to choose // 2.
no such type and can not judge // the first solution make the correct ratio
low // the second solution has no fault-tolerance. // and here I choose the
second solution. // if I have more free time later, I will write the first
solution throw “no such type”; } GeneralTreeNode * childNode =
gt.GetAChild(node,branch_index); return JudgeType(childNode,
info,attribs_test); } bool CheckFileFormat(vector& attribs_test) {
bool isCorrect = true; for(int j = 0; j < attribs_test.size(); j++) {
if(Find(attribs_test[j],attribs) == -1) { isCorrect = false; } }
if(attribs_test.size() == attribs.size() - 1) { isCorrect = isCorrect && true;
} else { isCorrect = false; } return isCorrect; } };

这里的main函数这样写(自己使用的VS2005):

int _tmain(int argc, _TCHAR* argv[]) { DT dt; //dt.Print(); string testFile =
“test.txt”; string testResult = “testResult.txt”; vectortypes;
dt.Judge(testFile,types,testResult); return 0; }

自己感觉DT 的注释比较详细,所以在我的blog中就不再做太多的解释。另外这段代码会将测试结果放在工程目录下的testResult.txt中。

另外在控制台上会有生成决策树ID3的相关相关的信息显示,例如:

红概率为:0.25
黄概率为:0.125
桔黄概率为:0.125
绿概率为:0.5
颜色的G为:1
球概率为:0.625
椭球概率为:0.25
弯月概率为:0.125
形状的G为:1.20121
轻概率为:0.375
一般概率为:0.375
重概率为:0.25
轻重的G为:0.688722
choose attribute:轻重
go into the branch:一般
红概率为:0.125
黄概率为:0.125
绿概率为:0.125
颜色的G为:0
球概率为:0.25
弯月概率为:0.125
形状的G为:0
…choose attribute:颜色
…go into the branch:红
…decision type:苹果
…go into the branch:绿
…decision type:苹果
…go into the branch:黄
…decision type:香蕉
…go into the branch:桔黄
…decision type:
go into the branch:轻
红概率为:0.125
桔黄概率为:0.125
绿概率为:0.125
颜色的G为:0
球概率为:0.25
椭球概率为:0.125
形状的G为:0
…choose attribute:颜色
…go into the branch:红
…decision type:草莓
…go into the branch:绿
…decision type:草莓
…go into the branch:黄
…decision type:
…go into the branch:桔黄
…decision type:桔子
go into the branch:重
…decision type:西瓜

这一段信息是什么意思呢?

红概率为:0.25
黄概率为:0.125
桔黄概率为:0.125
绿概率为:0.5
颜色的G为:1

红,黄,桔黄,绿的概率是颜色的具体属性。这里没有把entropy打印出来。如果此段代码被中科院的师弟师妹有幸看到,

你们可以在AttribDifferComputer()函数中添加几行代码就可以把每一个entropy打印出来。反正老师也会让你们看代码,这里就当作作业题吧。
(另外老师第十章机器学习ppt上的决策树的这个例子计算结果有错误。如果你认真计算过的话)颜色G的含义是颜色G的决策值,决策值越小,选择此属性的概率就越大。

那决策树是什么样子的呢?

choose attribute:轻重
go into the branch:一般

…choose attribute:颜色
…go into the branch:红


看看上面的这些.这里代表根节点是“轻重”,然后进入“一般”分支,然后进入“一般”分支的节点为颜色…然后进入”红“分支.这里一定要注意”…“,相等的"…
”代表树的相同的层次。

做出这个Decision Tree 的ID3代码主要是为了学弟学妹们在考试中测试用的。因为我只是测试了老师ppt中的例子,不保证对于所有的例子都正确。而且老
师出的考试题比较变态(属性十个左右)…如果手工计算应该需要一个小时左右的时间。

当初后悔没有先编一个程序。祝各位考试顺利…(我想我这段代码可能会在考试之前被搜到)。

同时提醒大家一点, ID3也不是什么很好的算法。当两个属性的G值一致时,如果它并不能给出一个更好的判断标准。而且如果采用顺序选择很有可能生成一个非最小决策树
。这点还值得研究一下。

这个类是为了给GeneralTree提供Queue队列操作才创建的。

因为GeneralTree使用层次遍历的时候,必须要使用这样一个队列。当然如果你没有这样一个队列,但是你在每个节点那里设置了计数器,那么你还是可以完成一个层
次遍历操作。

这里为了保持GeneralTreeNode的最简单性,所以没有添加计数器属性。

下面是List类的具体代码:

/* * create by chico chen * date: 2009/02/02 / #ifndef LIST_H #define
LIST_H template class ListNode { public: T data; ListNode
next;
ListNode() { next = NULL; } ListNode(T & data) { this->data = data; next =
NULL; } ListNode(T & data, ListNode* next) { this->data = data; this->next
= next; } ~ListNode() { next = NULL; } }; template class List {
private: int length; ListNode* head; public: List() { head = NULL; length =
0; } List(ListNode* head) { this->head = head; length = 1; } ~List() {
ListNode* tempHead = head; while(NULL != head) { tempHead = head->next;
delete head; head = tempHead; } length = 0; } bool IsEmpty() { return 0 ==
length; } // the coral function to insert the node // pre : none // post: no
matter what kind of situation, the function can work. void Insert(ListNode*
node, int index) { if(0 == index) { // insert in the front if(NULL == head) {
head = node; } else { node->next = head; head = node; } } else { if(NULL ==
head) { head = node; } else { if(index >= length || index < 0) { index =
length; } ListNode* temp = head; while(NULL != temp->next && index–) {
temp = temp->next; } temp->next = node; } } length ++; } ListNode*
GetHead() { return this->head; } // pre: list is not empty // post: return the
last element. ListNode* GetTail() { if(NULL == head) { return NULL; }
ListNode* tempHead = head; while(NULL != tempHead->next) { tempHead =
tempHead->next; } return tempHead; } // pre: node is not NULL // post: return
the node’s next node ListNode* GetNext(ListNode* node) { if(NULL !=
node) { return node->next; } } // pre: begin at zero, and the index is less
than the length of the list // post: if index is -1, then return the last //
post: if index is not -1 and less than zer, or bigger than the length, throw
exception. ListNode* GetAt(int index) { ListNode* temp = NULL; if(-1 ==
index) { // get the last temp = GetTail(); } else if(0 <= index && index <
length) { ListNode* tempHead = head; while(tempHead && index–) { tempHead
= tempHead->next; } temp = tempHead; } else { throw “out of list”; } return
temp; } void DeleteHead() { ListNode* tempHead = head; head = head->next;
delete tempHead; this->length–; } // pre: head is not NULL // post: delete
the last one and length subtract 1 void DeleteTail() { if(NULL == head)
return; ListNode* tempTail = head; while(NULL != tempTail->next) { tempTail
= tempTail->next; } delete tempTail; length–; } // pre: head may be not NULL
// post: if index is equal to -1, then delete tail element // post: if index
is equal to 0, then delete the head // post: if it is bigger than the length,
or less than 0, throw exception // post: delete one node at index and length
subtract 1 void DeleteAt(int index) { if(-1 == index) { DeleteTail(); } else
if(0 == index) { DeleteHead(); } else if(0 < index && index < length) {
ListNode* temp = GetAt(index-1); ListNode* dNode = temp->next;
temp->next = dNode->next; delete dNode; length --; } else { throw “out of
List”; } } }; #endif

这个类用于一般树形,每个节点可以有多个分支,且数目不定。

可以看做是二叉树的变形形式。一个节点除了父指针外还有左右两个指针。

左指针为孩子节点的起始指针,右指针为同父节点的兄弟节点的指针

例如:

A的左指针为B,右指针为C,C的左指针为E,右指针为D

则,A,C,D为同兄弟节点。B为A的子节点,E为C的子节点。

这里使用到了 GeneralTreeNode类

这个树没有delete操作。因为我暂时不知道这个树类在什么地方会用到delete操作。而且这个树的查找是O(n),相比与排序二叉树那是慢的太多了。不过这个树
在未知每个节点的分叉个数时,可以使用。其他的地方,个人认为还是尽量使用其他树形。

这个GeneralTree类还要进行大量的改进。

另外因为继承的缘故,这里大量使用dynamic_cast<>()方法。为了将GeneralTreeNode类转变为TreeNode类。这里我暂时还是不知道有
什么好的方法。

另外注意这里的Print函数,必须传入一个函数指针。因为树不知道你的打印数据方法和格式,其实我这里想了很多,最后感觉还是这种方法好点。感觉应该在TreeNo
de类中添加一个virtual Print()函数来负责data的打印工作。

开始的时候,想过使用模板的方法,在TreeNode中添加一个模板参数。后来发现这样做对数据控制不利,而且我要改动非常多的代码,不如直接在GeneralTre
eNode类中添加一个virtual Print()函数,然后传入指针参数去控制打印。

当然这样做的缺点在于如果还有类继承了TreeNode,而且也需要有print data
的方法。那么代码还要改动。但是现在的需求并没有看出这样做的趋势…所以暂时还是在GeneralTreeNode类中添加一个virtual
Print()函数.

具体代码如下:

/* created by chico chen * date 2009/02/02 * 如需转载注明出处 / #ifndef
GENERAL_TREE #define GENERAL_TREE #include #include
#include “GeneralTreeNode.h” #include “BinaryTree.h” #include “List.h” using
namespace std; // this tree can not accept the same value. No element is the
same! // The class is not finished, and I am thinking where the class should
be used. // And there is no delete operator. template class
GeneralTree: public BinaryTree { private : GeneralTreeNode

GetTail(GeneralTreeNode* head) { // only the right piont can be used!
if(head != NULL) { while(head->right != NULL) { head =
(GeneralTreeNode)head->right; } } else { throw “head is null!”; } return
head; } // pre: parent != NULL and index is bigger than or equal with 0
GeneralTreeNode
GetAChild(GeneralTreeNode* parent,int index) {
assert(index>=0); assert(parent!=NULL); GeneralTreeNode* head =
dynamic_cast<GeneralTreeNode>(parent->left); assert(head != NULL);
while(head->right != NULL && index–) { head =
dynamic_cast<GeneralTreeNode
>(head->right); } if(NULL == head->right &&
index > 0) { throw “index is over float!”; } return head; } // this is deep
print(深度遍历) void DeepPrint(GeneralTreeNode* subRoot) { if(NULL != subRoot)
{ cout << subRoot->getData()<<" "<<endl;
DeepPrint(dynamic_cast<GeneralTreeNode>(subRoot->getLeft()));
DeepPrint(dynamic_cast<GeneralTreeNode
>(subRoot->getRight())); } } // this
is level print(层次遍历) void LevelPrint(GeneralTreeNode* subRoot,void
(print)(T& data)) { List<GeneralTreeNode> queue; queue.Insert(new
ListNode<GeneralTreeNode>(subRoot),-1); while(!queue.IsEmpty()) {
ListNode<GeneralTreeNode
>* temp = queue.GetHead(); GeneralTreeNode*
tempNode = temp->data; tempNode->Print(print); for(int i = 0; i <
tempNode->childLength; i++) { GeneralTreeNode* tempChildNode =
GetAChild(tempNode,i); queue.Insert(new ListNode<GeneralTreeNode*

(tempChildNode),-1); } queue.DeleteHead(); } } // pre: node != NULL // post:
true iff node is in the Tree, false iff node isn’t in the tree bool
Search(GeneralTreeNode* subRoot,GeneralTreeNode* node) { if(subRoot ==
NULL) { return false; } else if(node == subRoot) { return true; } else { bool
a = Search((GeneralTreeNode)subRoot->getLeft(),node); bool b =
Search((GeneralTreeNode
)subRoot->getRight(),node); return a||b; } }
public: GeneralTree():BinaryTree() { this->root = NULL; } GeneralTree(T&
data):BinaryTree(data) { this->root->parent = NULL; } virtual ~GeneralTree() {
} // this function will call Insert (GeneralTreeNode* node,
GeneralTreeNode * parent) // and it will find the point of parentData. //
So it means if there are the same T in two node, it will return the first
node. //void Insert(T & dataCurrent, T & parentData) //{ //} // pre: node is
not in the tree. void Insert(GeneralTreeNode* node, GeneralTreeNode *
parent) { if(parent == NULL&& root == NULL) { // this is root root = node;
return; } if(root == NULL) { throw “no parent!”; } bool isFind =
Search(dynamic_cast<GeneralTreeNode>(root),parent); if(!isFind) { throw
“no such parent node!”; } isFind =
Search(dynamic_cast<GeneralTreeNode
>(root),node); if(isFind) { throw
“there is the same node in the tree!”; } if(parent->left == NULL) {
parent->left = node; } else { GeneralTreeNode* tail =
GetTail((GeneralTreeNode)parent->left); tail->right = node; } node->parent
= parent; parent->childLength ++; } // this is deep print(深度遍历) void
DeepPrint() { DeepPrint(dynamic_cast<GeneralTreeNode
>(this->root)); } //
this is level print(层次遍历) void LevelPrint(void (print)(T& data)) {
LevelPrint(dynamic_cast<GeneralTreeNode
>(this->root),print); } }; #endif

这里可能还需要一个 List.h

文件,大家可以使用stl中的代替,也可以自己写,也可以使用我的…

写这个类是配合GeneralTree这个类的。

这个类使用TreeNode基类继承而来。这里有一点要说明的。为了编程的方便,这里TreeNode中的成员属性均设置为Public

当然,如果有需求一遍写为protected。当然我这里是为了自娱自乐…所以没有在意太多。

TreeNode头文件详见 http://blog.csdn.net/cctt_1/archive/2008/08/19/2794469.aspx

这个Node其实是二叉树的一种变形形式。它含有一个父指针,和一个孩子个数计数器。

#ifndef GENERALTREENODE_H #define GENERALTREENODE_H #include “TreeNode.h”
template class GeneralTreeNode : public TreeNode { public : int
childLength; // how many children does the node have GeneralTreeNode*
parent;// the parent point of the node public: GeneralTreeNode(T &
data):TreeNode(data) { childLength = 0; parent = NULL; } GeneralTreeNode(T&
data, TreeNode* left, TreeNode* right, TreeNode* parent)
:TreeNode(data,left,right) { childLength = 0; parent = parent; }
GeneralTreeNode(GeneralTreeNode* a):TreeNode(a->data,a->left,a->right) {
childLength = a->childLength; parent = a->parent; } // to print the data
virtual void Print(void (*print)(T& data)) { print(data); } virtual
~GeneralTreeNode() { childLength = 0; parent = NULL; } };

查找它的各个孩子的任务交给了GeneralTree类来做,它的职能就是记录孩子节点的个数,并快速的查找到它的父节点可能上面那个网页的TreeNode.h文件
由于以前是直接贴代码到CSDN上,所以可能现在不适合拷贝。

所以将TreeNode.h的代码在贴到下方:

/* * create by chico chen * date: 2009/02/02 / #ifndef TREENODE_H #define
TREENODE_H template class TreeNode { public: T data; TreeNode *
left; TreeNode * right; public: TreeNode(T& data) { this->data = data;
this->left = NULL; this->right = NULL; } TreeNode(T& data,TreeNode
left,
TreeNode* right) { this->data = data; this->left = left; this->right =
right; } virtual ~TreeNode() { // cout << “node (”<data<<“)
destory!”<<endl; // to do } T& getData() { return data; } void setData(T&
data) { this->data = data; } TreeNode * getLeft() { return left; } void
setLeft(TreeNode * left) { this->left = left; } TreeNode * getRight() {
return right; } void setRight(TreeNode* right) { this->right = right; } };
#endif

从我用计算机开始,算来一共装过两三次系统。一直以来靠备份还原度日。终于最近不行了。蜗牛没有备份资料,只好重装,开始的时候只是在清理各种软件,然后使用PQ
Magic分区。然后PQ提示重启…结果就发生了boot.ini
missing。因为多年没有装机,所以没有把安装盘带回家,只好现在网上下,然后再刻录为光盘。结果nero的刻录软件老是出问题,不能识别或者说burn
error还有buffer error错误,害我损失了n张盘。那后拿到蜗牛上去试,结果蜗牛死活不认,一直boot cd failure。想哭呀…不知道是不
是蜗牛的那个光驱不认,还是刻录的盘不能启动。因为有张linux的盘,蜗牛是承认的,就是慢死在安装上。后来还是找到了新光驱,然后换下了蜗牛的光驱。那几个启动盘
都能使用,也不用看网上的教程如果做一个启动盘,其实就是光驱的问题。装了Windows xp分了两个区,希望一个装Unix,然后再使用FreeBSD的安装盘。
这里犯下一个错误,就是不能使用windows可以识别的分区来装Unix,一定要把要装分区的标识去掉才行。否则你装FreeBSD时要不出现cannot
write hd0 ,要不即使装好了,并且装了boot Mgr,可是你启动windows时,一定会出现ntldr is missing
错误.然后使用网络上的那个教程也没有用。

网络教程是: http://www.computerhope.com/issues/ch000465.htm

。所有的办法用尽,还是选择重装。然后去掉d盘符。装上了FreeBSD。不过FreeBSD画面.的确不咋地…

然后出问题的就是我的土狗,这家伙怎么都不能联网。开始的时候,如果你开机的时候插着网线,那么可以上网。你中途拔下网线,它便死活不认。有时显示连接上,但是发出的
包和接受的包都是0.也想卸载网卡,结果每次卸载都卡在那里。网络连接停用和修复有时也会卡在那里。最后连关机都关不上。不知道为啥,土狗特给我老爸面子。卸载驱动,
一下就成功。我看着真是无语。看来人品真的很重要。

或许人生要自己把握才能叫做人生。

不管结果如何,总是自己做的决定。想起了教父的那句话:“不管对错,一定是我做的决定!”

在7楼的日子。没有目标,每天只不过是为了活下去。不知道自己的目的地,不知道生为何,死为何。

有天终于可以脱离,去想去的地方,成就自己的“梦想”,掌握自己的生死.

或许我们活得很简单:看到大海,走到目标,穿上喜欢的衣服,体味到生的乐趣。

博弈
如果有最佳策略,则对手一定采用那个最佳策略。自己要根据那个最佳策略相应而行。但是有一点要谨记:
那就是对手是从哪个角度考虑他的最佳策略的。如果是从短期的预算,还是想击垮某个竞争对手?
如果你有一个优势策略,那么就选择你的优势策略,不用担心对方。对方一定照办。优势策略不意味着你的策略产生的最差结果比其他
策略要好。(这是同时行动是才采用的)

追求最佳,避免最差

博弈是中纳什均衡不代表有利还是没有利。得利不得利是另外一套体系。博弈均衡是指产生了一个稳定的结果。
纳什均衡:在对方确定策略里,自己的是最好的。所以没有人会改变策略。
有几率策略来制定相应的策略。
纯策略是参与者一次性选取的,并且坚持他选取的策略;而混合策略是参与者在各种备选策略中采取随机方式选取的。
在博弈中,参与者可以改变他的策略,而使得他的策略选取满足一定的概率。
启示1:没有把真正的问题找出来就盲目采取行动,是最愚蠢的做法。能够找出问题,已经可以说是把问题解决一半了。
启示2:解决问题的公式:
(1)找出问题发生的原因;
(2)分辨情报的价值;
(3)彻底推行解决方案;
(4)观察事情进行得是否顺利。
任何事情都看似很难,实质不难;任何事情都比你预期的更令人满意;任何事情都能办好,而且是在最佳的时刻办好——麦可斯韦尔定

律有助你走出阴霾。
如果未来是重要的话,就不存在最佳的策略。一报还一报的规则。不首先背叛。希望坚持引出不背叛的好处。
在持续的囚徒困境中如何表现:
1.不要嫉妒。
不要把对方的成功和自己的成功对立起来
2.不要首先背叛
3.对合作与背叛都给予回报(惩罚和宽恕的公平)
4.不要耍小聪明(不要用复杂的规则进行推断,不要永久报复)
5.一报还一报从来没有在游戏中赢得更高的分数。

启示:两只困倦的刺猬由于寒冷而拥在一起。可因为各自身上都长着刺,于是它们离开了一段距离,
但又冷得受不了,于是凑到一起。几经折腾,两只刺猬终于找到一个合适的距离:既能互相获得对方的温暖而又不至于被扎。
了解并关心对方,并巧妙地保护自己,会使合作更加长久。
长期建立合作关系。如果背叛的惩罚非常大,那么即使短期的合作也最优策略
只要双方的长期合作激励大于背叛的短期激励即可。
不可以无条件合作,这样会宠坏对方。
未战而庙算胜者,得算多也
人数的平方代表军力,军力多为胜多。
分散敌军,各个击破。
合则两利,分则两害。
同样的兵力守则不足,攻则有余
形人而我无形
兵闻速拙,未睹巧久。夫兵久而国利者,未之有也。故不尽知用兵之害者,则不能尽知用兵之利也。
成本就是为了得到某种东西而必须放弃的东西。
你支付的成本越大,局面就越不利。
围棋中不将棋走重,效率低,而且包袱重。
最好不要迈出第一步,除非你清楚的知道自己去哪里。
认识自己,正确选择,这是最重要的。
保留选择余地总归是有好处的。
计划好的行动路线以及使这一路线显得可信的承诺。
一个无条件的行动(不计代价、只要胜利)可以使这个参与者获得策略上的优势,抢占先机,率先出招。
回应规则:许诺和威胁。

经济活动要善于从已有的认知模式中跳出来。要有足够的学习能力——即探索未知领域的能力。
两只手表并不能告诉你更准确的时间,只会让你在两种不同的时间面前茫然无措。你要做的就是选择其中较可信赖的一只,尽力校准它,并

以此作为你的标准,听从它的指导行事。
如果你想过得幸运一些,你必须只采用一种判断准则而不要贪多,这样你会活得更容易些。–尼采
一个经济社会,要尽量做到信息是对称的。
为什么知情权如此重要?就是因为信息的传播有利于人们在掌握信息之后,通过理性选择,作出正确决定。这对社会和个人都有好处。
民可使由之,不可使知之。
所谓专家,就是周旋于三宫六院间的太监,无所不知,却无能为力。
别在自己不熟悉的领域发言。
根据迹象预见到危险的人,能够避开危险。
有四样东西一去不复返:说过的话、泼出去的水、虚度的年华和错过的机会。
岂能尽如人意?但求无愧我心。
上苍赋予人类的许多宝贵礼物中,“选择的权利”就是其中的一个。
边际效用递减原理说的是:第一个东西带给他的最好,第二个就其次…
运气仅仅是你最喜欢的状态而已
(1)世界上本来就有很多潜在的稀罕事,你肯定会经历其中的一些。
(2)有些事情看起来稀奇,实际上并不是。比如,在24个任意选择的人们中发现两个生日(月和日)一样的人的概率有多大?答案是超过50%!
如果对手知道得比你多,千万别赌。
谁也不满足于自己的财产,谁都满足于自己的聪明。——托尔斯泰
炒股是一种冤大头游戏。
人往往是这样,到手的东西总不那么叫人满意。但是知道“适可而止”总不是坏事。
破窗理论的谬误原本不知道资源是短缺的。因为这里并没有增长财富。而是消耗了财富。
经济学建立在两个假设前提上:其一,人是自私的,都在追求利益的最大化;
其二,人是理性的,其所有行为都是为了实现追求利益最大化这个目的。
任何时候,只要可能,我们必须做最有成效的事情。
所谓“此一时,彼一时”,当时做的认为正确的决定,不一定事后认为也正确。不过不要后悔了,既然已经做了,那就坚持自己的决定。
有冒险而成功的将领,没有无备而胜利的军队。在不曾达到目的以前,尽可能保存好每一个铜板,尽可能不被眼前的事物牵绊,这是成功的

必备条件,因为前面的路说不定很长。
民主投票往往不民主
一方能否获胜,不仅仅取决于他的实力,更取决于实力对比造成的复杂关系。
才华出众者创造历史;碌碌无为者繁衍子孙。
三党的政策是不稳定的
我们不是因一贯正确而获得权威,而是因获得了权威而一贯正确。
怎样才能把权力交到有能力的人手中,交到善良人的手中。这个问题不能解决,一切都无从做起。然而,现在已经没有好的方法。
情侣博弈无法使用纳什均衡
帕累托效率表明:如果可以改善自己而不损耗他人利益,那说明资源还没有得到充分利用。否则定会改善自己损害他人。
从某种层度而言:GDP是对自然破坏的指标。
根据纳什均衡,可能等不到宇宙灾难的那天,人类就已经自己把自己灭掉了。

故此,尔等须知晓自身宿命,故此,尔等须把稳船只……置欲求于动机之后,尔须奋力以搏。
故此,且容好奇心为尔等指南。追寻天上真理,如同在大地寻觅。
所不敢为者,为之;所不敢至者,往之。
道路千万条,宜选阳光道。聪明择路,正派为人,公平行事。
故此,尔须多有智识,勤于创造。
——《爱因斯坦的圣经》

好多人失败,不是因为他们傻,而是太聪明。
一个聪明人的麻烦是他总希望比别人多得一些,或者说,他总面临这样做的诱惑。
要不要与人合作?利益如何分配?它会不会得罪某些人?等等。你不得不考虑它们,因为这些问题确实存在。这样你就不得不花费大量的精

力和智慧去处理它们,而这些花费对你本来想做的那件事并无多大益处。也就是说,它们大大提高了你做事的成本。这种多余的花费似乎是

我们的宿命。
不要把赢作为惟一目标,也不要总是追求最好结果。
你不可能永远控制局面,也不必永远控制局面,人类最理智的时候,往往是别无选择的时候。
即使是全然理性的决策也可能是错的,反之亦然。
无论你想做什么,不管是赌博、运动、投资股市、择偶,甚或发动战争,之前你最好弄清楚自己在做什么。
合作与双赢并不意味着完全的公平。所有好的策略,都不过是在公平与效率之间找平衡。
团体决策基本上比个人决策更难保持理性,在团体决策过程中有很大的操弄和使诈的空间。
至今仍找不到令人满意的方法,能在不产生不良结果的情形下,同时顺利地把各人偏好转换成团体偏好。阿罗不可能原理告诉我们:任何制

度都有缺陷,而最好的制度就是造成损害最少的制度。内耗不可避免,明智的人把内耗控制在可接受的限度内。据此推论,“若每个人的行

为都以理性的自利为出发点,则其结果仍会对社会有利”,这个乐观想法仍旧是个误区。更不幸的是,它反而掩饰了无知自利的影响。再以

此推论,至今人类仍未发明出一种政府形态,完全令人满意、可以作出造福社会的团体决策。我们真的不知道该往何处去,所以要常怀谦逊

之心。

有时我想知道怎样设计容器类才是合理的。

是让用户自己new一个新的对象在放入容器类,还是我隐式的new一个新的对象?

这就带来一些问题。如果我隐式为新的对象建立容器类,那么很有可能我以后不好释放。因为对于object来说,是不能使用delete。并且每次都new也带来不小的
时间损耗。

最简单的方式是不为用户new出新的对象,不delete容器类中的对象。

那么假如粗心的用户new出来新的指针并放入容器中…那么用户只好清除的时候先清除容器内的每个对象,然后再delete容器。

这样看起来不错。好像也只能这样做。

有三个门,两个羊一个车。嘉宾选择一个门后,主持人打开另外两个门中的一个,门里是羊。嘉宾改选或者不改选。门后有车就中大奖。否则什么都没有。

记得当年做这个题目的时候就与小李子和疯子争论的不休。

当时时至今日仍然不能完全确定这是个概率问题。

其实这个不完全是概率问题

因为概率中只是考虑了出现结果的可能性。但是这个问题却考虑出现结果的好坏。

换而言之,就是在这个事件中。它是一个不可重复的事情。你甚至可以考虑到主持人的心理在做决策。

所以它不是一般意义上的概率问题。

因为主持人的心理对这个事件有着非常重大的影响。如果主持人随机选择一个门并打开,并且里面是羊。那么你改选或者不改选你的概率都是1/2。如果主持人要指定打开一个
羊的门,那么你改选选中车的概率就是2/3.如果这个老兄和主持人是熟人,其实可以通过这点信息交互就能断定哪个是车的门。

有一个同样的例子:三个囚徒,其中两个是要被释放的。囚徒A与看守很熟,但是不能直接打听自己是否会被释放。另外两个中肯定有一个会被释放。那么是否打听过那两个中的
一个释放名字。会影响自己的释放的概率呢?

当然不会,这点谁都能理解。但是囚徒A竟然改变了另两个囚徒选中概率。其实…我觉得也是不可能。一个不被释放概率变为0,另外一个变为2/3.这样囚徒A会不会因为
得到这条消息“另外两个中的一个人被释放了”,而非常开心呢?(傻瓜才会开心!)

那么说来,如果我们有很多奖项等待颁发(抽奖的形式)。那么你应该听到别人的名字而感到开心。因为你不久就会中奖了。但是如果刚才的情况是两个囚徒同时知道另外一个人
可以被释放。那么难道两个囚徒不被释放的概率都是2/3吗,难道不应该是1/2?按照刚才那个选车选羊的问题给出的结论。那的确都是2/3.所以我一直不认为这个是个
概率的问题。因为这是个博弈问题。

如果主持人是相当狡猾的。他的任何选择都没有给带来任何信息。那么你的选择其实刚刚从打开羊门的一霎那才开始。

但是不管怎么说,你改变你过去的选择在概率上对你来说是百利而无一害。因为不管怎样你选择另外一个门的概率比你坚守一个门的概率要么相等,要么高出一倍。

所以最优策略就是改选。

0%