0%

发表于 分类于 Valine：

对于恋爱的一些思索

在我成长这么多年，最值得一提的一点就是，我和家庭的和解。我一直不明白我是怎么从厌倦逃离家庭到现在想念和热爱我的家庭的，现在大概明白了，是恋爱教会我如何爱和感受爱。
其实每次有勇气面对眼前的这些问题的时候，我都会想，我为什么想要拉她回来，其实我在想一个什么样的问题呢，就是，为什么要恋爱，也就是说当我在学会怎么恋爱的时候，我始终没想明白，为什么要恋爱。这个问题其实可以很含糊的回答，比如两个喜欢的人在一起了，不需要理由。但我不喜欢这样糊弄，于是我开始认真地想为什么人要恋爱，仅仅是喜欢对方的好然后想要占有吗，仅仅是看到别人恋爱然后从众吗，或者是其中有很多很多原因。我觉得这个问题每个想要好好谈恋爱的人都要搞懂，或者说即便它是搞不懂的，也要深入想一想，然后深入浅出，不然就很难谈一场健康的恋爱。

一、恋爱可以让我发现自己的缺点
这点毋庸置疑，很多很多缺点是自己一个人没办法发现的，即便身边朋友感觉到也不会跟你提出，所以在恋爱的时候，我想变得更好，同时我也会暴露自己的缺点，这让对方感到不适，对方向你提出了你的问题，这些问题通常是你自己没有发现过但是一发现也会觉得确实是个问题，然后认真的反思改进，不断的互相成为更优秀的人，不只是为了对方，也是为了自己。

二、恋爱可以让人学会爱人
其实我一直觉得我自己很爱对方，但其实我一直不很会爱对方，这里说的不是说生活中的惊喜和浪漫，而是在说从心灵上如何去关爱对方，其中包括如何关心一个人的情绪、如何尊重一个人以及如何帮助一个人，这些都算是爱，但是要比那些表面的仪式感更难意识到。“我都是为了你好！”这些人往往都不会爱人。

三、恋爱可以让我学会感受爱
人其实都容易自私，喜欢索取容易变得贪婪。往往这个时候我们会对对方苛责，会极尽力气想让对方对自己好，我想说，这样的人不懂得被爱。被爱当然也是种能力，恋爱的过程中人们其实很难学会被爱，相反当恋爱出现问题，人才开始思考对方的好，才开始感受到原来对方其实真的对我很好了，这时候才会想起来当时自己的幼稚。就是这样一步步学会了感受到对方的爱意。其实对于家庭也是这样，感受家庭的爱和如何去爱家庭都是一件很难很难的事情。

四、恋爱可以让我变得勇敢
一个人的时候往往瞻前顾后在意别人的看法，恋爱让我有了依靠，可以不必太在意其他人看发，所以可以勇敢的尝试以前害怕的事情，恋爱让我变得勇敢起来。

五、恋爱让我认识自己
人最难的一个过程还是认识自己，成长就是不断地认识自己，但是往往一个人很难明白自己，日常生活中很难和其他人有深入灵魂的交流，但是恋爱让你走进对方深处的同时也看清自己内心深处。恋爱本身就是两个人的交融，人是复杂的，没有完美契合的两个人，所以这中间必定会有摩擦，但正是这些摩擦让你认识到自己的形状，认识到自己是一个怎样的人。

六、（还有很多，用心感悟吧）…

最后想说的是，人类社会形态本就不是孤身一人的，除却极少数，大多数人都需要一个依靠，这个依靠不是绑定，也不是享乐的纽带，它最终极的要义就是使得两个人在幸福和痛苦中感受到人间的美好同时也变得更加勇敢坚强，大概这样的变化适合人类生存吧，大概这才是健康的恋爱吧。

反观自己，虽然甜蜜不少，但是真正去思考如何去谈恋爱，如何处理痛苦，如何反思进步共同成长却是想的很少，当然不是否认享乐的恋爱不好，只是，我们已经有过这样的阶段了，总是要到下一个阶段的。
爱总是会消失的，如果不转化为习惯、依赖、责任，那就很难以后了，没有人会永远保持新鲜感。所以，希望每个人都能认识到，自己为什么要谈恋爱，不要总是被推着走，这样才值得健康的恋爱，打开心结吧，我的朋友们。

阅读全文 »

发表于 更新于 分类于 Valine：

—> 把这几百页的书从头到尾看一遍梳理一下期末考点吧！

基本数据类型与数组

标识符和关键字

  1. 字母、下划线、美元符号、和数字
  2. 第一个不能是数字
  3. 不能是关键字
  4. 不能是true false null（尽管他们不是关键字）
  5. 区分大小写

基本数据类型

8种基本数据类型

boolean

byte,short,int,long

char

float,double

  1. int 四字节
  2. byte一个字节
  3. short两个字节
  4. long八个字节
  5. 没有无符号即unsigned
  6. char两个字节，没有负数
  7. 使用unicode字符集，前128个是ASCII
  8. ‘\u0041’表示A
  9. （char)65 a
  10. double y = 0.4 小于 float x = 0.4f;

类型转换运算

低赋值给高会自动转换，反之需要强制转换

低到高排序：byte short char int long float double

阅读全文 »

发表于 分类于 Valine：

昨天挺突然的，忽然得知学校封校了，一阵骚动，食堂面包房、超市、寝室楼下买水，到处都是长队，我很久很久没见过这么大的阵仗了，本来打算到超市买点酒只好作罢。约了室友打羽毛球，结果体育馆已经封起来了，到处都是志愿者，我看到各个运动场馆已经清空了，核酸检测的桌子已经摆起来了，然后收到通知，全员连夜核酸检测。惊诧与学校的行动之快，我和室友在室外的霾里打了球。后来回到宿舍稍稍休息之后戴好口罩下楼了。

刚走出宿舍楼，被身后的宿管阿姨叫住，一口浓重的sang海口音。
“你四去检测的对伐？”
“恩是的，我准备去。”
“那我跟你一起去好吧。”
忽然觉得相处了快三年的阿姨像个小姑娘一样在漆黑里祈求着我，我说走呀，可以。

一路上人潮汹涌，去检测的人和检测回来的人把桥上填的满满的，阿姨一路嘴不停，向我诉说着那些阿姨们都回不去了，只好找个小房间住一晚。其它好多话我也听不懂，只好嗯嗯啊啊地应付，她似乎看出来了我的应付，还不停地追问我。呼——终于坚持到了体育馆门口，那个时候队伍已经从体育馆排到了教学楼，少说百米长。但是那队伍极快，哪里是在排队啊，我想，这分明是在马拉松。我看到那队伍在我面前跑动着，阿姨拉着我说跑起来，我说我们要去后面排队不能插队，阿姨说哎呀排什么队，都在跑。罪过，于是我就和阿姨插了队，插在了几百人的前面。
由于队伍实在跑动过快，阿姨体力不支，我就减速等着阿姨，我说慢点慢点不着急，这时前面的保安喊起来快点快点，身旁的志愿者看着阿姨说阿姨加油！阿姨笑笑说你也在这！

我带着阿姨走进体育馆来到核酸检测的桌子前，阿姨跟我炫耀说她已经截好图了，我看了看水滴屏，怀疑是红米note，但看UI又不像，倒像是HUAWEI的野鸡手机（说歪了）。我坐在那，等待着被捅鼻子（之前都是喉咙），那医生喊着放松放松，越喊我越紧张，感受着长长的异物捅进最深处转来转去，仿佛要把我的灵魂搅碎了，一边眼泪流个不停。结束后我在后面等着，后来看到阿姨做完以后四处找我，我伸出手摆一摆，这里。“你不等我我都不知道往哪走了！”阿姨有点埋怨的说，“哎呀，捅鼻子可太难受了，鼻涕都要捅出来了，阿姨眼泪都流出来了。”我就在体育馆看着以防护服和嘈杂人群为背景的阿姨，有点好玩。“我从来没来过这个体育馆。”阿姨说。

你叫什么呀？
阿姨突然问我。
我告之。
阿姨嘴里巴咂着我的名字，然后说有好几个呢，可能是大一的。

回来的时候，阿姨还在像个小孩子一样嘟哝着什么，我没太听清，只记得到楼下阿姨向我道谢，我说没事，然后匆匆上楼了。
室友买了酒等我喝。
纯生真难喝，室友说。

阅读全文 »

发表于 更新于 分类于 Valine：

前段时间看了乙一，感悟到故事以及写故事本身的魅力，所以想把脑中很有意思的想法也写成故事来，尝试写了一部分，但是后面的故事情节自己很不满意，所以目前的框架还没搭起来，但是近期实在忙碌，就先停一停，我相信所有人都会理解的。

一

八月份的天流金铄石，这让我一直处于一种焦虑的状态里，每过正午，我坐在电脑面前盯着屏幕上密密麻麻的代码就会感到热浪从我的背后紧紧包裹着我。我明明开了空调，空调外机的声音已经响彻楼层，但我依然感到酷热难耐。我感觉那热像是化成了人形，就在我的周围走来走去，我挥舞胳膊却怎么也抓不到它，于是我决定出去走走。由于不知道要出去多久，或许几天几夜也不回来，出于安全我把寝室的电源断了，不过是拉下电闸那么简单。
刚走出宿舍门，我就感到我被前后夹击了，那化成人形的热跟着我溜了出来，和外面的热合起伙来收拾我。我猜测这会宿舍又凉快下来了，但我不愿再回去，我抱着自己做好防御工事，一边同热较量，一边踉踉跄跄下了楼，期间与正在上楼的工人师傅撞了满怀，我们互相沉默，匆忙走掉。宿管在值班的位置上一动不动，往常大家会向她问好，但这个时候我们都不想被打扰。我喜欢看见她睡着，这样我会很自在。

我走出了宿舍楼，成千上万的蝉鸣向我扑过来，我眯起眼睛看着四周，到处都是郁郁葱葱的树，我知道那可恶的蝉就藏在里面。白色的天空从树的缝隙间流到地上，汇聚成一滩滩大大小小的水洼。我拖着步子在这胶状的空气里行走，打算到便利店买瓶啤酒。前后左右到处都是热，他们太吵了，推搡着我，挤压着我，搞得我晕头转向。
便利店在学校不远处，自动门打开了，一股凉意从里面偷跑出来。自动门每开一次都要偷偷跑出来一些凉，就像我从宿舍里跑出来一样，而随后，也就是在自动门关上以后，还会有一些凉会被抓回便利店——空调就是这么残忍的家伙。
我对便利店的东西如数家珍，由于不喜欢在食堂的人群中乞求座位，我常常自己出来到便利店寻找能够填饱肚子的食物——这里总是空无一人。从冷柜里拿出来啤酒，结账，随后又坐在了靠玻璃墙的凳子上。囚禁着凉的液体从我的嘴唇灌进口腔流过食道到达我的胃部，每次吞咽，我都把凉从易拉罐里转移到了我的胃里，它们只不过是换个牢房罢了。我坐在那里四处张望，似乎这样可以给便利店增加点人气，这时自动门开了，伴随着轻快的音乐，我看见她走了进来。

我惊讶地看到她和我拿了一样的啤酒然后坐在了我的身边。我并不太喜欢和陌生人来往，坐在便利店也是因为这里很少有人驻留，这里已经成了我的私人领地，所以她的入侵顿时让我有点生气，于是我决定不再理她。
“你好，坐在这里你不会生气吧？”
手机屏幕亮了，我收到了这样一封Email，打开我的电子邮箱，这样短短的文字就这样肆意地躺在我面前。她怎么会知道我的邮箱，我往右边悄悄斜了一眼，并没有发现她的任何动静，我期待这个时候她看我一眼，那样只要我扭过头我们就会双目对视，这将是绝佳的交流时机。从这一刻我开始觉得她是个有趣的人。但是她并没有。她没有任何动静，就像我不存在一样。由于我不善于直视别人，所以一时没办法弄懂她具体在干什么，但我可以肯定的是她并没有看我。
我想了想还是决定给她回信，我并不确定这封邮件是谁发的，但直觉告诉我一定是她。

“随便，又不是我的地盘！”
我昧着心意回了邮件，虽然我同意了，但是由于我担心她会察觉不到我客气的背后还有一丝不满，所以加了叹号。但我不知道她会怎样解读这个感叹号，或许她会理解为我的热情好客，一想到这里我又感觉后悔。
“你在吃什么呀？”
我注意到她邮箱的昵称是“关”，或许是她的姓氏，也或许是她名字中最喜欢的一个字，但我更倾向于礼貌地叫她关小姐。
因为常常孤身一人，所以我格外珍惜这次交流，虽然我明明什么也没有吃，我也很不希望对话到我这里就戛然而止——尽管我一开始并不是很喜欢这个关小姐。而当我已经写好了要回复的内容时，手机却怎么也上不了网了。

二

本意决定在外面逗留几天的我又回到了宿舍，因为我无论如何也连不上便利店的网络，而移动网络在此刻也断了链子。不出所料，宿舍里果然凉了下来，空调还在轰隆隆的工作着，我这才意识到空调的电路是另外的，即便我切断了整个寝室的电源。
我将总闸重新推上去，随着“哔——”的一声，启辉器将日光灯管点亮。自从暑假室友都回家以后就没有关过灯，这样独自一人看着灯管从暗到亮还是第一次。但我顾不上灯管了，我的目光拽着我坐下打开电脑，但很不幸——我的电脑也连不上网络了。我觉得很诧异，我又拿起手机，网络旁边的叹号依然在，天哪，我居然没办法发出一封小小的邮件！
蝉忽然静了下来，我听到外面公交车到站的播报，楼上有人冲了厕所，还有不知道是几楼的水管不停地发出嘤嘤嘤的怪叫，那是空气柱在高压下不停震动产生的声音。我仿佛看到那声音和蝉鸣和热浪趁我不注意潜入宿舍将我的网线咬断，将便利店的网线咬断，又钻进我的手机将所有的天线网卡都一并咬断，它就是要我上不了网。

“谢谢你告诉我，听你说话的语气，你是一个好人~”
这时我又收到了邮件。
我看着那句似乎是赞赏我又似乎是讽刺我而且还有些让人摸不着头脑的话出现在手机通知栏里，和网络旁边的叹号一样，它切切实实的存在着。我试着点开通知，我仿佛听到关小姐在我身后对着我的耳朵说“你是一个好人~”。
她为什么还能发进来邮件呢？我什么也没告诉她呀！说话的语气是指我同意她坐下的语气吗？她是误解了我的感叹号吗？为什么要称我为一个好人呢，明明素不相识！我觉得很难理解，同时也很气愤。我不理解为何断网还能收到她的邮件，我气愤即便她是在夸我，我依然不喜欢一个陌生人称呼我为一个好人，正如我不喜欢随便称呼一个不认识的人为好人一样，哪能如此随意的就给对方套上好人的光环。我想象着假如我依然坐在便利店，她忽然站起来居高临下看着我，对我伸出右手说，你是一个好人。这样的事想想都有点恶心。

“原来你才大四啊？我已经研二了！”
邮件又来了，我拉过来室友的躺椅，将自己陷入柔软当中。夏日的炎热已经烟消云散，蝉鸣不再聒噪，我甚是感受到了风在我的头顶绕来绕去，清凉的雨从我脖间流下，滑过我出汗的脊背钻进衣服的沟壑里。我想象着她下一封邮件会发什么，我马上要大三了，我明白了她并不是在跟我聊天，这邮件一定是要发给另一个人的。这时的我有一种偷窥其他人秘密的快感，不过究竟是什么样的人会用邮件聊天呢。我在柔软中等着下一封邮件的到来，我似乎在像看一本小说一样不停地猜测接下来的情节走向，我想她可能是上个年代的人，那个时候或许他们还比较习惯用邮件交流；不过也可能是和我一个时代的人，要真的这样，那可就有趣起来了。我喜欢有趣的人，然而我太不擅长打交道，每次遇到有趣的人又经常把关系搞得一团糟，但是这次却有个有趣的人自己送上门来，我可以肆无忌惮的窥视着她的邮件而不用担心搞砸关系。一想到这些我又感觉很兴奋，要是有个人站在我旁边，一定会觉得我是个变态。你想想，一个独居的大三男生窝在躺椅上咧着嘴笑，脑子里还幻想着窥视其它女生的聊天，多么变态啊！
就这样想着，等了很久，邮件却迟迟不来。也许是最近学业压力太大了，或者是夏天的热让我很久没有睡过好觉了，我就这样躺着睡着了。

阅读全文 »

发表于 分类于 Valine：

剃了头，嘴里噙着嚼不烂牛肉，带个耳暖，个子不高，但走路有力得很。
走着走着，桥就在脚下了，电话识趣地响起。

电话那头：家明，到哪了？
电话那头：在月亮底下？我看不见月亮。
电话那头：我宿舍不向阳，但还是看不见月亮。
电话那头：今天不是十五吗怎么会像个月牙呢，我还是看不见啊，是云挡住了吧。
电话那头：你拍这照片，肯定是云挡住了，另一半还能隐约看见点。
电话那头：正常的也没这么明显啊。
电话那头：啊真的吗？
电话那头：是要补一下天文学知识了，但是我看不懂啊。
电话那头：你说的很有道理，说不定月亮一天也有圆缺。
电话那头：天哪，那完蛋了，我们成了最后一批人类。
电话那头：你快去问问天文学大佬去吧。
电话那头：啥？月食？我也想到了，但想着这么罕见的东西应该不是吧就给pass掉了。
电话那头：你不也是吗？我是真的想到了。
电话那头：挂了挂了。

把手机揣进裤子口袋里，口袋有点小，塞进去憋得慌，又拿出来了，还是不舒服，又塞进去了。要说想舒服也行，搁上衣口袋，但就是不想这么做，就是觉得别扭。揣着憋得慌的手机往前走，绕了一个大圈，拐了弯，走到十字路口，交警赶着横向的人过马路，绿灯闪瞎眼了，那人还在扣手机。交警和那人和十五的月牙看起来好看的很，于是掏出来手机准备咔嚓。“草，啥也拍不到。”骂骂咧咧过了马路。也不是啥也拍不到，要拍交警也能拍，拍那人扣手机也不是不行，哪怕是拍月亮，跺跺脚也能看，可就是拍不了这幅景，这景不是交警，也不是那人扣手机，还不是月亮。景就在那，就拍不着。
又走到十字路口，打算右转了，看到个女人跟自己一样右转。那女人追不上来，步子太小了，一会就被甩八丈远。走了半道，停下来看看手机，也没啥消息。也不是为了看消息，就是想看两眼手机，手机屏都不用点亮，就那么看两眼就行。这会两辆公交披星戴月开了过去，盯着看了半天。那女人追了上来。
“你别追我。”
加快脚步向前走，碰上对情侣，路灯黄黄的照着他们，站在远处给他们拍个照。那女人又追了上来。
“草，追啥追，你先走。”
坐在树底下看了会小说，今天刚看完本小说，不知道看啥好，随便翻。也不是不知道看啥，看刘大爷其它书也行，看历史看科普看社会都行，但就是都行，搞得不知道看啥了。盯着屏幕一会，那女人已经走远了，这才起身走。这会儿有从学校出来回宿舍区的人，也不早了，看到个人骑着车带着个女生。忽然想起来小时候母亲骑着力矩很小的自行车带着自己和姐姐俩人骑了几公里到大姨家洗澡的事。家里穷，天一冷就是没地方洗澡，常四处寄人淋浴间下。眼泪立马就下来了，想家里人了，想的不得了，但不久前刚打过电话，再打也不知道说啥。要说也能说，就是说了就会让家人觉得自己难受，觉得自己是不是有心事，一想到这也就不说了。
正走着，听见俩人议论月食，再回头看，背后的月亮跟闰土头上的没啥两样。俩人一人说是月食，一人说没有。开头那人就翻开朋友圈给另一个人看。看罢圆月，回过头又惊了一下，那个女人停了下来，扭头正看着自己，黑色的深筒高跟鞋，肉色裤袜，黑色贝雷帽，一头长头发盖下来，就那么看着。
“你别追我！”
于是加快脚步向前走了，再往后看时，那女人还是背对着，举着手机拍月亮。也许刚刚也没看自己，就是看月亮而已。

电话又响起了。
“家明，到哪了？”
“回去了。”
正说着，已经走到超市门口了，翻了瓶啤酒走到门口对着老板笑，然后把账结了。

阅读全文 »

发表于 分类于 Valine：

本片对于数据结构自行设计的ADT，以及常用的算法、性质做一个记录。

顺序表

const int MAXLISTSIZE = 100; //默认最大长度
template<class ElemType>
class SqList{
  	private:
    ElemType *elem;   // 存储空间基址
    int length;               // 当前长度
    int listsize;        // 允许的最大存储容量(以sizeof(ElemType)为单位
    public:
    //初始化顺序表
    SqList(int ms = MAXLISTSIZE)
    {
        elem = new ElemType[ms];
        length = 0;
        listsize = ms;
    }
    //删除顺序表
    ~SqList(){delete [] elem;}
    //将顺序表置为空表
    void ListClear( )
    {
        delete [] elem;
        elem = new ElemType[length];
        length = 0;}
    //返回顺序表的长度
    int ListLength() const {return length;}
    //设置顺序表的长度
    bool SetListLength(int len)
    {
        if(len <= listsize && len >= length)
        {
            length = len;
            return 1;
        }
        ElemType *t;
        t = new ElemType[len];
        for(int i = 0; i < min(length,len); ++i)
            t[i] = elem[i];
        length = len;
        delete [] elem;
        elem = t;
        return 1;
    }
    //判断顺序表是否为空表
    bool ListEmpty() const
    {
        return !length;
    }
    //判断顺序表是否为满表
    bool ListFull() const
    {
        return listsize == length ? 1 : 0;
    }
    //用e返回顺序表标号为i的元素
    ElemType GetElem(int i) const
    {
        return elem[i];
    }
    //返回元素e的标号，否则返回-1
    int GetElemIndex(ElemType e) const
    {
        for(int i = 0; i < length; i++)
        {
            if(elem[i] == e)
                return i;
        }
        return -1;
    }
    //用e设置顺序表标号为i的元素
    bool SetElem(int i, ElemType e)
    {
        if(i < 0 || i >= length)
            return 0;
        elem[i-1] = e;
        return 1;
    }
    //在顺序表的标号为pos的元素之前插入e元素
    bool ListInsert(ElemType e, int pos)
    {
        if(pos < 0 || pos > length)
            return 0;
        if(listsize - length > 0)
        {
            for(int i = length; i >= pos; i--)
            {
                elem[i] = elem[i-1];
            }
            elem[pos] = e;
            length ++;
        }else
        {
            ElemType *t;
            length ++;
            t = new ElemType[length];
            for(int i = 0; i < length; ++i)
                t[i] = elem[i];
            delete [] elem;
            elem = t;
            for(int i = length; i > pos; i--)
                elem[i] = elem[i-1];
            elem[pos] = e;
        }
        return 1;
    }
    //在顺序表的标号为pos的元素之前插入e元素
    bool Push(ElemType e)
    {
        if(listsize - length > 0)
        {
            elem[length] = e;
            length ++;
        }else
        {
            ElemType *t;
            length ++;
            t = new ElemType[length];
            for(int i = 0; i < length; ++i)
                t[i] = elem[i];
            delete [] elem;
            elem = t;
            elem[length-1] = e;
        }
        return 1;
    }
    //删除最后一个元素
    void Pop()
    {
        if(length > 0)
            length --;
    }
    //删除顺序表下表为pos的元素
    bool ListDelete(int pos)
    {
        if(pos < 0 || pos > length)
            return 0;
        if(length > 0)
            length--;
        else
            return 0;
        for(int i = pos; i < length; ++i)
            elem[i] = elem[i+1];
        return 1;
    }
    //compare函数，用来判断a和b是否相等
    bool compare(ElemType a, ElemType *b)
    {
        return a == *b;
    }
    //按指定条件查找
    int LocateElem(ElemType e)
    {
        for(int i = 0; i < length; ++i)
        {
            if(elem[i] = e)
                return i;
        }
        return -1;
    }
    //      //逆置顺序表
    //      void Invert(int, int);
    //返回线性表给定数据元素的前驱数据元素的值
    bool PriorElem(ElemType cur_e, ElemType &pri_e)
    {
        for(int i = 0; i < length; i++)
        {
            if(elem[i] == cur_e)
            {
                if(i > 0)
                {
                    pri_e = elem[i-1];
                    return 1;
                }else
                {
                    return 0;
                }
            }
        }
        return 0;
    }
    //返回线性表给定数据元素的后继数据元素的值
    bool NextElem(ElemType cur_e, ElemType &nex_e)
    {
        for(int i = 0; i < length; i++)
        {
            if(elem[i] == cur_e)
            {
                if(i < length-1)
                {
                    nex_e = elem[i+1];
                    return 1;
                }else
                {
                    return 0;
                }
            }
        }
        return 0;
    }
    //将线性表中的元素前移一次
    void MoveForward()
    {
        ElemType t = elem[0];
        for(int i = 0; i < length-1; i++)
            elem[i] = elem[i+1];
        elem[length - 1] = t;
    }
    //打印元素
    void Print()
    {
        if(length == 0)
        {
            cout<<"NULL"<<endl;
            return;
        }
        for(int i = 0; i < length; ++i)
        {
            cout<<elem[i];
            if(i < length - 1)
                cout<<',';
        }
        cout<<endl;
    }
    //销毁线性表
    void ListDestroy()
    {
        delete [] elem;
        elem = NULL;
        length = 0;
        listsize = 0;
    }
    //      //遍历顺序表
    //      int ListTraverse() const;
};

链表

单链表

// 结点
template<class ElemType>
struct LinkNode
{
    ElemType data; //数据域
    LinkNode<ElemType> *next; //指针域
    LinkNode(LinkNode<ElemType> *ptr = NULL){next = ptr;} //构造函数，默认指针域为空，数据域没有初始化
    LinkNode(const ElemType &item, LinkNode<ElemType> *ptr = NULL) //构造函数，默认指针域为空，数据域初始化
    {
        next = ptr;
        data = item;
    }
};

//带头结点的单链表
template<class ElemType>
class LinkList
{
  private:
      LinkNode<ElemType> *head;   // 头指针
      LinkNode<ElemType> *tail;   // 尾指针
  public:
      //无参构造
      LinkList(){head = new LinkNode<ElemType>; tail = head;}
      //有参构造，给头节点数据域赋值
      LinkList(const ElemType &item){head = new LinkNode<ElemType>(item); tail = head;}
      //拷贝构造
      LinkList(LinkList<ElemType> &List);
      //析构
      ~LinkList(){ListDestroy();}
      //等于号重载
      LinkList<ElemType>& operator=(LinkList<ElemType> &List);
      //销毁链表
      void ListDestroy();
      //清空链表
      void ListClear();
      //返回链表的长度
      int ListLength() const;
      //判断链表是否为空表
      bool ListEmpty() const;
      //在首节点之前插入一个结点
      bool InsFirst(ElemType e);
      //在尾节点之后添加一个结点
      bool InsEnd(ElemType e);
      //获取链表头结点
      LinkNode<ElemType>* GetHead() const{return head;}
      //获取链尾结点
      LinkNode<ElemType>* GetTail() const{return tail;}
      //设置链表头结点
      void SetHead(LinkNode<ElemType> *p);
      //设置链尾结点
      void SetTail(LinkNode<ElemType> *p);
      //返回链表的第i个元素
      ElemType GetElem(int pos);
      //在链表的第pos个位置之前插入e元素
      bool ListInsert(int pos,ElemType e);
      //删除链表的首结点
      bool DelFirst();
      //表头插入法动态生成链表
      void CreateList_Head(int n, ElemType *A);
      //表尾插入法动态生成链表
      void CreateList_Tail(int n, ElemType *A);
      //删除链表的第pos个位置的元素
      ElemType ListDelete(int pos);
      //compare函数，用来判断两个链表是否相等
      bool compare(const LinkList<ElemType> &b);
      //按指定条件查找，返回指向第一个符合条件（=e）的元素的指针
      bool LocateElem(const ElemType &e, LinkNode<ElemType> *pos);
      //返回链表给定数据元素的前驱数据元素的值
      //bool PriorElem(ElemType cur_e, ElemType &pri_e);
      //返回链表给定数据元素的后继数据元素的值
      bool NextElem(LinkNode<ElemType> *p, ElemType &e);
      //遍历链表
      bool ListTraverse() const;
};

//拷贝构造
template<class ElemType>
LinkList<ElemType>::LinkList(LinkList<ElemType> &List){
  this->head = new LinkNode<ElemType>(List.head->data);
  LinkNode<ElemType> *p1 = this->head,*p2 = List.head;
  while(p2->next)
  {
    p1->next = new LinkNode<ElemType>(p2->next->data);
    p1 = p1->next;
    p2 = p2->next;
  }
  this->tail = p1;
}
//销毁链表
template<class ElemType>
void LinkList<ElemType>::ListDestroy()
{
    LinkNode<ElemType> *p = head, *t = p->next;
    while(p)
    {
        delete p;
        p = t;
        if(p) t = p->next;
    }
}
//重载赋值运算符
template<class ElemType>
LinkList<ElemType>& LinkList<ElemType>::operator=(LinkList<ElemType> &List)
{
  this->head = new LinkNode<ElemType>(List.head->data);
  LinkNode<ElemType> *p1 = this->head,*p2 = List.head;
  while(p2->next)
  {
    p1->next = new LinkNode<ElemType>(p2->next->data);
    p1 = p1->next;
    p2 = p2->next;
  }
  tail = p1;
  return *this;
}
//清空链表
template<class ElemType>
void LinkList<ElemType>::ListClear()
{
  ListDestroy(head->next);
  tail = head;
}
//返回链表的长度
template<class ElemType>
int LinkList<ElemType>::ListLength() const
{
  int length = 0;
  LinkNode<ElemType> *p = head;
  while(p->next)
  {
      p = p->next;
      length++;
  }
  return length;
}
//判断链表是否为空表
template<class ElemType>
bool LinkList<ElemType>::ListEmpty() const
{
  return head->next;
}
//在首节点之前插入一个结点
template<class ElemType>
bool LinkList<ElemType>::InsFirst(ElemType e)
{
  LinkNode<ElemType> *t = new LinkNode<ElemType>(e);
  t->next = head->next;
  head->next = t;
  return true;
}
//在尾节点之后添加一个结点
template<class ElemType>
bool LinkList<ElemType>::InsEnd(ElemType e)
{
  LinkNode<ElemType> *t = new LinkNode<ElemType>(e);
  tail->next = t;
  tail = t;
  return true;
}
//设置链表头结点
template<class ElemType>
void LinkList<ElemType>::SetHead(LinkNode<ElemType> *p)
{
  head = p;
}
//设置尾结点
template<class ElemType>
void LinkList<ElemType>::SetTail(LinkNode<ElemType> *p)
{
  tail = p;
}
//返回链表的第i个元素
template<class ElemType>
ElemType LinkList<ElemType>::GetElem(int pos)
{
  if(pos < 1)  //不合法数据返回头节点data
    return head->data;
  int num = 0;
  LinkNode<ElemType> *p = head;
  while(p->next)
  {
    num++;
    p = p->next;
    if(num == pos)
      return p->data;
  }
  return head->data; //不合法数据返回头节点data
}
//在链表的第pos个位置之前插入e元素
template<class ElemType>
bool LinkList<ElemType>::ListInsert(int pos,ElemType e)
{
  if(pos < 1)
      return false;
  int num = 0;
  LinkNode<ElemType> *p = head;
  LinkNode<ElemType> *t = new LinkNode<ElemType>(e);
  while(p->next)
  {

    num++;
    if(num == pos)
    {
      t->next = p->next;
      p->next = t;
      return true;
    }
    p = p->next;
  }
  return false;
}
//删除链表的首结点
template<class ElemType>
bool LinkList<ElemType>::DelFirst()
{
  if(!(head->next))
    return false;
  LinkNode<ElemType> *t = head->next;
  head->next = t->next;
  delete t;
  if(!head->next)
    tail = head;
  return true;
}
//表头插入法动态生成链表
template<class ElemType>
void LinkList<ElemType>::CreateList_Head(int n, ElemType *A)
{
  int m = n;
  while(n)
  {
    InsFirst(*(A+(m-n)));
    n--;
  }
}
//表尾插入法动态生成链表
template<class ElemType>
void LinkList<ElemType>::CreateList_Tail(int n, ElemType *A)
{
  int m = n;
  while(n)
  {
    InsEnd(*(A+(m-n)));
    n--;
  }
}
//删除链表的第pos个位置的元素
template<class ElemType>
ElemType LinkList<ElemType>::ListDelete(int pos)
{
  LinkNode<ElemType> *p = head, *t;
  while(--pos)
    p = p->next;
  t = p->next;
  p->next = t->next;
  if(!p->next)
    tail = p;
  ElemType res = t->data;
  delete t;
  return res;
}
//compare函数，用来判断a和b是否相等
template<class ElemType>
bool LinkList<ElemType>::compare(const LinkList<ElemType> &b)
{
  LinkNode<ElemType> *t = b.GetHead(), *p = head;
  while(p->next || t->next)
  {
    if(p->next->data != t->next->data)
      return false;
    p = p->next;
    t = t->next;
  }
  return true;
}
//返回链表给定数据元素的后继数据元素的值
template<class ElemType>
bool LinkList<ElemType>::NextElem(LinkNode<ElemType> *p, ElemType &e)
{
  if(p->next)
    e = p->next->data;
  else
    return false;
  return true;
}
//遍历链表
template<class ElemType>
bool LinkList<ElemType>::ListTraverse() const
{
  LinkNode<ElemType> *p = head;
  while(p->next)
  {
    p = p->next;
    cout<<p->data;
    if(p->next)
      cout<<"->";
  }
  cout<<endl;
  return 1;
}

循环链表

// 结点
template<class ElemType>
struct LinkNode
{
    ElemType data,num; //数据域
    LinkNode<ElemType> *next; //指针域
    LinkNode(LinkNode<ElemType> *ptr = NULL){next = ptr;} //构造函数，默认指针域为空，数据域没有初始化
    LinkNode(const ElemType &item, LinkNode<ElemType> *ptr = NULL) //构造函数，默认指针域为空，数据域初始化
    {
        next = ptr;
        data = item;
        num = 0;
    }
};

//带头结点的单链表
template<class ElemType>
class LinkList
{
  private:
      LinkNode<ElemType> *head;   // 头指针
      LinkNode<ElemType> *tail;   // 尾指针
  public:
      //无参构造
      LinkList(){head = new LinkNode<ElemType>; tail = head;}
      //有参构造，给头节点数据域赋值
      LinkList(const ElemType &item){head = new LinkNode<ElemType>(item); tail = head;}
      //拷贝构造
      LinkList(LinkList<ElemType> &List);
      //析构
      ~LinkList(){ListDestroy();}
      //等于号重载
      LinkList<ElemType>& operator=(LinkList<ElemType> &List);
      //销毁链表
      void ListDestroy();
      //清空链表
      void ListClear();
      //返回链表的长度
      int ListLength() const;
      //判断链表是否为空表
      bool ListEmpty() const;
      //在首节点之前插入一个结点
      bool InsFirst(ElemType e);
      //在尾节点之后添加一个结点
      bool InsEnd(ElemType e);
      //获取链表头结点
      LinkNode<ElemType>* GetHead() const{return head;}
      //获取链尾结点
      LinkNode<ElemType>* GetTail() const{return tail;}
      //设置链表头结点
      void SetHead(LinkNode<ElemType> *p);
      //设置链尾结点
      void SetTail(LinkNode<ElemType> *p);
      //返回链表的第i个元素
      ElemType GetElem(int pos);
      //在链表的第pos个位置之前插入e元素
      bool ListInsert(int pos,ElemType e);
      //删除链表的首结点
      bool DelFirst();
      //表头插入法动态生成链表
      void CreateList_Head(int n, ElemType *A);
      //表尾插入法动态生成链表
      void CreateList_Tail(int n, ElemType *A);
      //删除链表的第pos个位置的元素
      ElemType ListDelete(int pos);
      //compare函数，用来判断两个链表是否相等
      bool compare(const LinkList<ElemType> &b);
      //按指定条件查找，返回指向第一个符合条件（=e）的元素的指针
      bool LocateElem(const ElemType &e, LinkNode<ElemType> *pos);
      //返回链表给定数据元素的前驱数据元素的值
      //bool PriorElem(ElemType cur_e, ElemType &pri_e);
      //返回链表给定数据元素的后继数据元素的值
      bool NextElem(LinkNode<ElemType> *p, ElemType &e);
      //遍历链表
      bool ListTraverse() const;
};

//拷贝构造
template<class ElemType>
LinkList<ElemType>::LinkList(LinkList<ElemType> &List){
  this->head = new LinkNode<ElemType>(List.head->data);
  LinkNode<ElemType> *p1 = this->head,*p2 = List.head;
  while(p2->next)
  {
    p1->next = new LinkNode<ElemType>(p2->next->data);
    p1 = p1->next;
    p2 = p2->next;
  }
  this->tail = p1;
}
//销毁链表
template<class ElemType>
void LinkList<ElemType>::ListDestroy()
{
    LinkNode<ElemType> *p = head, *t = p->next;
    while(p!=head)
    {
        delete p;
        p = t;
        if(p) t = p->next;
    }
}
//重载赋值运算符
template<class ElemType>
LinkList<ElemType>& LinkList<ElemType>::operator=(LinkList<ElemType> &List)
{
  this->head = new LinkNode<ElemType>(List.head->data);
  LinkNode<ElemType> *p1 = this->head,*p2 = List.head;
  while(p2->next)
  {
    p1->next = new LinkNode<ElemType>(p2->next->data);
    p1 = p1->next;
    p2 = p2->next;
  }
  tail = p1;
  return *this;
}
//清空链表
template<class ElemType>
void LinkList<ElemType>::ListClear()
{
  ListDestroy(head->next);
  tail = head;
}
//返回链表的长度
template<class ElemType>
int LinkList<ElemType>::ListLength() const
{
  int length = 0;
  LinkNode<ElemType> *p = head;
  while(p->next)
  {
      p = p->next;
      length++;
  }
  return length;
}
//判断链表是否为空表
template<class ElemType>
bool LinkList<ElemType>::ListEmpty() const
{
  return head->next;
}
//在首节点之前插入一个结点
template<class ElemType>
bool LinkList<ElemType>::InsFirst(ElemType e)
{
  LinkNode<ElemType> *t = new LinkNode<ElemType>(e);
  t->next = head->next;
  head->next = t;
  return true;
}
//在尾节点之后添加一个结点
template<class ElemType>
bool LinkList<ElemType>::InsEnd(ElemType e)
{
  LinkNode<ElemType> *t = new LinkNode<ElemType>(e);
  tail->next = t;
  tail = t;
  tail->next = head;
  return true;
}
//设置链表头结点
template<class ElemType>
void LinkList<ElemType>::SetHead(LinkNode<ElemType> *p)
{
  head = p;
}
//设置尾结点
template<class ElemType>
void LinkList<ElemType>::SetTail(LinkNode<ElemType> *p)
{
  tail = p;
}
//返回链表的第i个元素
template<class ElemType>
ElemType LinkList<ElemType>::GetElem(int pos)
{
  if(pos < 1)  //不合法数据返回头节点data
    return head->data;
  int num = 0;
  LinkNode<ElemType> *p = head;
  while(p->next)
  {
    num++;
    p = p->next;
    if(num == pos)
      return p->data;
  }
  return head->data; //不合法数据返回头节点data
}
//在链表的第pos个位置之前插入e元素
template<class ElemType>
bool LinkList<ElemType>::ListInsert(int pos,ElemType e)
{
  if(pos < 1)
      return false;
  int num = 0;
  LinkNode<ElemType> *p = head;
  LinkNode<ElemType> *t = new LinkNode<ElemType>(e);
  while(p->next)
  {

    num++;
    if(num == pos)
    {
      t->next = p->next;
      p->next = t;
      return true;
    }
    p = p->next;
  }
  return false;
}
//删除链表的首结点
template<class ElemType>
bool LinkList<ElemType>::DelFirst()
{
  if(!(head->next))
    return false;
  LinkNode<ElemType> *t = head->next;
  head->next = t->next;
  delete t;
  if(!head->next)
    tail = head;
  return true;
}
//表头插入法动态生成链表
template<class ElemType>
void LinkList<ElemType>::CreateList_Head(int n, ElemType *A)
{
  int m = n;
  while(n)
  {
    InsFirst(*(A+(m-n)));
    n--;
  }
}
//表尾插入法动态生成链表
template<class ElemType>
void LinkList<ElemType>::CreateList_Tail(int n, ElemType *A)
{
  int m = n;
  while(n)
  {
    InsEnd(*(A+(m-n)));
    n--;
  }
}
//删除链表的第pos个位置的元素
template<class ElemType>
ElemType LinkList<ElemType>::ListDelete(int pos)
{
  LinkNode<ElemType> *p = head, *t;
  while(--pos)
    p = p->next;
  t = p->next;
  p->next = t->next;
  if(!p->next)
    tail = p;
  ElemType res = t->data;
  delete t;
  return res;
}
//compare函数，用来判断a和b是否相等
template<class ElemType>
bool LinkList<ElemType>::compare(const LinkList<ElemType> &b)
{
  LinkNode<ElemType> *t = b.GetHead(), *p = head;
  while(p->next || t->next)
  {
    if(p->next->data != t->next->data)
      return false;
    p = p->next;
    t = t->next;
  }
  return true;
}
//返回链表给定数据元素的后继数据元素的值
template<class ElemType>
bool LinkList<ElemType>::NextElem(LinkNode<ElemType> *p, ElemType &e)
{
  if(p->next)
    e = p->next->data;
  else
    return false;
  return true;
}
//遍历链表
template<class ElemType>
bool LinkList<ElemType>::ListTraverse() const
{
  LinkNode<ElemType> *p = head;
  while(p->next != head)
  {
    p = p->next;
    cout<<'('<<p->num<<','<<p->data<<')';
    if(p->next != head)
      cout<<"->";
  }
  cout<<endl;
  return 1;
}

顺序栈

const int MAXLISTSIZE = 100;

template<class ElemType>
class SqStack{
private:
    ElemType *base;   // 栈底指针
    ElemType *top;   // 栈顶指针
    int maxSize;        // 允许的最大存储容量(以sizeof(ElemType)为单位
public:
    //初始化顺序栈
    SqStack(int ms = MAXLISTSIZE)
    {
        maxSize = ms;
        base = new ElemType[maxSize];
        top = base;
    }
    //删除顺序栈
    ~SqStack(){StackDestroy();}
    //将顺序栈置为空表
    bool StackClear( ){top = base;}
    //返回顺序栈的长度
    int StackLength() const {return top - base;}
    //设置顺序栈的长度
    //bool SetListLength(int len);
    //判断顺序栈是否为空栈
    bool StackisEmpty() const{ return top == base; }
    //判断顺序栈是否为满栈
    bool StackFull() const{ return base - top == maxSize;}
    //用e返回栈顶元素
    bool GetTop(ElemType &e) const
    {
        e = *(top-1);
    }
    ElemType GetTop() const
    {
        return *(top-1);
    }
    //入栈
    bool push(ElemType &e)
    {
        if(StackFull())
            return 0;
        *top = e;
        top++;
        return 1;
    }
    //顺序打印
    void print()
    {
        ElemType *p = base;
        while(p!=top)
        {
            cout<<*(p++);
        }
        cout<<endl;
    }
    //出栈
    bool pop(ElemType &e)
    {
        if(StackisEmpty())
            return 0;
        GetTop(e);
        top--;
        return 1;
    }
    ElemType pop()
    {
        if(StackisEmpty())
            return 0;
        ElemType t = GetTop();
        top--;
        return t;
    }
    //销毁顺序栈
    bool StackDestroy()
    {
        delete[] base;
        base = top = nullptr;
    }
    //遍历顺序栈
    void StackTraverse() const
    {
        for(ElemType* i = base; i != top; i++)
        {
            cout<<*i;
        }
    }
    //栈空间加倍
    bool DoubleSpace()
    {
        maxSize *= 2;
    }
    //比较栈是否相等
    bool isEqual(SqStack &t) const
    {
        if(t.StackLength() != this->StackLength())
            return false;
        for(ElemType *p1 = base, *p2 = t.base; p1 != top; p1++, p2++)
            if(*p1 != *p2)
                return false;
        return true;
    }
};
阅读全文 »

发表于 分类于 Valine：

Linux目录介绍

/bin存放二进制可执行文件(ls,cat,mkdir等)，常用命令一般都在这里；

/etc存放系统管理和配置文件；

/home存放所有用户文件的根目录，是用户主目录的基点，比如用户user的主目录就是/home/user，可以用~user表示；

/usr用于存放系统应用程序，比较重要的目录/usr/local 本地系统管理员软件安装目录(安装系统级的应用)。这是最庞大的目录，要用到的应用程序和文件几乎都在这个目录；

/usr/x11r6 存放x window的目录；

/usr/bin 众多的应用程序；

/usr/sbin 超级用户的一些管理程序；

/usr/doc linux文档；

/usr/include linux下开发和编译应用程序所需要的头文件；

阅读全文 »

发表于 更新于 分类于 Valine：

链表

提纯

记录一下我踩的坑吧…真够蠢的

  1. 没加abs，因为题目是绝对值…
  2. 删除元素以后pos应该–，或者删除的时候pos不++，传参的时候传pos+1
  3. 拿一个指针记录上一次的位置！
  4. 把其它题目adt复制过来了，忘了原题是个循环链表…
  5. new出来的数组没有初始化0…
template<class ElemType>
void Delete_Equal_Node( LinkList<ElemType> &A, int N )
{
    int *arr = new int[N+1];
    for(int i = 0; i < N; ++i)
        arr[i] = 0;
    LinkNode<ElemType> *p = A.GetHead()->next, *t;
    int pos = 0;
    while(p)
    {
        p = p->next;
    }
    p = A.GetHead()->next;
    while(p)
    {
        if(!arr[abs(p->data)])
        {
            arr[abs(p->data)] = 1;
            t = p;
            pos++;

        }else
        {
            p = t;
            A.ListDelete(pos+1);
        }
        p = p->next;

    }
}

有序归并

当b比a长的时候，要把b接在a后边，还要注意b本身也要提纯。。

void Merge_L_Order( LinkList<ElemType> &A, LinkList<ElemType> &B )
{
    LinkNode<ElemType> *pa = A.GetHead()->next, *pb = B.GetHead()->next, *t1=A.GetHead(), *t2;
    int pos = 1;
    while(pa)
    {
        if(!pb)
            break;
        if(pb->data < pa->data)
        {

            t2 = pb->next;
            A.ListInsertNode(t1, pb);
            pa = pb;
            pb = t2;

        }else if(pb->data == pa->data)
        {
            t2 = pb->next;
            delete pb;
            pb = t2;
        }else
        {
            pos ++;
            t1 = pa;
            pa = pa->next;
        }
    }
    if(pb)
        A.GetTail()->next = pb;
    while(pb && pb->next)
    {
        if(pb->next->data == pb->data)
        {
            t1 = pb->next;
            pb->next = t1->next;
            delete t1;
        }else
        {
            pb = pb->next;
        }
    }
    if(pb)
        A.SetTail(pb);
    delete B.GetHead();
    B.GetTail()->next = NULL;
}
阅读全文 »

发表于 更新于 分类于 Valine：

Vue核心

快速入门

入门

不写了，参考文档

引入vue.js开发版的时候，控制台会提示，这个提示可以关掉。

Vue.config.productionTip = false

el也可以通过`.$mount(‘#root’)挂载

后面用到了es6的简写，如果不了解es6语法的可以适当补充一下

注意事项

  1. vue不能挂在到html和body上。
  2. vue作用范围包括子元素
  3. 建议使用id选择器
  4. 一个vue实例对应一个容器，一对一
  5. 插值里可以写js表达式，一个表达式可以生成一个值（变量，运算，三元，函数…）
  6. data里面写多个同名属性，会覆盖，只有最后一个有用。
  7. methods里面的最好不要写箭头函数，否则会导致this从vue变成了window。
阅读全文 »

发表于 更新于 分类于 Valine：

基础配置

  1. 服务端口默认3306

  2. 安装的时候选择自动添加path

  3. 编码格式utf8

  4. windows启动服务

    net start 服务名称（mysql）
    net stop 服务名称

登录

  1. 首先确保mysql服务已经打开，不确定话net start mysql试试

  2. mysql -uroot -pxxxx

    xxxx为你的密码，也可以不显示密码登录

    mysql -uroot -p

    然后输入密码（此时密码以*显示）即可登录。

密码重置（8.0.23）

网上老的教程可能已经过时，8.0以上不支持mysqld --skip-grant-tables

  1. 打开命令窗口cmd，输入命令：net stop mysql，停止MySQL服务，

  2. 开启跳过密码验证登录的MySQL服务，输入命令，然后不要关闭此窗口，命令如下：

    mysqld --console --skip-grant-tables --shared-memory

  3. 再打开一个新的cmd，无密码登录MySQL，输入登录命令：mysql -u root -p，然后回车即可

    1. 密码置为空，命令如下：

    use mysql

    update user set authentication_string='' where user='root';

    1. 退出，命令如下

      quit

  4. 关闭以-console --skip-grant-tables --shared-memory启动的MySQL服务（即关闭第一个打开的cmd窗口）

    1. 打开cmd，输入：net start mysql启动MySQL服务。

    2. 步骤4密码已经置空，所以无密码状态登录MySQL，输入登录命令：mysql -u root -p，然后回车即可登录

    3. 修改密码，如下：

      ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 你的密码';

  5. 验证更改后密码正确登录

  6. 输入quit，退出当前登录，输入登录命令：mysql -u root -p

  7. 输入密码，成功登录，到此，重置密码结束。

常用命令

以;结尾

show databases;

阅读全文 »