博客园_类菌体

分享一个Visual Studio 2010的皮肤：greendream

2012-05-01T18:46:00Z

回学校之前，每天晚上都在修改毕业设计和论文，弄的眼睛好痛，刚刚还听说在深圳春天十几天的时间里死去了十几个人，虽然只是听说，但是不知道是不是真实的，话说话来，我们地球人的身体越来越受到威胁，举个例子看看我以下写的你有多少个，证明这些已经影响到我们的身体健康了：

近视
月光族
喜欢Money
从不锻炼身体
一日三餐没有规律
路盲，没有方向感
搞不清自己的血型
有一颗狠宅的心
做事情都是三分钟的热度
经常午夜12点以后才睡觉

呵呵，话题扯远了，我主要想表达现在多爱惜自己的身体，好的身体是做好一切工作的必要前提。好了，今天发现的这个皮肤还是不错的，我贴出一点给大家看看，觉得好就去下载吧！

C# code：

HTML / ASP.NET (with CSS and Javascript)：

皮肤下载在这里：http://studiostyl.es/schemes/greendream

如何安装：

首先下载greendream

然后打开vs工具，选择菜单栏---工具如图

选择-导入和导出设置向导

下一步

建议先保存原有的设置

浏览皮肤所在

然后点击完成，就Ok了。

希望对你的眼睛或者健康有帮助。

作者：类菌体
出处：http://www.cnblogs.com/bacteroid/
关于作者：在校学生
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接
如有问题，可以通过303323670@qq.com 联系我，非常感谢。

本文链接

分享一个分层架构音乐网站源码（第二版本）一步一步构造（三）：项目计划和安排

2012-04-19T19:03:00Z

前言

为了体现我也训练过，真正参与过软件开发，所以我给大家说一小段的往事，其实笔者在一年前就在课程培训当中做个案例，当时是老师组织班干划分小组进行培训，如今已经过了很长一段时间，回想起来当时培训时候的逼真样子，当时我也过了一把主管职位的瘾，只记得我们进行了面向过程的训练；然后是进行面向对象的训练，模拟软件开发的过程，如何在每一个阶段进行小组会议，制作文档，设计图纸，文档交换（交付给下一组进行下个阶段的训练），当时总结的学到很多东西，比如：面向过程训练时候，当时每个阶段训练的结果有，比如需求规格说明书，概要设计说明书，总体设计说明书，编码说明与调试文档，图纸有数据字典，数据流图，软件模块图，程序流程图等等；面向对象训练的时候，当时每个训练的结果有，比如需求规格说明书，概要设计说明书，总体设计说明书，编码说明与调试文档，图纸有用例图，交互图，类图，活动图等等；为了体现真实性，我贴出几张图：

好了，要是那位朋友想多了解我们当时培训信息的，可以直接和我聊，呵呵！现在回到我这次的主题是项目计划和安排

任务名称

本次的任务主要是针对天籁音乐网站，所以我给他起的任务名称为天籁音乐网站项目计划和安排

任务描述

编写天籁音乐网站用于协调所有项目计划编制的文件，指导项目执行和控制的文件，内容包括：

项目划分的各个实施阶段
每个阶段的工作重点和任务是什么
完成本阶段工作和任务的人力。资源需求，时间期限（当然这个和我我写博客没有关系）
阶段工作和任务的成果形式
项目实施过程中对风险，疑难，其他不可预见的因素的处理机制
各任务组及开发人员之间的组织，协调关系等等

任务分析

我就根据《GB8567-88计算机软件产品开发文件编制指南》中项目开发计划的需求，结合实践情况得到的《项目计划书》主要内容如下索引：

项目概述
项目目标
产品目标与范围
假设与约束
项目工作范围
应交付成果
需完成的软件
需提交用户的文档
需提交内部的文档
应当提供的服务
项目开发环境
项目验收方式与依据

项目团队组织

组织结构
人员分工
协作与沟通
内部协作
外部沟通

实施计划

支持条件

预算（可选）

关键问题

专题计划要点

当然这些内容提纲只是作为我们在软件产品开发当中的泛本，这个有助于我们完成天籁音乐网站的编写

项目描述

这次开发天籁音乐网站是我重构第一版本以后的产品，他应该是一个具有灵活性和系统性，可扩充性和可维护性强，可以不断延续发展的网站软件产品，所以他的内部有：

在对音乐网站总体业务进行分析的基础上进行提炼，充分考虑系统性和可扩充性
遵循各种国标，国家及行业标准（汗，有点夸张）
综合考虑外部系统的接口
网站应该实用，友好，稳定，可靠，可移植性好，可扩充性好
方便实施和维护，减轻客户化工作
建立新型业务与技术模型，注重业务流程的重用性与可定制性，用户可以根据自身的需求方便定义，采用三层框架的内核并以内核为框架，采用面向组件对象的方式，建立面向组件为基础的结构化的综合应该体系，使得实现应用对象的重组更加灵活，降低维护管理的成本，同时基于设计模式，缓存机制，面向接口技术的应该使得这个体系更加灵活和便于扩充，使得他真正体现出“平台”的效果

主要参与人员

我把参与该项目计划安排的人员如图所示：

主要参与人员（名称有点俗，见怪了）

交付成果

1、程序

2、文件

3、服务

4、非移交产品

验收标准

**验收标准**
系统名称	验收方式	验收依据
天籁音乐网站	交付后验收	需求规格说明书

完成项目的最迟期限

**交付期限**
系统名称	期限
天籁音乐网站	2020年12月25日

实施计划

1、工作任务分解和人员分工

**工作任务分解和人员分工**
系统名称	工作	所需人员	所需天数	标志性事件（交付物）
	需求分析	2	3	需求规格说明书
天籁音乐网站	系统设计	2	3	概要设计说明书
	子系统设计	4	5	详细设计说明书
	系统编码与实现	4	15	可测试代码
	系统测试	4	3	测试报告
	系统实施与维护，使用培训	4	3	用户手册、验收报告

2、前期项目计划表

可以用Project软件制作一个前期的项目计划表以及甘特图，随着开发工作的进行深入，该项目计划表会不断被加以细化和补充，这个图先省，等我有时间在补充

3、预算的问题

预算
项目	工作量	价格	金额（万）
天籁音乐网站	4.0/月	每人月5000元	1.8

网站运行软硬件环境

1、硬件环境

在初始化访问压力不大的时候，Web服务器和数据库服务器可以可以使用一台机器就可以了，但是当你访问量大的时候，可以采取附加均衡，分布式服务的手段，把web服务器和数据库服务器部署在不同的机器上（当作参考）如下：

配件	配置
CPU	至强服务器CPU*2
内存	4GB
硬盘	146GB*3SAS硬盘Raid5

2、软件环境

操作系统	MS Window Server 2003/2008标准版或者企业版
数据库	MS SQL Server 2005 标准版或者企业版

3、网络环境

环境	备注
100MB网络接入	建议在校园主干网上，若需对校外发布，则需要公网IP
防火墙	建议采用硬件防火墙，可以考虑使用现有资源

总结

本文通过针对该音乐网站的项目的计划和安排为参考延伸出来一个软件项目的计划和安排，可以得出项目计划和安排是一个软件项目进去系统实施的启动阶段，通过该工作环节可以确定详细的项目实施范围，定义递交的工作成果，评估实施过程的风险，制定项目实施的时间计划，成本，预算等等。从而理解软件项目计划的作用与组成元素，下次接着系统设计！

本文链接

分享一个分层架构音乐网站源码（第二版本）一步一步构造（二）：用户需求的分析与处理

2012-04-15T18:42:00Z

前言

为了开发出真正的满足用户需求的软件产品，首先必须知道用户需求，这样子对软件需求的深入理解是软件开发工作获得成功的前提条件，所以不管我们在设计阶段和编码阶段做的多好，但是没有真正满足用户的需求，只会让用户失望，让程序员苦恼；鉴于本文是关于一个简单的音乐网站，架构业务不是很多（在之前的基础上加上了评论，分类等等），当然需求分析的基本任务就是准确低回答“系统必须做什么？”所以在开发软件初级阶段一定要分析好，如何回答提炼出系统的功能。本文的主要内容：

前言
需求分析任务
针对网站收集用户需求
总结

需求分析的任务

这个过程可以根据一般音乐网站的特点与基本流程以及用户需求调查报告通过理解需求阶段的目标，为业务上下文和网站功能建模，在完整的用例模型中记录网站的需求，完成需求模型报告，最后依据需求模型报告进行产品需求规格说明书撰写

确定对系统的音乐网站的综合需求，可以从下面几点概述：

功能需求：指音乐网站提供的服务，比如会员注册，上传音乐，评论等等，通过需求分析可以知道音乐网站必须完成这些功能
性能需求：指的是网站要满足定时约束或者容量约束，这个可以从速度（响应的时间）、信息量速度、方面体现出来，比如播放音乐响应的时间，是否占据大内存
可靠性和可用性需求：是指网站定量上的可靠性，比如在多久时间内不出现播放不出音乐的故障，而可用性那就是备份的事情了，不可以没有用
出错处理需求：这个就是网站在出现错误的时候，此时可以提醒如何去响应，解决这种错误
接口需求：这个硬性上指的是他的环境通信，比如网站用户接口需求，硬件接口需求，有没有网络，浏览器，太大了不说了
约束：指的是在设计的或者实现这个网站的时候遵循的什么限制条件，比如网站前台符合w3c等
逆向需求：可以这样子觉得网站不应该实现什么
将来可能提出的需求：比如以后需求改变了，需求多几个功能，那你如何应对

针对网站收集用户需求

1、网站的背景和意义

关于我发布这个版本的背景和意义即：现在关于ASP.NE的音乐网站的源码例子还是蛮少的，拿来参考的可能没有采用分层或者没有采用设计模式和缓存思想，网站源码可以拿来当中初学者学习，当然在这个开发制作过程也有一下优点：

开发成本低
多用户可以拿来学习
网上开发性
简单符合音乐网站的表现力

该网站有前台和后台，前台可以浏览音乐网站的信息，播放音乐，评论，按类别和名称搜索音乐，分类查看音乐库，完成注册会员等等；后台可以分超级管理员和一般会员，权限不一样，操作也不一样，会员可以修改本身信息，上传音乐，删除音乐，修改音乐；超级管理员也同样可以完成类似功能。

2、网站业务流程如下：

3、用户需求调查问卷

具体的用户调查就不列出了，我主要把附录大致描述一下：

需求类型：

功能性：包括特性功能和安全
可用性：包括人员因素、用户界面的一致性，联机帮助和环境相关帮助、向导和代理、用户文档和培训材料
可靠性：需求考虑的可靠性有故障的频率/严重性，可恢复性，可预见性，准确性和平均故障时间
性能：规定了一下的参数，有速度，效率，可用性，准确性，吞吐量，响应时间，恢复时间和资源用途
可支持性：包括可测试性，可扩展性，可适应性，可维护性，兼容性，可配置性，可服务性
设计需求：规定或者约束了网站的设计
实施需求：规定和约束了网站的编码和构建，如所需的标准，实施的语言，数据库完整性，操作环境等
接口需求：网站之间交互操作的外部项
物理需求：网站的物理特征

4、用户需求

用户可以匿名浏览网站信息播放音乐，评论，但只有登录会员才可以上传音乐
用户可以按类别查看音乐，播放
提供快速的检索功能
采用会员制，会员采用唯一的标识标识身份，会员可以修改个人信息，管理员可以对会员信息进行整理
管理员可以创建音乐类型
管理员可以添加音乐和修改音乐属性
网站具有友好型和易操作性
网站具有安全性和保密性

5、需求分析人员分析用户需求

第一步可以细化分析用户需求

第二步可以撰写需求规格说明书

第三步可以进行需求确认，即：

需求建模和撰写需求规格说明书

需求建模：

功能目标：如图所示

用例图：如图

业务对象模型：如下

撰写需求规格说明书：

总结

本文通过用户需求的分析和处理，理解该网站需求阶段的目标，并给业务上下文和网站功能建模，在完整的用例模型中记录了网站的需求！

本文链接

分享一个分层架构音乐网站源码（第二版本）一步一步构造（一）：综述

2012-04-13T01:14:00Z

前言

记得差不多一年前，我分享了【分享一个分层架构音乐网站源码（使用了ASP.NET+sql server 2005 无限下载）】网友或多或少给我留言，咨询，很荣幸可以解答，前一段时间有部分网友拿来参考作为毕业设计，在QQ留言问我，类似音乐播放系统之类的，连论文题目都做好了，就是拿我的代码做终稿，然后让我详细说明一下，需求以及设计或者采用技术多注意的地方，多谢你们，其实上一个版本存在着很多问题，比如，播放页面，歌词显示，用户体验，以及功能拓展等等都存在部分少许问题，现在构造的这个版本需要在这些方面都有所改善。当然这次在分层架构和设计模式方面和页面缓存和url重写都有涉及，所以初学者有必要了解一下这方面的知识比较好，我打算按照软件系统开发的流程来一步一步构造这个第二版的音乐网址系统，虽然业务太少，不过主要体现软件开发构造思想，所以希望初学者喜欢！

给自己打个广告：就快毕业了，考研考不好，想着毕业工作的事情就心烦，只想为自己在这段时间想找一份互联网公司的工作（可以做管理，可以做前端开发，可以做后台开发），如果你们觉得我可以的话，可以留言或者和我沟通，我肯定会倍感兴奋和感谢！

综述

得益于http://www.cnblogs.com/leoo2sk/博主的分层架构实践的参考，我自己也把今年的毕设设计完成了，主要是采用博主的分层架构思想和设计模式+反射机制+缓存机制案例才能很快编码完成，往后有时间可以发布来分享一下这段时间做毕设的心得体会，当然这次版本的部分代码以及思想参考也来自于他的博客，在这里谢谢了！

这次版本给大家看看工程解决方案图：

12年毕设：（Finish by 2012年3月28日)

音乐网站：初步

参考软件开发流程，我把这次内容大概分为：

分享一个分层架构音乐网站源码（第二版本）一步一步构造（一）：综述

分享一个分层架构音乐网站源码（第二版本）一步一步构造（二）：用户需求的分析与处理

分享一个分层架构音乐网站源码（第二版本）一步一步构造（三）：项目计划和安排

4、系统设计

5、子系统设计（包括数据库设计）

6、首页信息显示

7、播放页信息显示

8、其他页面

.....(还有待想)

总结

虽然看起来可能不太难，或者是对于这类型的项目太简单了，其实选这个源码再次做重构也是处于毕设关于重构和设计模式的理论学习，当然也是考虑到现在网上关于音乐网站的代码参考还是蛮少的，所以再次激起我在好好复习一下分层架构和设计模式，希望在这段时间一边学习一边做记录,当然在写的过程中有些部分可能是要不断补充和完善，考虑到笔者还是个学生，所以在这里要是说的不对，希望得到体谅，希望得到你们的指点，相信这个过程是非常需要的！

本文链接

分享我收藏的SQL知识以及SQL语句简单实践通俗易懂

2012-04-09T15:30:00Z

小引

首先说明,这个笔者2年前学习SQL的遗漏下来的笔记,由于参加完腾讯的笔试,内容比较偏向数据机构和编译以及数据库,刚好要换台本本,心里不想把它弄死在硬盘里,觉得蛮好的,所以把它都分享了,主要第一部分简单介绍SQL语言,第二部分简单实践,纯属于简单类似的记录,通俗易懂,希望对学习数据库原理的同学有一定的帮助!

主要内容:

综述
简单实践

综述

大家都知道SQL是结构化查询语言，是关系数据库的标准语言，是一个综合的，功能极强的同时又简洁易学的,它集级数据查询（Data Quest），数据操纵（Data Manipulation），数据定义（Data Definition），数据控制（Data Control）于一体即：

SQL语言包含4个部分：

※ 数据定义语言(DDL)，例如：CREATE、DROP、ALTER等语句

※ 数据操作语言(DML)，例如：INSERT（插入）、UPDATE（修改）、DELETE（删除）语句

※ 数据查询语言(DQL)，例如：SELECT语句

※ 数据控制语言(DCL)，例如：GRANT、REVOKE、COMMIT、ROLLBACK等语句

SQL语言包括三种主要程序设计语言类别的语句：数据定义语言(DDL)，数据操作语言(DML)及数据控制语言(DCL)

现在说说SQL的几个基本概念：

基本表：本身独立存在的一个表，一个关系就是对应一个基本表

内模式：存储文件的逻辑结构组成了关系数据库的内模式

视图：从一个或几个基本表导出的表，他是一个虚表

简单实践

建一个数据库，包含“学生表”，“教员表”，“任课表”，“专业表”，“课程表”，“学生个人情况表”，“成绩表”七张表

下面几个表是我们这次实践要用到的表：用SQL语句建表：

建立一个数据库cc

1 create database cc;
2 use cc;

创建一个名为tb_student的学生表

1 create table tb_student(
2 stunum char(7) primary key, --学号
3 stuname char(8) not null, --姓名
4 stusex char(2) check(stusex in('女','男')), --性别
5 stubirthday smalldatetime not null, --学生出生日期
6 stuspec char(6)not null, --专业
7 stuscore numeric(4,1), --入学成绩
8 stuloan char(2) check(stuloan in ('是','否'))not null, --是否贷款
9 )

创建一个名为tb_teacher的教师表

1 create table tb_teacher(
2
3 教师代号 char(7) primary key, --教师代号
4 姓名 char(8) not null, --教师名字
5 性别char(2) check(teasex in('女','男')), --教师性别
6 出生年月 datetime not null, --教师出生日期
7 职称 char(6), --职称
8 )

创建一个名为tb_renke的任课表

1 create table tb_renke(
2 课程代号 char(5), --课程代号
3 教师代号 char(7), -- 教师代号
4 )

创建一个名为tb_major的专业表

1 create tabletb_major(
2 专业名称 char(8) primary key, --专业名称
3 负责人 char(8) not null, --负责人
4 )

创建一个名为tb_course的课程表

1 create table course(
2 课程代号 char(5)primary key, --课程代号
3 课程名 char(14) not null, --课程名
4 周学时 int, --周学时
5 学分 int, --学分
6 )

创建一个名为tb_studentinfo的学生个人情况表

1 create table tb_studentinfo(
2 学号 char(7), --学号
3 身份证 char(15) unique, --身份证号码
4 籍贯 char(8), --籍贯
5 家庭住址 text, --家庭住址
6 电话 char(30), --电话
7 特长 text, --特长
8 奖励 text, --奖励
9 处分 char(100), --处分
10 )

创建一个名为tb_grade的成绩表

1 create table tb_grade(
2 学号 char(7), --学号
3 课程代号 char(5), --课程代号
4 平时 numeric(3,1), --平时
5 期中 numeric(3,1), --期中
6 期末 numeric(3,1), --期末
7 )

现在向每一张表插入记录

给学生表tb_student插入数据

1 insert into tb_student values('9607039','邓盈莹','女','1978-6-6','外贸',666.6,'是');
2 insert into tb_student values('9907002','倪雯娴','女','1981-4-1','外贸',641.4,'是');
3 insert into tb_student values('9801055','赵东','男','1979-11-9','中文',450,'否');
4 insert into tb_student values('9902006','和音','女','1982-6-19','数学',487.1,'否');
5 insert into tb_student values('9704001','克敏敏','女','1978-7-22','物理',463,'否');
6 insert into tb_student values('9603001','申强','男','1978-1-15','新闻',512,'是');
7 insert into tb_student values('9606005','迟大为','男','1976-9-3','化学',491.3,'否');
8 insert into tb_studentvalues('9803011','欧阳小娟','女','1981-8-11','新闻',526.5,'否');
9 insert into tb_student values('9908088','毛杰','男','1982-1-1','计算机',622.2,'否');
10 insert into tb_student values('9608066','康红','女','1979-9-7','计算机',596.8,'是');
11 insert into tb_student values('9805026','夏天','男','1980-5-7','历史',426.7,'否');
12 insert into tb_student values('9702033','李力','男','1979-7-7','数学',463.9,'否');

给教师表tb_teacher插入数据

1 insert into tb_teacher values('20222','于朵','女','1962-6-19','副教授');
2 insert into tb_teacher values('20406','张建','女','1946-7-16','教授');
3 insert into tb_teacher values('10429','蒋成功','男','1959-3-12','副教授');
4 insert into tb_teacher values('10616','万年','男','1945-9-1','教授');
5 insert into tb_teacher values('20626','孙乐','女','1971-12-15','讲师');
6 insert into tb_teacher values('10803','李铁','男','1958-9-22','副教授');
7 insert into tb_teacher values('10812','米粟','男','1960-1-3','副教授');
8 insert into tb_teacher values('11015','柴淮','男','1973-8-26','讲师');
9 insert into tb_teacher values('11107','方华','女','197**-6','讲师');
10 insert into tb_teacher values('20836','张静','女','1974-11-15','讲师');
11 insert into tb_teacher values('10101','高树声','男','1940-12-5','教授');
12 insert into tb_teacher values('10312','巩文','男','1959-3-17','副教授');
13 insert into tb_teacher values('20506','吴燕','女','1947-10-6','教授');
14 insert into tb_teacher values('20701','沈菲菲','女','1960-6-18','副教授');
15 insert into tb_teacher values('10202','梁龙林','男','1948-6-18','教授');
16 insert into tb_teacher values('10428','李阳','男','1955-8-12','教授');
17 insert into tb_teacher values('10621','鲁师','男','1943-11-18','教授');
18 insert into tb_teachervalues('10809','邓为民','男','1957-1-26','副教授');
19 insert into tb_teacher values('20106','姜晓红','女','1961-6-5','副教授');
20 insert into tb_teacher values('10131','付林','男','1968-9-11','讲师');
21 insert into tb_teacher values('10802','杨亮红','男','1941-5-23','教授');
22 insert into tb_teacher values('10223','周毅','男','1970-3-8','讲师');
23 insert into tb_teacher values('20255','孙莉莉','女','1975-9-12','讲师');
24 insert into tb_teacher values('20705','夏雪','女','1969-10-28','讲师');
25 insert into tb_teacher values('10712','南方','男','1975-9-13','讲师');
26 insert into tb_teacher values('10201','代顺达','男','1940-12-17','讲师');
27 insert into tb_teacher values('20301','高珊','女','1965-6-19','副教授');
28 insert into tb_teacher values('20319','林妮','女','1973-4-1','讲师');
29 insert into tb_teacher values('21025','张旗','女','1972-6-6','讲师');
30 insert into tb_teacher values('11117','韩明','男','1976-2-14','助教');
31 insert into tb_teacher values('10503','孙建国','男','1949-10-1','教授');
32 insert into tb_teacher values('10509','黄宁','男','1956-12-23','副教授');

给任课表tb_renke插入数据

1 insert into tb_renke values('21003','21025');
2 insert into tb_renke values('30211','20255');
3 insert into tb_renke values('30232','10201');
4 insert into tb_renke values('40711','10712');
5 insert into tb_renke values('40722','20701');
6 insert into tb_renke values('10101','20106');
7 insert into tb_renke values('11101','11107');
8 insert into tb_renke values('20511','10509');
9 insert into tb_renke values('10101','10131');
10 insert intotb_renke values('20534','10503');
11 insert into tb_renke values('10712','20705');
12 insert into tb_renke values('20115','20106');
13 insert into tb_renke values('10222','10223');
14 insert into tb_renke values('30412','10429');
15 insert into tb_renke values('40316','20319');
16 insert into tb_renke values('40612','20626');
17 insert into tb_renke values('20328','20301');
18 insert into tb_renke values('10812','10429');
19 insert into tb_renke values('20801','10803');
20 insert into tb_renke values('30802','10812');
21 insert into tb_renke values('11001','11015');
22 insert into tb_renke values('20113','10131');
23 insert into tb_renke values('30416','10428');
24 insert into tb_renke values('20327','10312');
25 insert into tb_renke values('20521','20506');
26 insert into tb_renke values('30213','10201');
27 insert into tb_renke values('11101','11117');
28 insert into tb_renke values('10715','20222');
29 insert intotb_renke values('20111','10101');
30 insert into tb_renke values('10218','10202');
31 insert intotb_renke values('30423','20406');
32 insert into tb_renke values('40331','20319');
33 insert intotb_renke values('40625','10616');
34 insert into tb_renke values('20314','20301');
35 insert into tb_renke values('10811','20836');
36 insert into tb_renke values('30819','10802');

给专业表tb_major插入数据

1 insert into tb_major values('化学','鲁师');
2 insert into tb_major values('计算机','邓为民');
3 insert into tb_major values('软件','李明');
4 insert into tb_major values('外贸','沈菲菲');
5 insert into tb_major values('数学','梁龙林');
6 insert into tb_major values('物理','李阳');
7 insert intotb_major values('物理学','王国玉');
8 insert into tb_major values('历史','吴燕');
9 insert into tb_major values('中文','高树声');
10 insert into tb_major values('新闻','巩文');

给课程表tb_course插入数据

1 insert into tb_course values('20511','世界近代史',4,4);
2 insert into tb_course values('10101','大学语文',2,2);
3 insert into tb_course values('20801','计算机基础(一)',4,3);
4 insert into tb_course values('10218','高等代数',4,4);
5 insert into tb_course values('11001','英语(一)',6,6);
6 insert into tb_course values('20113','外国文学',4,4);
7 insert into tb_course values('30416','接口技术',4,3);
8 insert into tb_course values('20327','报刊编辑学',2,2);
9 insert into tb_course values('20521','中国民族史',3,2);
10 insert into tb_course values('30213','数论',4,4);
11 insert into tb_course values('11101','体育',2,2);
12 insert into tb_course values('21003','英语(二)',4,4);
13 insert into tb_course values('10715','高等数学',4,4);
14 insert into tb_course values('20111','古代汉语',3,3);
15 insert into tb_course values('30802','计算机基础(二)',3,3);
16 insert into tb_course values('30423','电磁场理论',3,3);
17 insert into tb_course values('40331','传播心理学',2,2);
18 insert into tb_course values('40625','色谱学',2,2);
19 insert into tb_course values('20314','新闻学概论',2,2);
20 insert into tb_course values('10811','离散数学',2,2);
21 insert into tb_course values('30819','编译技术',4,4);
22 insert into tb_course values('20534','中国近代史',4,4);
23 insert into tb_course values('10712','政治经济学',3,3);
24 insert into tb_course values('20115','近代汉语',4,4);
25 insert into tb_course values('30211','概论统计',3,3);
26 insert into tb_course values('30232','数学分析',2,2);
27 insert into tb_course values('40711','国际投资学',2,2);
28 insert into tb_course values('40722','国际商法',2,2);
29 insert into tb_course values('30832','算法设计',4,4);
30 insert into tb_course values('10812','数字电路',4,4);
31 insert into tb_course values('10222','解析几何',2,2);
32 insert into tb_course values('30412','近代物理实验',3,2);
33 insert into tb_course values('40316','当代新闻史',2,2);
34 insert into tb_course values('40612','配位化学',3,3);
35 insert into tb_course values('20328','现代新闻报道',4,4);

给学生个人情况表tb_studentinfo插入数据

1 insert into tb_studentinfo values('9607039','530120169021101','安徽','江岸小区栋单元','5033228','唱歌,摔跤','被评为三好学生','');
2 insert into tb_studentinfo values('9907002','530120170060701','云南','江岸小区栋单元','5033226','跳舞，篮球','被评为三好学生','');
3 insert into tb_studentinfo values('9801055','530120171072501','湖北','白马小区栋单元','4133224','围棋','','');
4 insert into tb_studentinfo values('9902006','530120170122901','湖南','金星小区栋单元','3133218','象棋','被评为三好学生','');
5 insert into tb_studentinfo values('9704001','530120168121101','云南','静园小区栋单元','2133227','排球,足球','','');
6 insert into tb_studentinfo values('9603001','530120174050101','云南','江岸小区栋单元','5033219','唱歌,跳舞','被评为红花少年','');
7 insert into tb_studentinfo values('9606005','530120175040702','江苏','江岸小区栋单元','5033123','演讲','','');
8 insert into tb_studentinfo values('9803011','530120173021201','四川','白马小区栋单元','4133124','集邮','获集邮展三等奖','');
9 insert into tb_studentinfo values('9908088','530120172092801','四川','阳光小区栋单元','3133177','长跑足球','获省长跑第二名','作弊受处分');
10 insert into tb_studentinfo values('9608066','530120174092201','云南','阳光小区栋单元','3133222','摄影','获优秀作文奖','');
11 insert into tb_studentinfo values('9805026','530120174110901','贵州','阳光小区栋单元','3133189','围棋','获数学竞赛一等奖','');
12 insert into tb_studentinfo values('9702033','530120170080401','黑龙江','阳光小区栋单元','3148212','围棋','获数学竞赛三等奖','');

给成绩表tb_grade插入数据

1 insert into tb_grade values('9805026','20801',75,87,82);
2 insert into tb_grade values('9702033','30802',80,89,91);
3 insert into tb_grade values('9907002','11001',91,83,85);
4 insert into tb_grade values('9801055','20113',70,65,55);
5 insert into tb_grade values('9607039','40711',85,80,88);
6 insert into tb_grade values('9907002','10715',83,90,86);
7 insert into tb_grade values('9801055','20111',78,60,65);
8 insert into tb_grade values('9902006','10218',75,63,52);
9 insert into tb_grade values('9902006','11001',78,86,81);
10 insert into tb_grade values('9704001','30416',80,90,90);
11 insert into tb_grade values('9803011','20327',95,93,90);
12 insert into tb_grade values('9908088','11001',90,91,87);
13 insert into tb_grade values('9805026','20521',90,97,96);
14 insert into tb_grade values('9702033','30213',88,69,76);
15 insert into tb_grade values('9907002','11101',88,65,72);
16 insert into tb_grade values('9801055','21003',70,90,84);
17 insert into tb_grade values('9902006','11101',80,70,70);
18 insert into tb_grade values('9803011','21003',78,84,82);
19 insert into tb_grade values('9908088','11101',82,75,78);
20 insert into tb_grade values('9805026','21003',83,85,84);
21 insert into tb_grade values('9805026','20511',90,82,86);
22 insert into tb_grade values('9702033','30232',80,84,83);
23 insert into tb_grade values('9907002','10101',84,96,92);
24 insert into tb_grade values('9801055','20801',76,78,60);
25 insert into tb_grade values('9902006','10101',85,88,81);
26 insert into tb_grade values('9704001','30802',90,87,82);
27 insert into tb_grade values('9803011','20801',60,50,51);
28 insert into tb_grade values('9704001','30423',80,81,85);
29 insert into tb_grade values('9603001','40331',67,72,70);
30 insert into tb_grade values('9606005','40625',83,85,84);
31 insert into tb_grade values('9803011','20314',76,76,76);
32 insert into tb_grade values('9908088','10811',82,92,89);
33 insert into tb_grade values('9608066','30819',78,84,82);
34 insert into tb_grade values('9805026','20534',70,90,84);
35 insert into tb_grade values('9702033','30211',93,89,90);
36 insert into tb_grade values('9607039','40722',90,87,82);
37 insert into tb_grade values('9907002','10712',90,96,97);
38 insert into tb_grade values('9801055','20115',80,82,87);
39 insert into tb_grade values('9902006','10222',85,91,79);
40 insert into tb_grade values('9704001','30412',78,87,90);
41 insert into tb_grade values('9603001','30316',66,71,73);
42 insert into tb_grade values('9606005','40612',70,78,60);
43 insert into tb_grade values('9803011','20328',90,88,87);
44 insert into tb_grade values('9908088','10812',80,67,83);
45 insert into tb_grade values('9608066','30832',95,92,93);
46 insert into tb_grade values('9908088','10101',80,82,87);

下面进行数据查询：

(1)查询在78年12月31日之后出生的学生的学号和姓名

1 select学号,姓名from tb_student where 出生年月>'1979';
2 或是：
3 select学号,姓名from tb_student where 出生年月>cast('1978-12-31' as datetime);

(2)查询入学成绩大于500分的女同学和入学成绩大于600分的男同学的姓名

1 select姓名from tb_student where (入学成绩>500 and 性别='女')or(入学成绩>600 and 性别='男') ;

(3)查询家在江岸小区住的学生的姓名和家庭住址

1 select家庭住址,姓名from tb_studentinfo,tb_student where( 家庭住址like'江岸小区%')and (tb_studentinfo.学号=tb_student.学号) ;

(4)查询没有选修姜晓红老师所授课程的学生的学号

1 select学号from tb_student where 学号not in(select 学号from tb_grade,tb_teacher,tb_renke where tb_grade.课程代号=tb_renke.课程代号and tb_renke.教师代号=tb_teacher.教师代号and姓名='姜晓红' );

(5)查询各学生所选课的期末平均成绩，学生学号，姓名

1 select tb_student.姓名,tb_grade.学号,avg(期末) from tb_student,tb_grade where tb_student.学号=tb_grade.学号group by tb_student.姓名,tb_grade.学号;

(6)查询赵东所选修的课程的课程名及其学号、姓名

1 select tb_student.姓名,tb_grade.学号,课程名from tb_student,tb_grade ,tb_course where tb_grade.学号=tb_student.学号and tb_grade.课程代号=tb_Course.课程代号and姓名='赵东';

(7)查询由教授所任课的课程名

1 select课程名from tb_course,tb_teacher ,tb_renke where tb_course.课程代号=tb_renke.课程代号and tb_teacher.教师代号=tb_renke.教师代号and职称='教授'
2 或是：
3 select课程名from tb_course where 课程代号in (select 课程代号from tb_renke where 教师代号in(select教师代号from tb_teacher where 职称='教授'));

(8)统计没有贷款的学生的人数

1 select count(*)没贷款的人数from tb_student where 是否货款='false';

(9)查询每个科目平时、期中及期末三个成绩的平均成绩在80分以上的学生的学号

1 select学号成绩平均在分以上的学号from tb_grade group by 学号having avg(平时+期中+期末)>80;

（10）查询和毛杰同学所学专业一样的人的学号和姓名

1 select学号,姓名from tb_student where 专业in (select 专业from tb_student where 姓名='毛杰');
2

（11）查询期末成绩大于任何一个老师所教学生的期末成绩的学生姓名、选修课程号、成绩

1 select 姓名,课程代号,期末,tb_grade.学号from tb_grade,tb_student where tb_student.学号=tb_grade.学号and 期末>=all(select 期末from tb_grade);
2

（12）来了一位新同学，学号为9607001，省份证号为530120169021100

1 insert into tb_studentinfo (学号,身份证)values('9607001','530120169021100');
2 insert into tb_student(学号)values('9607001');

（13）将期末成绩在所有人的期末平均成绩以上的同学加10分

1 update tb_grade set 期末=期末+10 where 期末>(select avg(期末) from tb_grade);

（14）查询至少选修了付林老师所授所有课程的学生学号

Select学号from tb_grade x Where not exists (select * from tb_grade y Where 教师代号in( Select 教师代号from tb_teacher,tb_renke Where 姓名=’付林’and tb_teacher.教师代号=tb_renke.教师代号) And not exists(select *from tb_grade z Where z.课程代号=y.课程代号and z.学号=x.学号))

（15）统计每个老师授课的种数

1 select教师代号,count(*)课程种数from tb_renke group by tb_renke.教师代号;

（16）查询选修2门以上课程的学生学号及平均成绩（指各课程的期末成绩的平均成绩，只统计及格的课程），并按其平均成绩降序排列输出

1 select 学号,avg(期末)平均分from tb_grade where 期末> 60 group by 学号having count(*)>2 order by avg( 期末)desc;

（17）查询没有贷款的学生的学号

1 select学号没贷款的学号from tb_student where 是否货款='false';

(18)查询年龄最大的学生的学号和姓名

1 select学号,姓名from tb_student where 出生年月in ( select min(出生年月) from tb_student );

希望这些资料，能够对你有所帮助！

本文链接

Web开发之JavaScript（不断添加）

2012-03-27T12:39:00Z

小引

笔者认为web开发包括设计html，javascript,css，以及一种高级语言，比如c#,java等等，本文分为三部分，第一部分为简单介绍javascript，第二部分为理解ECMAscript，最后部分为为javascript基础，所以针对javascript笔者不是很深理解，只能从下面几点对他进行分析，另外文章是经过多次重构，不断添加，修改，要是不对，请指出，谢谢!主要内容为：

第一部分：简单介绍javascript

javascript
特点
javascript的实现
ECMAScript标准
javascript的发展

第二部分：理解ECMAscript

关于 ECMAScript
1、相同的句法
2、面向对象编程
3、函数也是对象
4、对象都有原型
5、数据构造方便
6、JavaScript对象符号（JSON）
7、Fifth Edition

第三部分：javascript基础

1、javascript语法
2、变量
3、数据类型
4、条件语句
5、循环语句
6、函数

参考

第一部分：

javascript介绍

JavaScript是一种基于对象(Object)和事件驱动(Event Driven)并具有安全性能的脚本语言。使用它的目的是与HTML超文本标记语言、Java 脚本语言（Java小程序）一起实现在一个Web页面中链接多个对象，与Web客户交互作用。从而可以开发客户端的应用程序等。它是通过嵌入或调入在标准的HTML语言中实现的。它的出现弥补了HTML语言的缺陷，它是Java与HTML折衷的选择.

特点

是一种脚本编写语言

JavaScript是一种脚本语言，它采用小程序段的方式实现编程。像其它脚本语言一样,JavaScript同样已是一种解释性语言,它提供了一个易的开发过程。它的基本结构形式与C、C++、VB、Delphi十分类似。但它不像这些语言一样，需要先编译，而是在程序运行过程中被逐行地解释。它与HTML标识结合在一起，从而方便用户的使用操作。基于对象的语言。JavaScript是一种基于对象的语言，同时以可以看作一种面向对象的。这意味着它能运用自己已经创建的对象。因此，许多功能可以来自于脚本环境中对象的方法与脚本的相互作用。

简单性

JavaScript的简单性主要体现在：首先它是一种基于Java基本语句和控制流之上的简单而紧凑的设计, 从而对于学习Java是一种非常好的过渡。其次它的变量类型是采用弱类型，并未使用严格的数据类型。

安全性

JavaScript是一种安全性语言，它不允许访问本地的硬盘，并不能将数据存入到服务器上，不允许对网络文档进行修改和删除，只能通过浏览器实现信息浏览或动态交互。从而有效地防止数据的丢失。

动态性的

JavaScript是动态的，它可以直接对用户或客户输入做出响应，无须经过Web服务程序。它对用户的反映响应，是采用以事件驱动的方式进行的。所谓事件驱动，就是指在主页(Home Page)中执行了某种操作所产生的动作，就称为“事件”(Event)。比如按下鼠标、移动窗口、选择菜单等都可以视为事件。当事件发生后，可能会引起相应的事件响应。

跨平台性

JavaScript是依赖于浏览器本身，与操作环境无关，只要能运行浏览器的计算机，并支持JavaScript的浏览器就可正确执行。从而实现了“编写一次,走遍天下”的梦想。实际上JavaScript最杰出之处在于可以用很小的程序做大量的事。无须有高性能的电脑，软件仅需一个字处理软件及一浏览器，无须WEB服务器通道，通过自己的电脑即可完成所有的事情。

综合

JavaScript 是一种新的描述语言，它可以被箝入到 HTML 的文件之中。 JavaScript语言可以做到回应使用者的需求事件 (如： form 的输入) ，而不用任何的网路来回传输资料，所以当一位使用者输入一项资料时，它不用经过传给伺服端 (server)处理，再传回来的过程，而直接可以被客户端 (client) 的应用程式所处理。

JavaScript 和 Java 很类似，但到底并不一样！ Java 是一种比 JavaScript 更复杂许多的程式语言，而 JavaScript 则是相当容易了解的语言。JavaScript 创作者可以不那麽注重程式技巧，所以许多 Java 的特性在 Java Script 中并不支援。

JavaScript实现

核心(ECMAScript)——JavaScript的核心ECMAScript描述了该语言的语法和基本对象
文档对象模型(DOM)——DOM描述了处理网页内容的方法和接口
浏览器对象模型(BOM)——BOM描述了与浏览器进行交互的方法和接口

ECMAScript标准

1997年，欧洲计算机制造商协会（ECMA）在JavaScript语言规范的基础上制定了ECMA-262标准，形成了网页脚本语言的规范。目前各主流浏览器均支持符合 ECMA-262标准的脚本语言。从此，Web浏览器就开始努力(虽然有着不同程度的成功和失败)将ECMAScript作为JavaScript实现的基础。尽管ECMAScript是一个重要的标准，但它并不是JavaScript唯一的部分，当然，也不是唯一被标准化的部分。实际上，一个完整的JavaScript实现是由以下3个不同部分组成的：

核心(ECMAScript)——JavaScript的核心ECMAScript描述了该语言的语法和基本对象
文档对象模型(DOM)——DOM描述了处理网页内容的方法和接口
浏览器对象模型(BOM)——BOM描述了与浏览器进行交互的方法和接口

目前所有的主流 Web 浏览器都支持 ECMA-262 第三版，即JavaScript 1.5版本，JavaScript 1.6-1.9只是ECMAScript (JavaScript on Gecko)升级至JavaScript 2.0的临时代号。

JavaScript的发展趋势

语言永远被当做工具，这一点从来都没有被改变过，以后也不会，语言是使用及和其他技术进行交流的方式和手段。例如，在Windows平台上，使用ADODB组件可以使JavaScript能处理支持SQL的数据库中的数据，使用FSO组件可以实现本地文件IO功能。这一切都说明了JavaScript位于应用开发的最顶端，其与低层技术的实现无关。

尽管平台技术不断发生变化，JavaScript仍将以不变的形式去使用平台提供的能力从而适应新的需求。未来的一段时间内，Web开发将是开发者众聚之地，也是JavaScript变得紫红的时代。

第二部分：

关于 ECMAScript

ECMAScript是ECMA(European Computer Manufacturers Association)制定的标准脚本语言（JAVAScript），目前推荐遵循的是ECMAScript 262（http://www.ecma.ch/ecma1/STAND/ECMA-262.HTM），首先ECMAScript规范描述了脚本编程语言应实现的基本内容如下：语法，数据和变量的类型，语句，关键字，保留字，运算符对象。所以符合ECMA-262规范的脚本编程语言必须实现该规范描述的所有的“类型、值、对象、属性、函数和程序语法及语义”，并且必须支持Unicode字符标准（UCS）。在此基础上，每个具体实现还可以指定“额外的类型、值、对象、属性和函数”，可以定义新的“程序和正则表达式语法”等。

1、相同的句法

首先是相同的句法，ECMAScript与其他流行的开放语言如c#,java，很类似，也就意味着其他语言风格看起来很想在ECMAScript上，比如

for(i = 0; i < a.length; i++) {
if (a[i] == x)
return i;
}

2、面向对象编程

ECMAScript的支持面向对象编程。在ECMAScript对象命名属性的值。对象的属性，函数可以被称为方法。

window.setTitle(user.name);

3、函数也是对象

ECMAScript的功能是对象和属性作为参数传递，可以存储，并作为结果返回。从函数式编程上，让你的函数和方法导入功能从他们的调用者那里得到一个简单而灵活的方式。

var recent = posts.sort(function(a, b) {
return (a.date > b.date ? -1 : 1);
}).slice(0, 10);

4、对象都有原型

受到本身程序语言的鼓舞，ECMAScript的对象继承原型对象的属性，基于原型的编程方便容易委托和灵活的覆盖对象的行为。

function Car() { }
Car.prototype = new Object();
Car.prototype.wheels = 4;
Car.prototype.color = "black";

function RaceCar() { }
RaceCar.prototype = new Car();
RaceCar.prototype.color = "red";

var vroom = new RaceCar();
vroom.wheels // 4
vroom.color // "red"

5、数据构造方便

ECMAScript中谈到许多常见的数据类型，这样可以节省时间，使你的程序更加易读速记。

Arrays

var digits = [3, 1, 4, 1, 5, 9];

Objects

var img = { width: 320, height:160, src: "images/es.png" };

正则表达式

var email = /([^@]*)@([^@]*)/;

6、JavaScript对象符号（JSON）

JSON是一种流行，轻量级的数据交换格式。 JSON是交互式的网页和网络服务，部分特别有用，因为它的语法是ECMAScript的语法的一个子集。

7、Fifth Edition

欧洲计算机制造商协会最近公布的新的ECMAScript标准第五版的最终候选人草案。一些新的功能包括：

1、提高标准库
2、标准化的JSON库
3、反射的getter和setter方法

第三部分：

1、javascript语法

1.1区分大小写

1.2弱项类型变量

var MyName="Xinzhu";
var Age =22;
var School="Gxnu";
var male=true;

1.3每项结尾分号可有，可无

1.4括号用于代码块

if(myName=="xinzhu"){
var age=22;
alert(age);
}

1.5javascript注释方式和c语言，java相同

2、变量

通过var关键字声明，如：var boy="xinzhu";这里要注意，首字符是字母，可以是大小写，下划线和$,剩下的可以是下划线，$,任意之母；变量名不可以是关键字或者保留字

3、数据类型

underfined,代表一切不可知的事情，可以将underfined赋值给任何变量或者属性，但是并不意味清除该变量，反而会因此多了一个属性

null,大概有这个概念，但是什么东西都没有

boolean,是和非，用于代码处理和控制代码流程

Number,线性的事物，大小写和次序分明，用于代码进行批量处理，可以控制代码迭代或循环

String,面向人们的理性事物，可以通过人机沟通的信息，代码可以理解人的意图

4、条件语句

比较操作符，逻辑操作符，if语句，switch语句，这些都会很简单不布列

5、循环语句

for, while, 太简单不布列

6、函数

javascript代码只有function一种形式，function就是函数的类型，用于完成一个事件的方法

格式：

function functionName([arg0,arg1,arg2......argN]){
statements
[returm[expression]]
}例子：

function sayHello(sName){
alert(“Hello”+sName);
}

sayName(xinzhu);//调用

参考

1、2012年3月编程语言排行榜：JavaScript语言的回归(1)

2、it公司面试手册

3、Standard ECMA-262：http://www.ecma-international.org/publications/standards/Ecma-262-arch.htm

4、ecmascript：http://www.ecmascript.org/index.php

5、《精通JavaScript.jQuery》

作者：类菌体
出处：http://www.cnblogs.com/bacteroid/archive/2012/03/27/2420123.html
关于作者：在校学生
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接
如有问题，可以通过303323670@qq.com 联系我，非常感谢。

本文链接

深入浅出设计模式基础(一)：总结&概述

2012-03-21T14:06:00Z

  小引
     最近在读<<大话设计模式>>,也刚好自己的本科毕业设计是有关设计模式的内容,所以把本书的大概的内容通读了一遍,希望在本书当作自己初认识设计模式的开始阶段,想必大家都听说宫保鸡丁如何制作吧,他是经过不断实践、思考、总结，最后得到最佳的烹饪方法,而程序设计也如此,有方法,程序不是有生俱来的,也不是一种发明,他是利用前人的经验，使解决问题不需要从头解决,设计模式也由此而生了,使得程序重用性和可维护性提高
主要内容：
设计模式概述
设计模式分类
设计模式作用
可重用性
简单工厂模式
策略模式
单一职责原则
开放-封闭原则
依赖倒转原则
装饰模式
代理模式
工厂方法模式
原型模式
模板方法模式
迪米特法则
外观模式
设计模式概述
      设计模式通常是对于某一类软件设计问题的可重用的解决方案，将设计模式引入软件设计和开发过程，其目的在于要充分利用已有的软件开发经验，优秀的软件设计师都知道，不是每个问题都有从头开始解决，而是复用以前曾经使用过的解决方案，每当找到一个好的方案了，就一遍一遍在使用，熟练了，设计模式的目标就是帮助人们利用成功软件的集体开放经验，做出更加好的解决产品。
　1、Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2、Adapter：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
   3、Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
   4、Builder：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
   5、Chain of Responsibility：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。
6、Command：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。
7、Composite：将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。
8、Decorator：动态地给一个对象添加一些额外的职责。就扩展功能而言，它比生成子类方式更为灵活。
9、Facade：为子系统中的一组接口提供一个一致的界面， F a c a d e模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
10、Factory Method：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到其子类。
11、Flyweight：运用共享技术有效地支持大量细粒度的对象。
12、Interpreter：给定一个语言, 定义它的文法的一种表示，并定义一个解释器, 该解释器使用该表示来解释语言中的句子。
13、Iterator：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
14、Mediator：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
15、Memento：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。
16、Observer：定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。
17、Prototype：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。
18、Proxy：为其他对象提供一个代理以控制对这个对象的访问。
19、Singleton：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
20、State：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。
21、Strategy：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。
22、Template Method：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
23、Visitor：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

设计模式分类

1、目的划分
创建型（Creational）：与对象创建有关
结构行(Structural)：处理类和对象的组合
行为型（Behavioral）:描述类或者对象如何交互和如何分配职责
2、范围划分
类模式：用于处理类和子类的关系，这些关系通过继承建立，是静态的，在编译的就已经确定下来了，当然几乎所有的模式都是使用继承机制，所以这里的“类模式”是指处理类间关系的模式
对象模式：用于处理对象间的关系，这些关系具有动态性，在运行的时候是可以变化的

范围\的                  创建型（Creational）                  结构行(Structural)：                                         行为型（Behavioral）
类                                 Simple Factory                        Adapter  (CLASS)                                      Interpereter
                                   Factory Method                                                                                        Template method
对象                              Abstract Factory                      Adapter(OBJECT)                               Chain of Responsibility
                                   Builder                                    Bridge                                                           Command
                                   Prototype                                Composite                                                    Iterator
                                   Singleton                                 Decorator                                                     Meditor
                                                                                 Facade                                                         Memento
                                                                                 Flyweight                                                     Observer

设计模式的作用

1、重用设计，自动带来代码重用
2、为设计代码共同的词汇，每个模式就是一个设计词汇，使交流更加方便
3、在开发文档的采用模式词汇可以容易理解你的想法，理解为什么这样子做，你多了些什么，使开发文档更加容易
4、可以使重构系统变得容易，可以确保开发正确的代码，并降低在设计或者实现当中出现错误的可能，同时可以重写其他应用程序提供更好的系统框架
5、正确使用设计模式可以节省大量时间

可重用性
       •传统的可重用性:包括代码复制粘贴;算法重用,如：排序算法等;数据结构重用如：队列、数组等
       •面向对象的可重用性:继承性实现概念和定义可重用,抽象类,接口,方法接口,标识接口,常量接口;多态性使实现和应用可重用;封装促进系统的可维护性

简单工厂模式
面向对象：可维护、可复用、可扩展、灵活性好
业务封装：业务逻辑与界面逻辑分开，让它们的耦合度下降
面向对象三大特性：封装，继承，多态
URL类图：注意前面的符号，“+”表示public，“-”表示 private，“#”表示protected
继承、接口、关联、聚合、合成（组合）、依赖
简单工厂模式可以解决对象的创建问题

策略模式
策略模式（Strategy）：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化不会影响到算法的客户。
策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。
策略模式的优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。
策略模式就是用来封装算法的，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。

单一职责原则
单一职责原则：就一个类而言，应该仅有一个引起它变化的原因。
如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职能的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。
软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离。
如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责。
开放-封闭原则
开放-封闭原则：就是说软件实体（类、模块、函数等等）应该可以扩展，但是不可修改。两个特征，对于扩展是开放的，对于更改是封闭的。
怎样的设计才能面对需求的改变却可以保持相对稳定，从而使得系统可以在第一个版本以后不断推出新的版本呢？
设计的时候，尽量让这个类足够好，写好了就不要去修改了，如果新需求来，我们增加一些类就完事了，原来的代码能不动则不动。
无论模块多么的“封闭”，都会存在一些无法对之封闭的变化。既然不可能完全封闭，设计人员必须对于他设计的模块应该对哪种变化封闭做出选择。他必须先猜测出最有可能发生的变化种类，然后构造抽象来隔离那些变化。
在我们最初编写代码时，假设变化不会发生。当变化发生时，我们就创建抽象来隔离以后发生的同类变化。
面对需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码。

依赖倒转原则
依赖倒转原则：抽象不应该依赖细节，细节应该依赖于抽象；针对接口编程，不要对实现编程。A. 高层模块不应该依赖低层模块。两个都应该依赖抽象。B. 抽象不应该依赖细节。细节应该依赖抽象。
里氏替换原则：子类型必须能够替换掉它们的父类型。
只有当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。
由于子类型的可替换性才使得使用父类类型的模块在无需修改的情况下就可以扩展。
依赖倒转其实可以说是面向对象设计的标志，如果编写时考虑的都是如何针对抽象编程而不是针对细节编程，即程序中所有的依赖关系都是终止于抽象类或者接口，那就是面向对象的设计，反之就是过程化的设计了。

装饰模式
动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
装饰模式是利用SetComponent来对对象进行包装的。
每个装饰对象的实现就和如何使用这个对象分离开了，每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中。
装饰模式是为已有功能动态地添加更多功能的一种方式。
当系统需要新功能的时候，是向旧的类中添加新的代码，在主类中加入了新的字段，新的方法和新的逻辑，从而增加了主类的复杂度；而装饰模式却提供了一个非常好的解决方案，它把每个要装饰的功能放在单独的类中，并让这个类包装它所要装饰的对象，因为，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择的、按顺序地使用装饰功能包装对象了。
优点：把类中的装饰功能从类中搬移去除，这样可以简化原有的类；有效地把类的核心职责和装饰功能区分开了。而且可以去除相关类中重复的装饰逻辑。

代理模式
代理模式：为其他对象提供一种代理以控制对这个对象的访问。
应用场合：第一、远程代理，也就是为了一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实（调用WebService）；第二、虚拟代理，是根据需要创建开销很大的对象。通过它来存放实例化需要很长的时间的真实对象（浏览网页，文字先下，图片后下，使用代理）；第三、安全代理，用来控制真实对象访问时的权限；第四、智能指引，是指当调用真实的对象时，代理处理另外一些事。
代理就是真实对象的代表。

工厂方法模式
简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品中的依赖。
工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类，而现在是修改客户端。

原型模式
原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需知道任何创建的细节。
一般在初始化的信息不发生变化的情况下，克隆是最好的办法。这既隐藏了对象创建的细节，又对性能是大大的提高。
MemberwiseClone()方法是这样，如果字段是值类型的，则对该字段执行逐位复制，如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其复本引用同一对象。
“浅复制”，被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象，所以我们需要把要复制的对象所引用的对象都复制一遍，这种方式就是“深复制”，深复制把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。

模版方法模式
我们既然用了继承，并且肯定这个继承有意思，就应该要成为子类的模板，所有重复的代码都应该要上升到父类去，而不是让每个子类都去重复。
当我们要完成在某一细节层次一致的一个过程或一系列步骤，但其个别步骤在更详细的层次上的实现可能不同时，我们通常考虑用模板方法模式来处理。
模板方法模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
模板方法模式是通过把不变行为搬移到超类，去除子类中的重复代码来体现它的优势。
模板方法模式就是提供了一个很好的代码复用平台。
当不变的和可变的行为在方法的子类实现中混合在一起的时候，不变的行为就会在子类中重复出现。我们通过模板方法模式把这些行为搬移到单一的地方，这样就帮助子类摆脱重复的不变行为的纠缠。

迪米特法则
迪米特法则也叫最少知识原则：如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的交互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。
首先强调的前提是在类的结构设计上，每一个类都应当尽量降低成员的访问权限。
迪米特法则其根本思想，是强调了类之间的松耦合。
类之间的耦合越弱，越有利于复用，一个处在弱耦合的类被修改，不会对有关系的类造成波及。
信息的隐藏促进了软件的复用。
外观模式
外观模式：为子系统的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这子系统更加容易使用
首先，在设计的时候，应该有意识低将不同的两个层分离，比如三层架构，就需要在数据访问层的和业务逻辑层，表现层的层与层之间建立外观的Facade
其次，在开发阶段，子系统往往因为不断的重构演化而变得越来越复杂，增加外观Facade可以提供一个简单的接口，减少他们之间的依赖
最后，维护一个遗留的大型系统时，可能这个系统已非常难以维护和扩展，你可以用外观模式，当然你在为新系统开发一个外观Facade类，来提供设计粗糙或者高度复杂的遗留代码的比较清闲简单的接口，让新系统与Facade对象交互，Facade与遗留代码交互所有复杂的工作

后记
      本文虽然没有详细介绍各种具体的设计模型，而是总结大话设计模式当中的结论性的语句，但是在各个大标题下也总结了与具体设计模式类似的方法，往后有时间在详细介绍常见的设计模式！主要参考：
C# 23种设计模式汇总：http://bbs.51aspx.com/showtopic-43429.html
大话设计模式
深入浅出设计模式

作者：类菌体
出处：http://www.cnblogs.com/bacteroid/archive/2012/03/21/2410704.html
关于作者：在校学生
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接
如有问题，可以通过303323670@qq.com 联系我，非常感谢。
本文链接

PHP简洁函数

2011-08-12T03:31:00Z

前言

笔者由于碰到用户多次修改页面，所以在麻烦的情况下，改用php完成技术开发，这篇文章主要记录PHP简洁函数，讲述PHP简单明了函数语法，适合人群为对开源社区感兴趣，对php感兴趣，有一点时间了解下php，希望对读者带来快乐!

1、与mysql相关

mysql_connect

建立一个与MySQL服务器的连接

语法

resource mysql_connect(string server[,string usingname[,string password[, bool new_link[,int client_flags]]]])

eg:

$DB_HOST =”localhost”;

$DB_LOGIN =”root”;

$DB_PASSWORD =” 123456”;

$conn=mysql_connect($DB_HOST,$DB_LOGIN,$DB_PASSWORD);

mysql_data_seek

将内部查询指针移动至查询行上

语法

bool mysql_data_seek(resource result_indetifier,int row_number)

eg:

$DB_HOST =”localhost”;

$DB_LOGIN =”root”;

$DB_PASSWORD =”123456”;

$DB_NAME =”flag”;

$conn=mysql_connect($DB_HOST,$DB_LOGIN,$DB_PASSWORD);

mysql_select_db($DB_NAME);

$res=mysql_query(“SELECT * FROM PRODUCT”);

$row=mysql_fetch_array($res);

for($i=0;$i<$num;$i++)

$row=mysql_fetch_array($res);

mysql_data_seek($res,0);//移动指针回到查询果的第一行

mysql_fetch_array

将查询的结果存在数组中（每一个数组元素存一个记录）

语法

array mysql_fetch_array(resource result[,int result_type])

eg

$DB_HOST =”localhost”;

$DB_LOGIN =”root”;

$DB_PASSWORD =”123456”;

$DB_NAME =”flag”;

$conn=mysql_connect($DB_HOST,$DB_LOGIN,$DB_PASSWORD);

mysql_select_db($DB_NAME);

$res=mysql_query(“SELECT * FROM PRODUCT”);

$row=mysql_fetch_array($res);

mysql_fetch_object

取得查询结果一行，并以对象类型存储之，与MySQL_fetch_array()使用方法完全相同，不同的是mysql_fetch_object()只能通过字段名称来取得查询结果

echo $row->fieldname; //正确用法

echo $row->0; //错误用法

语法

object mysql_fetch_object(resource result)

eg

$DB_HOST =”localhost”;

$DB_LOGIN =”root”;

$DB_PASSWORD =”123456”;

$DB_NAME =”flag”;

$conn=mysql_connect($DB_HOST,$DB_LOGIN,$DB_PASSWORD);

mysql_select_db($DB_NAME);

$res=mysql_query(“SELECT * FROM PRODUCT”);

$row=$mysql_fetch_object($res);

while($row)

{
echo $rowàp_id;
echo $rowàp_name;

}

mysql_insert_id

在使用INSERT命令增加完一条信息后，可利用此函数取得刚刚增加记录的unique id

语法

int mysql_insert_id([esource link_identifier])

eg

$DB_HOST =”localhost”;

$DB_LOGIN =”root”;

$DB_PASSWORD =”123456”;

$DB_NAME =”flag”;

$conn=mysql_connect($DB_HOST,$DB_LOGIN,$DB_PASSWORD);

mysql_select_db($DB_NAME);

$SQLStr”INSERT INTO produce (p_id,p_name)VALUES(‘’,’PHP书’)”;

$res=mysql_query($res);

$p_id=mysql_insert_id();

mysql_num_rows

取得查询结果里有几行

语法

int mysql_num_rows(resource result)

eg

$DB_HOST =”localhost”;

$DB_LOGIN =”root”;

$DB_PASSWORD =”123456”;

$DB_NAME =”flag”;

$conn=mysql_connect($DB_HOST,$DB_LOGIN,$DB_PASSWORD);

mysql_select_db($DB_NAME);

$res=mysql_query(“SELECT * FROM PRODUCT”);

$num=mysql_num_rows($res);

mysql_query

送出一个SQL语法的查询语句

语法

resource mysql_query(string query[,resource link_identifier])

eg

$DB_HOST =”localhost”;

$DB_LOGIN =”root”;

$DB_PASSWORD=”123456”;

$DB_NAME =”flag”;

$conn=mysql_connect($DB_HOST,$DB_LOGIN,$DB_PASSWORD);

mysql_select_db($DB_NAME);

$res=mysql_query(“SELECT * FROM PRODUCT”);

mysql_select_db

选择欲存取的数据库名称

语法

bool mysql_select_db(string database_name[,resource link_identifier])

eg

$DB_HOST =”localhost”;

$DB_LOGIN =”root”;

$DB_PASSWORD =”123456”;

$DB_NAME =”flag”;

$conn=mysql_connect($DB_HOST,$DB_LOGIN,$DB_PASSWORD);

mysql_select_db($DB_NAME);

2、文件系统函数

copy

复制文本

语法

bool copy(string source,string dest)

eg

copy(“abc.txt”,”/tmp/newabc.txt”);

fclose

关闭一个打开文件的指针

语法

bool fclose(resource handle)

eg

$fp=fopen(“abc.txt”,”w”);

fclose($fp);

fgets

从文件指针所指位置取得列的内容

语法

string fgets(resource handle[,int length])

eg

$fp=fopen(“abc.txt”,”w”);

$txtdata= fgets($fp,4096);

file

将整个文件内容读到数组中

语法

array file(string filename[,int use_include_path[,resource context]])

eg

$content=file(“abc.txt”);

file_exists

检查文件是否存在

语法

bool file_exists(string filename)

eg

if (file_exists(“abc.txt”))
echo “此文件存在”;

else

echo”此文件不存在”;

filesize

取得文件大小

语法

int filesize(string filename)

eg

$size=filesize(“abc.txt”);

fopen

打开一个文件或者url

语法

resource fopen (string filename,string mode[,bool use-include_path[,resource zcontext]])

eg

$fp=fopen(“abc.txt”);

$fp=fopen(“http://www.cnblogs.com/bacteroid/”,”r”);

fputs

将数据写至文件中

语法

int fputs(resource handle,string string[,int length])

eg

$fp=fopen(“abc.txt”);

fputs($fp,”helloworld!”);

fseek

设置文件指针所指的位置

语法

int fseek(resource handle,int offset[,int whence])

eg

$fp=fopen(“abc.txt”,”w”);

$txtdata=fgets($fp,4096);

fseek($fp,0);//将指针指回起始处

mkdir

建立一个目录

语法

bool mkdir(string pathname[,int mode[,bool recursive[,resource context]]])

eg

mkdir(“ljt/newfolder”);

unlink

删除文件

语法

int unlink(string filename);

eg

unlink(”abc.txt”);

3、日期与时间函数

data

返回指定格式的当地时间/日期

语法

string date(string format[,int timestamp])

eg

$time =date(“Y-m-d g:i:s”);

getdate

取得日期与时间的信息

语法

array getdata([int timestamp])

eg

$now=getdate();

$year=$now[“year”];

$month=$now[“month”];

gettimeofday

取得目前的时间（包括格林尼治时间）

语法

array gettimeofday(void)

eg

$time=gettimeofday();

4、字符串处理函数

explode

根据指定的分隔符将字符串拆分成一个数组

语法

array explode(string separator,string string[,int limit])

eg

$str=”a,b,c”;

$res=explode(“,”,$str);//$res[0]=a

implode

将数组内容连接成一个字符串

语法

string implode(string glue,array pieces)

eg

$newarray=array(‘a’,’b’,’c’);

$res=implode(“,”,$newarray);//$res=a,b,c

strlen

取得字符串的长度

语法

int strlen(string string)

eg

strlen(“www.gxnu.edu.cn”);//传回15

substr

取得字符串指定的某部分字符（子字符串）

语法

string substr(“www.gxnu.edu.cn”,1,7); //返回”ww.gxnu”

5、数学函数库

将浮点数的小数部分无条件进位

语法

float ceil(float value)

eg

echo ceil(9.99);//返回10

echo ceil(9.12);//返回10

cos

取得浮点数值的余弦值

语法

float cos(float arg)

eg

$numcos=cos(0.5);

floor

将浮点数的小数部分无条件去掉

语法

float floor(floor value)

eg

echo floor(9.12);//返回9

echo floor(9.99);// 返回9

rand

产生一个范围的随机数值

语法

nt rand([int min,in max])

eg

$num=rand(0,100);//产生一个介于1到100间的随机数值

round

将浮点数的小数部分四舍五入进位

语法

float round(float value)

eg

float round(9.99)//返回10

float round(9.12)//返回9

sin

取得浮点数值的正弦值

语法

float sin(float arg)

eg

$numsin=sin(0.5);

6、Session函数

session_register

说明一或多个Session里的变量

语法

bool session_register(mixed name[,mixed...])

eg

$name=”flag”;

session_register(“name”);

session_start

初始化Session 信息

语法

bool session(void)

eg

session_start();

7、数组函数

count

计算数组中共有几个数组函数

语法

int count(mixed var[,int mode])

eg

count($array);

list

将数组中的元素值分配给变量

语法

void list(mixed varname,mixed...)

eg

$array=array(a,b,c);

list($str1,$str2,$str3)=$array;//$str1=a

range

建立一个在指定范围内的数组

语法

array range(int low,int high[,int step])

eg

$array=array(0,9);

shuffle

将数组中的元素重新随机排序

语法

bool shuffle(array array)

eg

shuffle($array);

作者：类菌体
出处：http://www.cnblogs.com/bacteroid/archive/2011/08/12/2135930.html
关于作者：在校学生
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接
如有问题，可以通过303323670@qq.com 联系我，非常感谢。

本文链接

总结大学一些常见数据结构简单实现（c&c++语言）

2011-07-31T11:28:00Z

小引：

笔者是一个大三本科生，目前在备考研复习，在进行计算机统考复习数据结构当中，所以有时间在看到很久以前学习的数据结构和算法实现的上机操作以及自己平时编写的数据结构代码，一同把它分享到这里来，因为是初学到复习考研这个过程，不免会有错误和不足，所以希望得到园友批评和建议，实现环境是vc6.0,语言是c或者c++,希望得到初学者喜欢，大牛可以飞过！！！！

理解算法和程序的关系,掌握顺序表的基本操作

内容：(1) 在一个递增有序的顺序表中插入一个元素,使插入之后仍有序
(2) 将顺序表L逆置

#include "stdlib.h"
#include <iostream.h>

typedef int ElemType;

/* 顺序表定义，书20 */
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef struct {
ElemType *elem;
int length;
int listsize;
} SqList;

/* 生成具有n个元素的顺序表 L,类似书P21,算法2_1 */
void Creat_Sq(SqList &L,int n){
L.elem=new ElemType[LIST_INIT_SIZE];
for(int i=1;i<=n;i++) L.elem[i-1]=2*i;//直接生成
L.length=n;
L.listsize=LIST_INIT_SIZE;
}

void Increament(SqList &L)
{//当前存储空间已满，增加分配空间
ElemType *a=new ElemType[L.listsize+ LISTINCREMENT];
for (int i=0;i<L.length;i++) a[i]=L.elem[i];
delete []L.elem;
L.elem=a;
L.listsize=L.listsize+ LISTINCREMENT;
}

void ListInsert_Sq(SqList &L, int i,ElemType e) {
//将e插入到顺序表L中第i个元素之前
if(i<1||i>L.length+1) {cout<<"ERROR";exit(-1);}

if (L.length>L.listsize) Increament(L);

ElemType* q=&(L.elem[i-1]);
for (ElemType* p=&(L.elem[L.length-1]); p>=q;--p) *(p+1)=*p;
*q=e;

++L.length;

}

/* 主函数 */
void main()
{ SqList L;
int i,e,m;
cout<<"请输入元素个数:"<<endl;
cin>>m;

/* 生成具有n个元素的顺序表L*/
Creat_Sq( L, m);

/* 显示该顺序表 */
cout<<"\n该顺序表为： \n"<<endl;
for (i=1;i<=L.length;i++) cout<<""<<L.elem[i-1];

cout<<endl<<"请输入插入位置及元素："<<endl;
cin>>i>>e;

/* 在L中插入元素e , 注意函数调用的格式*/
ListInsert_Sq (L,i,e);

for (i=1;i<=L.length;i++)
cout<<""<<L.elem[i-1];
cout<<endl;
/*逆序排*/
cout<<" 逆序输出"<<endl;
for(i=L.length;i>=1;i--)
cout<<""<<L.elem[i-1];

}

进一步掌握顺序表的操作

内容：(1) 将两个递增有序的顺序表合并为一个递增有序的顺序表，并显示

(2) 将顺序表L逆置

以下代码为：把两个递增有序的单链表归并为一个递增有序的链表，辅助空间为O（1）
#include<iostream>
usingnamespace std;
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode *LinkList;
void CreatList(LinkList &L,int n)
{
LinkList p,q;
L=new LNode;
L->next=NULL;
q=L;
cout<<"请从小到大输入链表的元素：";
for(int i=1;i<=n;i++)
{
p=new LNode;
cin>>p->data;
p->next=q->next;
q->next=p;
q=q->next;
}
cout<<"所创建得的递增有序链表为：";
p=L->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void CreatC(LinkList &A,LinkList &B,LinkList &C,int n)
{
LinkList p,q,t;
p=A->next;
q=B->next;
C=t=A;
while(p&&q)
{
if(p->data<=q->data)
{
t->next=p;
t=p;
p=p->next;
}
else
{
t->next=q;
t=q;
q=q->next;
}
}
t->next=p?p:q;
delete B;
cout<<"合并后的递增有序链表为：";
p=C->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void main()
{
LinkList A,B,C;
int n,m,k;
cout<<"请输入链表***A***的长度：";
cin>>n;
CreatList(A,n);
cout<<"请输入链表***B***的长度：";
cin>>m;
CreatList(B,m);
k=m+n;
CreatC(A,B,C,k);
}

掌握链表的基本操作

内容：(1) 建立一个单链表，并写一个函数来显示链表中的元素
（2）在一个单链表中查找元素X,找到,显示其序号,否则显示”未找到”

#include<iostream>
usingnamespace std;
typedef int ElemType;

typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode *LinkList;

void InitList_L(LinkList &L)
{
L=new LNode;
L->next=NULL;
}

void CreateList_L(LinkList &L,int n)
{
InitList_L(L);
for(int i=n;i>0;--i)
{
LNode *p=new LNode;
cin>>p->data;
p->next=L->next;
L->next=p;
}
}

void print(LinkList L)
{
LNode *p=new LNode;
p=L->next;
while(p)
{
cout<<p->data<<"";
p=p->next;
}

}

void Find(LinkList L,ElemType a)
{
int i=1,j=0;
LNode *p=new LNode;
p=L->next;
while(p)
{
if(p->data==a)
{
cout<<"您要查找的数据 "<<a<<" 在单链表中为 "<<i<<" 号元素！\n";
j++;
}
i++;
p=p->next;
}
if(j==0)
cout<<"您要查找的数据不在单链表中！\n";
}

void main()
{
int n;
ElemType a;
LinkList L;
cout<<"请输入您要输入的单链表的数据个数n:\n";
cin>>n;
cout<<"请输入(逆序输入)您要输入的数据：\n";
CreateList_L(L,n);
cout<<"依次输出链表中的数据为:\n";
print(L);
cout<<"\n";
cout<<"请输入您要查找的数据a:\n";
cin>>a;
Find(L,a);
}

　通过实验理解栈和队列的应用

内容：(1) 用栈实现数制转换

(2) 输入一个算术表达式,其中含有（、[ 两种括号，判断括号是否匹配

#include<iostream>
usingnamespace std;

#define SElemType int
#define Stack_Init_Size 20
#define Stack_Increment 10

typedef struct{
SElemType *elem;
int top;
int stacksize;
int incrementsize;
}SqStack;

void InitStack(SqStack &s){ //初始化栈
s.elem=new SElemType[Stack_Init_Size];
s.top=-1;
s.stacksize=Stack_Init_Size;
s.incrementsize=Stack_Increment;
}

void StackIncrement(SqStack &s){ //增加栈长度
SElemType *a;
a=new SElemType[s.stacksize+s.incrementsize];
for(int i=0;i<=s.top;i++)
a[i]=s.elem[i];
delete []s.elem;
s.elem=a;
s.stacksize=s.stacksize+s.incrementsize;
}

void Push_stack(SqStack &s,SElemType x){ //入栈
if(s.top==(s.incrementsize-1))
StackIncrement(s);
s.elem[++s.top]=x;
}

void Get_num(int&a){ //输入十进制数
cout<<"请输入十进制数"<<endl;
cin>>a;
}

void change(SqStack &s,int x){ //十进制转化为二进制，并用栈储存
while (x!=1){
Push_stack(s,x%2);
x=x/2;
}
Push_stack(s,x);
}

void Output(SqStack &s){ //十进制数以二进制形式输出
cout<<"转为二进制:"<<endl;
for(int a=s.top;a>=0;a--)
cout<<s.elem[a];
cout<<endl;
}

void main (){
SqStack ss;
InitStack(ss);
int s;
Get_num(s);
change(ss,s);
Output(ss);
}
#include<iostream>
usingnamespace std;

#define SElemType char
#define Stack_Init_Size 20
#define Stack_Increment 10

typedef struct{
SElemType *elem;
int top;
int stacksize;
int incrementsize;
}SqStack;

void InitStack(SqStack &s){ //用于初始化栈
s.elem=new SElemType[Stack_Init_Size];
s.top=-1;
s.stacksize=Stack_Init_Size;
s.incrementsize=Stack_Increment;
}

void StackIncrement(SqStack &s){ //用于增加栈长
SElemType *a;
a=new SElemType[s.stacksize+s.incrementsize];
for(int i=0;i<=s.top;i++)
a[i]=s.elem[i];
delete []s.elem;
s.elem=a;
s.stacksize=s.stacksize+s.incrementsize;
}

void Push_stack(SqStack &s,SElemType x){ //入栈
if(s.top==(s.incrementsize-1))
StackIncrement(s);
s.elem[++s.top]=x;
}

void Pop_Stack(SqStack &s){ //出栈
s.top--;
}

void Get_C(char x[]){ //获取表达式，用数组存放
cout<<"请输入表达式(以等号结束):"<<endl;
for(int i =0;;i++){
cin>>x[i];
if(x[i]=='=')
break;
}
}

void match(SqStack &s,char x[]){ //进行括号的匹配判断
int n=1; //辅助量，用于判断括号的顺序性是否为真
for(int i=0;;i++){
if(x[i]=='(')
Push_stack(s,'a');
if(x[i]=='[')
Push_stack(s,'b');
if(x[i]==')'){
if(s.elem[s.top]=='a')
Pop_Stack(s);
else
{n=0;break;}
}
if(x[i]==']'){
if(s.elem[s.top]=='b')
Pop_Stack(s);
else
{n=0;break;}
}
if(x[i]=='=')
break;
}
if((n==1)&&(s.top==-1)) //若判断括号的顺序性为真，在判断是否一一匹配
cout<<"括号相匹配"<<endl;
else
cerr<<"括号不匹配"<<endl;
}

void main (){
SqStack ss;
char x[10];
InitStack(ss);
Get_C(x);
match(ss,x);
}

通过实验理解栈和队列的应用 (没有完成)

内容：(1) 输入一字符串,利用栈和队列判断是否是回文
（2）编写递归函数，求正整数N的阶乘N！；再编写函数，用栈实现求N的阶乘，体会栈与递归的关系

#include<iostream>
usingnamespace std;

#define SElemType char
#define Stack_Init_Size 20
#define Stack_Increment 10

typedef struct{
SElemType *elem;
int top;
int stacksize;
int incrementsize;
}SqStack;

void InitStack(SqStack &s){ //用于初始化栈
s.elem=new SElemType[Stack_Init_Size];
s.top=-1;
s.stacksize=Stack_Init_Size;
s.incrementsize=Stack_Increment;
}

void StackIncrement(SqStack &s){ //用于增加栈长
SElemType *a;
a=new SElemType[s.stacksize+s.incrementsize];
for(int i=0;i<=s.top;i++)
a[i]=s.elem[i];
delete []s.elem;
s.elem=a;
s.stacksize=s.stacksize+s.incrementsize;
}

void Push_stack(SqStack &s,SElemType x){ //入栈
if(s.top==(s.incrementsize-1))
StackIncrement(s);
s.elem[++s.top]=x;
}

void Pop_Stack(SqStack &s){ //出栈
s.top--;
}

void Get_C(char x[],int&y){ //获取表达式，用数组存放
cout<<"请输入表达式(以#结束):"<<endl;
for(int i =0;;i++){
{cin>>x[i];y++;}
if(x[i]=='#')
break;
}
}

void Judgment(SqStack &s,char x[],int y){
int i;
for(i=0;i<(y-2)/2.0;i++)
Push_stack(s,x[i]);
if((y-1)%2==0) ;
else
i=i+1;
for(;i<y;i++)
{if(x[i]==s.elem[s.top]) Pop_Stack(s);}
if(s.top==-1)
cout<<"回文!"<<endl;
else
cout<<"非回文!"<<endl;
}

void main (){
SqStack ss;
char x[20];
int y=0;
InitStack(ss);
Get_C(x,y);
Judgment(ss,x,y);
}

通过实验理解二叉树的存储和操作

内容： (1)建立二叉树的二叉链表存储，并对它进行中序遍历
(2)求二叉树的结点数
(3)求高度

#include"iostream.h"
typedef char TElemType;
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild;
struct BiTNode *rchild;
}BiTNode;
typedef BiTNode *BiTree;
void CreateBiTree_Rec(BiTree &T)
{
TElemType ch;
cin>>ch;
if(ch=='#')
T=NULL;
else
{
T=new BiTNode;
T->data=ch;
CreateBiTree_Rec(T->lchild);
CreateBiTree_Rec(T->rchild);
}
}
void InOrder_Rec(BiTree T)
{
if(T)
{

InOrder_Rec(T->lchild); cout<<T->data;
InOrder_Rec(T->rchild);
}
}
int Leafs_Rec(BiTree T)
{
int l_Leafs,r_Leafs;
staticint i=0;
if(T==NULL)
return0;
else
{
i++;
l_Leafs=Leafs_Rec(T->lchild);
r_Leafs=Leafs_Rec(T->rchild);
}
return i;
}
int Leafs_Rec1(BiTree T)
{
int l_Leafs,r_Leafs;
if(T==NULL)
return0;
else
{
if((T->lchild==NULL)&&(T->rchild==NULL))
return1;
else
{
l_Leafs=Leafs_Rec1(T->lchild);
r_Leafs=Leafs_Rec1(T->rchild);
return (l_Leafs+r_Leafs);
}

}
}
int BiTreeDepth_Rec(BiTree T)
{
int depth_l,depth_r;
if(!T)
return0;
else
{
depth_l=BiTreeDepth_Rec(T->lchild);
depth_r=BiTreeDepth_Rec(T->rchild);
if(depth_l>=depth_r)
return (depth_l+1);
else
return (depth_r+1);
}
}
void main()
{
BiTree T;
cout<<"请按要求(前序序列建立)输入您所要输入的字符串：\n";
CreateBiTree_Rec(T);
cout<<"中序递归遍历输出为：\n";
InOrder_Rec(T);
cout<<endl;
cout<<"该二叉树的结点数目为："<<Leafs_Rec(T)<<endl;
cout<<"该二叉树的叶子结点数目为："<<Leafs_Rec1(T)<<endl;
cout<<"该二叉树的深度为："<<BiTreeDepth_Rec(T)<<endl;
}

通过实验理解图的存储和搜索算法

内容：1。建立一个无向图的邻接表存储

2。对该图进行深度优先搜索，按顺序输出所访问的

#include<iostream.h>
#define MAX_VERTEX_NUM 20
typedef char VertexType;
typedef enum{FALSE,TRUE}Boolean;
Boolean visited[MAX_VERTEX_NUM];
typedef struct EdgeNode //表结点
{
int adjvex;
struct EdgeNode *nextedge;
}EdgeNode;
typedef struct VerNode //头结点
{
VertexType vex;
EdgeNode *firstedge;
}VerNode,AdjList[MAX_VERTEX_NUM];
typedef struct
{
AdjList vertices;
int vexnum,edgenum;
}ALGraph;
int LocateVex_ALG(ALGraph G,VertexType x) //确定x在G中的位置
{
int k=-1;
for(k=0;(k<G.vexnum)&&(G.vertices[k].vex!=x);++k);
return k;
}
void CreateNDG_ALG(ALGraph &G) //构造图的邻接表
{
int i,j,k;
VertexType v1,v2;
cout<<"请输入图的顶点数和边数：\n";
cin>>G.vexnum>>G.edgenum;
cout<<"请输入顶点的内容：\n";
for(i=0;i<G.vexnum;++i)
{
cin>>G.vertices[i].vex;
G.vertices[i].firstedge=NULL;
}
cout<<"请依次输入每条边的初始和终点的顶点内容：\n";
for(k=0;k<G.edgenum;++k)
{
cin>>v1>>v2;
i=LocateVex_ALG(G,v1);
j=LocateVex_ALG(G,v2);
EdgeNode *p=new EdgeNode;
p->adjvex=j;
p->nextedge=G.vertices[i].firstedge;
G.vertices[i].firstedge=p;
}
}
void DFS(ALGraph G,int v)
{
int w;
EdgeNode *p;
visited[v]=TRUE;
cout<<G.vertices[v].vex<<""; //输出顶点数据
for(p=G.vertices[v].firstedge;p;p=p->nextedge)
{
w=p->adjvex;
if(!visited[w])
DFS(G,w);
}
}
void DFSTraverse(ALGraph G)
{
int v;
for(v=0;v<G.vexnum;++v)
visited[v]=FALSE;
cout<<"按深度优先遍历顺序依次输出顶点为：\n";
for(v=0;v<G.vexnum;++v)
if(!visited[v])
DFS(G,v);
cout<<endl;
}
void main()
{
ALGraph G;
CreateNDG_ALG(G); //由邻接表构造无向图
DFSTraverse(G); //按深度优先遍历顺序遍历该无向图
}

通过实验理解图的存储和搜索算法

内容：1。构造图的邻接矩阵

2。对该图广度优先遍历

#include<iostream.h>
#define MAX_VERTEX_NUM 20
#define QUEUE_INIT_SIZE 100
typedef enum{DG,DN,UDG,UDN}GraphKind;
typedef char VertexType;
typedef int EdgeType;
typedef enum{FALSE,TRUE}Boolean;
Boolean visited[MAX_VERTEX_NUM];
typedef char QElemType;
typedef struct
{
QElemType *elem;
char front;
char rear;
char queuesize;
}SqQueue;
typedef struct
{
VertexType vexs[MAX_VERTEX_NUM];
EdgeType edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
int vexnum,edgenum;
}MGraph;
void InitQueue_Sq(SqQueue &Q) //队列
{
Q.elem=new QElemType[QUEUE_INIT_SIZE];
Q.front=Q.rear=0;
Q.queuesize=QUEUE_INIT_SIZE;
}
void EnQueue_Sq(SqQueue &Q,QElemType e)
{
if(((Q.rear+1)%Q.queuesize)==Q.front)
Q.elem[Q.rear]=e;
Q.rear=(Q.rear+1)%Q.queuesize;
}
QElemType DeQueue_Sq(SqQueue &Q)
{
QElemType e;
e=Q.elem[Q.front];
Q.front=(Q.front+1)%Q.queuesize;
return e;
}
int LocateVex_MG(MGraph G,VertexType x) //构造图的邻接矩阵
{
int k=-1;
for(k=0;(k<G.vexnum)&&(G.vexs[k]!=x);++k);
return k;
}
void CreatUDG_MG(MGraph &G)
{
int i=0,j=0,k=0;
VertexType v1,v2;
cout<<"请输入图(无向图)的顶点数和边数：\n";
cin>>G.vexnum>>G.edgenum;
cout<<"请输入顶点的内容：\n";
for(i=0;i<G.vexnum;++i)
cin>>G.vexs[i];
for(i=0;i<G.vexnum;++i)
for(j=0;j<G.vexnum;++j)
G.edges[i][j]=0;
cout<<"请依次输入每条边的初始和终点：\n";
for(k=0;k<G.edgenum;++k)
{
cin>>v1>>v2;
i=LocateVex_MG(G,v1);
j=LocateVex_MG(G,v2);
while((i<0)||(i>(G.vexnum-1))||(j<0)||(j>(G.vexnum-1)))
{
cout<<"编码超出范围，请重新输入：\n";
cin>>v1>>v2;
i=LocateVex_MG(G,v1);
j=LocateVex_MG(G,v2);
}
G.edges[j][i]=G.edges[i][j];
}
}
void BFSTraverse(MGraph G) //广度优先遍历
{
SqQueue Q;
int v;
for(v=0;v<G.vexnum;++v)
visited[v]=FALSE;
InitQueue_Sq(Q);
cout<<"按广度优先遍历顺序顶点依次输出为：\n";
for(v=0;v<G.vexnum;++v)
if(!visited[v])
{
visited[v]=TRUE;
cout<<G.vexs[v]<<"";
EnQueue_Sq(Q,v);
while(Q.front!=Q.rear)
{
DeQueue_Sq(Q);
for(int w=0;w<G.vexnum;w++)
if(G.edges[v][w]&&(!visited[w]))
{
visited[w]=TRUE;
cout<<G.vexs[w]<<"";
EnQueue_Sq(Q,w);
}
}
}
cout<<endl;
}
void main()
{
MGraph G;
CreatUDG_MG(G);
BFSTraverse(G);
}

掌握基本的排序方法

上机内容：给定一组整数,分别用直接插入排序、冒泡排序方法进行排序，输出排序后的结果

#include<iostream.h>
#define MAXSIZE 20 //假设文件长度，即待排序记录数目
typedef int KeyType; // 假设的关键字类型
typedef int InfoType;
typedef struct { //记录定义

KeyType key; //关键字型
InfoType otherinfo; //其他数据项，InfoType依赖于具体应用
}RedType; //记录类型
typedef struct { //顺序表定义

RedType r[MAXSIZE+1]; //r[0]闲置或用来做小兵
int length; //顺序表长度

}SqList; //顺序表类型

void input(SqList &l)
{
cout<<"请输入各元素"<<endl;
for(int i=1;i<=l.length;i++)
{
cin>>l.r[i].key;
}
}
void Insertsort(SqList &L){ //对顺序表进行直接插入排序

int i,j;
for(i=2;i<=L.length;i++) //外循环
if(L.r[i].key<L.r[i-1].key) { //将L.r[i]插入有序子表

L.r[0]=L.r[i];
for(j=i-1;L.r[0].key<L.r[j].key;j--) //内循环
L.r[j+1]=L.r[j]; //记录后移
L.r[j+1]=L.r[0];

} //end if

}//Insertsort
void Bubblesord(SqList &L)
{
int i,j;
bool tag=0;
for( i=1;(tag==0)&&(i<=L.length);++i)
{
tag=1;
for(j=L.length-1;j>=i;--j)
if(L.r[j+1].key<L.r[j].key)
{
L.r[0]=L.r[j+1];L.r[j+1]=L.r[j];L.r[j]=L.r[0];tag=0;
}//end if
}//end for
}//Bubblesord
int main()
{
SqList L;
int i,m;
cout<<"请输入元素个数:"<<endl;
cin>>m;
L.length=m;
input(L);
/* 显示该顺序表 */
cout<<"\n该顺序表为"<<endl;
for(i=1;i<=L.length;i++)
cout<<L.r[i].key<<"";
cout<<endl;
/* 进行直接插入排序 */
Insertsort(L);
cout<<"直接插入法排序"<<endl;
for(i=1;i<=L.length;i++)
cout<<L.r[i].key<<"";
cout<<endl;
/* 进行冒泡排序 */
Bubblesord(L);
cout<<"进行冒泡排序"<<endl;
for(i=1;i<=L.length;i++)
cout<<L.r[i].key<<"";
cout<<endl;
return0;
}

理解静态查找操作方法

内容：(1) 建立一个静态查找表 (可只输入数据的关键字项) 。
(2) 分别用顺序查找和用折半查找方法查找给定关键字。

(3)分别统计在两种查找方法中的比较次数。

#include<iostream.h>
typedef int KeyType;
typedef int InfoType;

typedef struct{
KeyType *k;
int length;
}SSTable;

void Initlist_SSTable(SSTable &ST){
ST.length=6;
ST.k=new KeyType[ST.length+1];
cout<<"请输入6个关键字："<<endl;
for(int i=1;i<=ST.length;i++)
cin>>ST.k[i];
}

int Search_Seq(SSTable ST,KeyType k, int&n){
ST.k[0]=k;
for(int i=ST.length;ST.k[i]!=k;--i)
++n;
return i;
}

int Search_Bin(SSTable ST,KeyType k,int&n){
int low=0;
int high=ST.length;
while(low<=high){
int mid=(low+high)/2;
if(k==ST.k[mid])
return mid;
elseif(k<ST.k[mid])
high=mid-1;
else low=mid+1;

}
return0;
}
void main(){
SSTable ST;
Initlist_SSTable(ST);
KeyType k;

int n=0;
cout<<"请输入需要查找的关键字："<<endl;
cin>>k;
cout<<"顺序查找"<<endl;

if(Search_Seq(ST,k,n)==0)
cout<<"没有该元素。"<<endl;
else cout<<k<<endl;
cout<<"关键字在第 "<<Search_Seq(ST,k,n)<<" 位置。"<<endl;
cout<<"查找比较次数为："<<n-1<<endl;

cout<<"折半查找"<<endl;
if(Search_Bin(ST,k,n)==0)
cout<<"没有该元素。"<<endl;
else cout<<k<<endl;
cout<<"关键字在第 "<<Search_Bin(ST,k,n)<<" 位置。"<<endl;
cout<<"查找比较次数为："<<n-1<<endl;
}

排序

#include<iostream.h>
#define MAXSIZE 20 //假设文件长度，即待排序记录数目
typedef int KeyType; // 假设的关键字类型
typedef int InfoType;
typedef struct { //记录定义

KeyType key; //关键字型
InfoType otherinfo; //其他数据项，InfoType依赖于具体应用
}RedType; //记录类型
typedef struct { //顺序表定义

RedType r[MAXSIZE+1]; //r[0]闲置或用来做小兵
int length; //顺序表长度

}SqList; //顺序表类型

void input(SqList &L) //输入顺序表
{
cout<<"请输入各元素"<<endl;
for(int i=1;i<=L.length;i++)
{
cin>>L.r[i].key;
}
}
void Insertsort(SqList &L){ //对顺序表进行直接插入排序

int i,j;
for(i=2;i<=L.length;i++) //外循环
if(L.r[i].key<L.r[i-1].key) { //将L.r[i]插入有序子表

L.r[0]=L.r[i];
for(j=i-1;L.r[0].key<L.r[j].key;j--) //内循环
L.r[j+1]=L.r[j]; //记录后移
L.r[j+1]=L.r[0];

} //end if

}//Insertsort
void Bubblesord(SqList &L)
{
int i,j;
bool tag=0;
for( i=1;(tag==0)&&(i<=L.length);++i)
{
tag=1;
for(j=L.length-1;j>=i;--j)
if(L.r[j+1].key<L.r[j].key)
{
L.r[0]=L.r[j+1];L.r[j+1]=L.r[j];L.r[j]=L.r[0];tag=0;
}//end if
}//end for
}//Bubblesord
int main()
{
SqList L;
int i,m;
cout<<"请输入元素个数:"<<endl;
cin>>m;
L.length=m;
input(L);
/* 显示该顺序表 */
cout<<"该顺序表为"<<endl;
for(i=1;i<=L.length;i++)
cout<<L.r[i].key<<"";
cout<<endl;
/* 进行直接插入排序 */
Insertsort(L);
cout<<"直接插入法排序"<<endl;
for(i=1;i<=L.length;i++)
cout<<L.r[i].key<<"";
cout<<endl;
/* 进行冒泡排序 */
Bubblesord(L);
cout<<"进行冒泡排序"<<endl;
for(i=1;i<=L.length;i++)
cout<<L.r[i].key<<"";
cout<<endl;
return0;
}

冒泡、直插、快速比较算法,数据不是随即产生，手动输入的你可以做一个参考

//这个是对冒泡、直插、快速的比较算法。数据不是随即产生的，是手动输入的，你可以做一个参考！代码如下：

#include <stdio.h>
#include <stdlib.h>
#define MAX 100
void disparr();
int a[MAX],n,m;
void creatarr()
{
int i=0;
printf("建立原始数序\n");
printf("\t 元素个数：");
scanf("%d",&n);
while (i<n)
{
printf("\t 第%d个元素值：",i+1);
scanf("%d",&a[i]);
i++;
}
}

int cmp(int lval, int rval,int order)
{
if (order==1)
{ if (lval<rval) return (1);
elsereturn (0); }
else
{ if(lval>rval) return (1);
elsereturn (0); }
}
void BubbleSort(int r[], int q, int w, int order)
{
int i=q ,j=w , k, swap;
for (i=q ; i<w ; i++)
{ swap=0;
for (j=q ; j<=w-q ; j++ )
if(cmp(r[j+1], r[j], order))
{ k=r[j+1];
r[j+1]=r[j];
r[j]=k;
swap=1;
}
if (!swap) return;
}
printf("\n");
if (q<i) BubbleSort (r, q,i-1, order);
if (i<w) BubbleSort (r,j+1,w,order);
}
void insertsort(int x[],int l,int r,int order)
{
int i=l,j=r,temp;
for (i=1;i<=r;i++)
{ temp=x[i];
j=i-1;
while (j>0&& cmp(temp, x[j], order))
{ x[j+1]=x[j];
j--; }
x[j+1]=temp;
}
printf("\n");
if (l<i) BubbleSort (x, l,i-1, order);
if (i<r) BubbleSort (x,j+1,r,order);
}
void quicksort(int x[],int l,int r,int order)
{
int i=l,j=r,temp;
temp=x[l];
while (i<j)
{ while (i<j && cmp (temp, x[j],order)) j--;
if (i<j)
{ x[i]=x[j]; i++; }
while (i<j && cmp (x[i], temp, order)) i++;
if (i<j)
{ x[j]=x[i]; j--; }
}
x[i]=temp;
if (l<i) quicksort (x, l,i-1, order);
if (i<r) quicksort (x,j+1,r,order);
}
void disparr()
{
int i;
for (i=0;i<n;i++)
printf("%d ",a[i]);
printf("\n\n");}
void main()
{
int m;
m=1;
creatarr(a);
printf("\n 原来的次序：");
disparr();
while(m)
{printf("*********************************************************************\n");
printf("0:退出 1:重新输入 2：直接插入排序 3：冒泡排序 4：快速排序 \n ");
printf("**********************************************************************\n");
scanf("%d",&m);
switch(m)
{
case0:
exit(-1);
case1:
creatarr(a);
printf("\n 原来的次序：");
disparr();
break;
case2:
printf("直接插入排序：\n");
printf("从小到大排序：\n");
insertsort(a,0,n-2,1);
printf("排序结果：");
disparr();
printf("从大到小排序：\n");
insertsort(a,0,n-2,0);
printf("排序结果：");
disparr();
break;
case3:
printf("冒泡排序法：\n");
printf("从小到大排序：\n");
BubbleSort(a,0,n-2,1);
printf("排序结果：");
disparr();
printf("从大到小排序：\n");
BubbleSort(a,0,n-2,0);
printf("排序结果：");
disparr();
break;
case4:
printf("快速排序法：\n");
printf("从小到大排序：\n");
quicksort(a,0,n-1,1);
printf("排序结果：");
disparr();
printf("从大到小排序：\n");
quicksort(a,0,n-1,0);
printf("排序结果：");
disparr();
break;
}
}
}

用系统计时器算时间复杂度

//用系统计时器算时间复杂度。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#define LIST_INIT_SIZE 50000
int bj1,yd1,n;
clock_t start_t,end_t;
typedef struct
{
int key;
}ElemType;
typedef struct
{
ElemType *elem;
int length;
}SqList;
void addlist(SqList &L)
{
int i;
a: printf("请输入你要输入的个数:");
scanf("%d",&n);
if(n>50000)
{
printf("超出范围重新输入!!!\n");
goto a;
}
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)exit(0);
L.length=0;
for(i=1;i<n+1;i++)
{
b: L.elem[i].key=rand();
if(L.elem[i].key>30000)goto b;
++L.length;
}
}
void SelectSort(SqList &L)//选择
{
start_t=clock();
int i,j,k,bj=0,yd=0;
for(i=1;i<L.length;i++)
{
k=i;
for(j=i+1;j<L.length;j++)
{
bj++;
if(L.elem[j].key<L.elem[k].key)k=j;
}
if(i!=k)
{
L.elem[0].key=L.elem[i].key;
L.elem[i].key=L.elem[k].key;
L.elem[k].key=L.elem[0].key;
yd+=3;
}
}
end_t=clock();
printf("比较次数为 %d移动次数为 %d\n",bj,yd);
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void qipao(SqList &L)//起泡
{
start_t=clock();
int i=1,j,bj=0,yd=0;
while(i<L.length)
{
for(j=1;j<L.length;j++)
{
bj++;
if(L.elem[j].key>L.elem[j+1].key)
{
L.elem[0].key=L.elem[j].key;
L.elem[j].key=L.elem[j+1].key;
L.elem[j+1].key=L.elem[0].key;
yd+=3;
}
}
i++;
}
end_t=clock();
printf("比较次数为 %d移动次数为 %d\n",bj,yd);
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void InsertSort(SqList &L)//直接插入
{
start_t=clock();
int i,j,yd=0,bj=0;
for(i=2;i<=L.length;i++)
{
if(L.elem[i].key<L.elem[i-1].key)
{
L.elem[0].key=L.elem[i].key;
yd++;
j=i-1;
bj++;
while(L.elem[0].key<L.elem[j].key)
{
L.elem[j+1].key=L.elem[j].key;
j--;
yd++;
bj++;
}
L.elem[j+1].key=L.elem[0].key;
yd++;
}
}
end_t=clock();
printf("比较次数为 %d移动次数为 %d\n",bj,yd);
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void xier(SqList &L)//希尔
{
start_t=clock();
int i,d=L.length/2,j,w=0,k,yd=0,bj=0;
while(w<d)
{
w=1;
for(i=w;i<L.length;i=i+d)
{
k=i;
for(j=i+d;j<L.length;j=j+d)
{
if(L.elem[i].key>L.elem[j].key)
{
k=j;
bj++;
}
}
if(i!=k)
{
L.elem[0].key=L.elem[i].key;
L.elem[i].key=L.elem[k].key;
L.elem[k].key=L.elem[0].key;
yd+=3;
}
w++;
}
d=d/2;
w=1;
}
end_t=clock();
printf("比较次数为 %d移动次数为 %d\n",bj,yd);
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}

void BeforeSort()
{
yd1=0,bj1=0;
}
void display(int m,int n)
{
printf("比较次数为 %d移动次数为 %d\n",m,n);
}
int Partition(SqList &L,int low,int high)//快速排序
{
int pivotkey;
L.elem[0]=L.elem[low];
yd1++;
pivotkey=L.elem[low].key;
while (low<high)
{
yd1++;
while(low<high&&L.elem[high].key>=pivotkey)
--high;
L.elem[low]=L.elem[high];
bj1++;
yd1++;
while (low<high&&L.elem[low].key<=pivotkey)
++low;
L.elem[high]=L.elem[low];
bj1++;
yd1++;
}
L.elem[low]=L.elem[0];
yd1++;
return low;
}
void QSort(SqList &L,int low,int high)
{
int pivotloc;
if(low<high)
{
pivotloc=Partition(L,low,high);
QSort(L,low,pivotloc-1);
QSort(L,pivotloc+1,high);
}
}
void QuickSort(SqList &L)
{
start_t=clock();
BeforeSort();
QSort(L,1,L.length);
display(yd1,bj1);
end_t=clock();
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void Merge(ElemType R[],ElemType R1[],int low,int m,int high)//归并
{
int i=low, j=m+1, k=low;
while(i<=m&&j<=high)
{
if(R[i].key<=R[j].key)
{
bj1++;
R1[k]=R[i];
yd1++;
i++;
k++;
}
else
{
bj1++;
R1[k]=R[j];
yd1++;
j++;
k++;
}
}
while(i<=m)
{
R1[k]=R[i];
yd1++;
i++;
k++;
}
while(j<=high)
{
R1[k]=R[j];
yd1++;
j++;
k++;
}
}
void MergePass(ElemType R[],ElemType R1[],int length, int n)
{
int i=0,j;
while(i+2*length-1<n)
{
Merge(R,R1,i,i+length-1,i+2*length-1);
i=i+2*length;
}
if(i+length-1<n-1)
Merge(R,R1,i,i+length-1,n-1);
else
for(j=i;j<n;j++)
R1[j]=R[j];
}
void MSort(ElemType R[],ElemType R1[],int n)
{
int length=1;
while (length<n)
{
MergePass(R,R1,length,n);
length=2*length;
MergePass(R1,R,length,n);
length=2*length;
}
}
void MergeSort(SqList &L)
{
start_t=clock();
BeforeSort();
MSort(L.elem,L.elem,L.length);
display(yd1,bj1);
end_t=clock();
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}

void main()
{
SqList L;
addlist(L);
printf("起泡排序: \n");
qipao(L);
addlist(L);
printf("直插排序: \n");
InsertSort(L);
addlist(L);
printf("选择排序: \n");
SelectSort(L);
addlist(L);
printf("希尔排序: \n");
xier(L);
addlist(L);
printf("快速排续: \n");
QuickSort(L);
addlist(L);
printf("归并排序: \n");
MergeSort(L);
}

下面附加一下基本的顺序表和链表的操作

/* 设一个递增有序顺序表L，将x插入L中，使L仍有序。*/
#include <iostream>
usingnamespace std;
#define INITSIZE 100
typedef int ElemType;

typedef struct{
ElemType *elem;
int initsize;
int length;
}SqList;

void CreatSL(SqList &L,int n)
{

L.elem=new ElemType[INITSIZE];
L.initsize=INITSIZE;
L.length=n;
cout<<"请按从小到大输入顺序表的元素："<<endl;

for(int i=0;i<L.length;i++)
cin>>L.elem[i];
cout<<"所创建的递增有序的顺序表为："<<endl;

for(int j=0;j<L.length;j++)
cout<<L.elem[j]<<"";
cout<<endl;
}
void Insert(SqList L,ElemType e)
{
int i=0;
while((i<L.length)&&(L.elem[i]<=e)) i++;
if(i<L.length)
{
for(int j=L.length;j>i;j--)//用法一
L.elem[j]=L.elem[j-1];
L.elem[i]=e;
/*//用法二
for(int j=L.length-1;j>i-1;j--)
L.elem[j+1]=L.elem[j];
L.elem[i]=e;
*/
}
else L.elem[L.length]=e;
L.length=L.length+1;
cout<<"插入后的顺序表为："<<endl;
for(int k=0;k<L.length;k++)
{
cout<<L.elem[k]<<"";
}
cout<<endl;
}

void main()
{

int n;
ElemType e;
SqList L;
cout<<"请输入顺序表的元素个数：";
cout<<endl;
cin>>n;

CreatSL(L,n);
cout<<"请输入要插入的元素：";
cin>>e;
Insert(L,e);
}

/* 设一个递减有序顺序表L，将x插入L中，使L仍有序。*/
#include <iostream>
usingnamespace std;
#define INITSIZE 100
typedef int ElemType;
typedef struct{
ElemType *elem;
int initsize;
int length;
}SqList;
void CreatSL(SqList &L,int n)
{
L.elem=new ElemType[INITSIZE];
L.initsize=INITSIZE;
L.length=n;
cout<<"请按从大到小输入顺序表的元素：";
for(int i=0;i<L.length;i++)
cin>>L.elem[i];
cout<<"所创建的递减有序的顺序表为：";
for(int j=0;j<L.length;j++)
cout<<L.elem[j]<<"";
cout<<endl;
}
void Insert(SqList L,ElemType e)
{
int i=0;
while((i<L.length)&&(L.elem[i]>=e)) i++;
if(i<L.length)
{
for(int j=L.length;j>i;j--)//用法一
L.elem[j]=L.elem[j-1];
L.elem[i]=e;
/*//用法二
for(int j=L.length-1;j>i-1;j--)
L.elem[j+1]=L.elem[j];
L.elem[i]=e;
*/
}
else L.elem[L.length]=e;
L.length=L.length+1;
cout<<"插入后的顺序表为：";
for(int k=0;k<L.length;k++)
{
cout<<L.elem[k]<<"";
}
cout<<endl;
}
void main()
{
int n;
ElemType e;
SqList L;
cout<<"请输入顺序表的元素个数：";
cin>>n;
CreatSL(L,n);
cout<<"请输入要插入的元素：";
cin>>e;
Insert(L,e);
}

/*2.11 ①设A和B是两个递增有序的单链表，把他们归并成一个递减有序的单链表C，②并要求辅助空间为O（1）。
(这道题处于极度变态的边沿中，让我怀疑它还是题目吗，还是题目有误。我个人认为，条件①和条件②，不能同时达成，要把两个递增的有序表合并成一个递减的有序链表则辅助空间就不可能为O（1）。辅助空间要为O（1）的话就只能合并成递增的有序表，这纯属我个人研究结果，要是哪位做得出来两个条件都符合的话，记得告诉我一下啊！)
以下代码为：把两个递增有序的链表归并为一个递减有序链表
*/
#include<iostream>
usingnamespace std;
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode *LinkList;
void CreatList(LinkList &L,int n) //创立链表
{
LinkList p,q;
L=new LNode;
L->next=NULL;
q=L;
cout<<"请从小到大输入链表的元素：";
for(int i=1;i<=n;i++)
{
p=new LNode;
cin>>p->data;
p->next=q->next;
q->next=p;
q=q->next;
}
cout<<"所创建得的递增有序链表为：";
p=L->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void CreatC(LinkList &A,LinkList &B,LinkList &C,int n) //合并链表
{
C=new LNode;
C->next=NULL;
LinkList p,q,t;
p=A->next;
q=B->next;
while(p&&q)
{
t=new LNode;
if(p->data<=q->data)
{
t->data=p->data;
p=p->next;
}
else
{
t->data=q->data;
q=q->next;

}
t->next=C->next;
C->next=t;
}
while(p)
{
t=new LNode;
t->data=p->data;
t->next=C->next;
C->next=t;
p=p->next;
}
while(q)
{
t=new LNode;
t->data=q->data;
t->next=C->next;
C->next=t;
q=q->next;
}
cout<<"合并后的递减有序链表为：";
p=C->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void main()
{
LinkList A,B,C;
int n,m,k;
cout<<"请输入链表***A***的长度：";
cin>>n;
CreatList(A,n);
cout<<"请输入链表***B***的长度：";
cin>>m;
CreatList(B,m);
k=m+n;
CreatC(A,B,C,k);
}

/* 2.11 ①设A和B是两个递增有序的单链表，把他们归并成一个递减有序的单链表C，②并要求辅助空间为O（1）。
(这道题处于极度变态的边沿中，让我怀疑它还是题目吗，还是题目有误。我个人认为，条件①和条件②，不能同时达成，要把两个递增的有序表合并成一个递减的有序链表则辅助空间就不可能为O（1）。辅助空间要为O（1）的话就只能合并成递增的有序表，这纯属我个人研究结果，要是哪位做得出来两个条件都符合的话，记得告诉我一下啊！)
*/
//以下代码为：把两个递增有序的单链表归并为一个递增有序的链表，辅助空间为O（1）
#include<iostream>
usingnamespace std;
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode *LinkList;
void CreatList(LinkList &L,int n) //创立链表
{
LinkList p,q;
L=new LNode;
L->next=NULL;
q=L;
cout<<"请从小到大输入链表的元素：";
for(int i=1;i<=n;i++)
{
p=new LNode;
cin>>p->data;
p->next=q->next;
q->next=p;
q=q->next;
}
cout<<"所创建得的递增有序链表为：";
p=L->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void CreatC(LinkList &A,LinkList &B,LinkList &C,int n) //合并链表
{
LinkList p,q,t;
p=A->next;
q=B->next;
C=t=A;
while(p&&q)
{
if(p->data<=q->data)
{
t->next=p;
t=p;
p=p->next;
}
else
{
t->next=q;
t=q;
q=q->next;
}
}
t->next=p?p:q;
delete B;
cout<<"合并后的递增有序链表为：";
p=C->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}

void main()
{
LinkList A,B,C;
int n,m,k;
cout<<"请输入链表***A***的长度：";
cin>>n;
CreatList(A,n);
cout<<"请输入链表***B***的长度：";
cin>>m;
CreatList(B,m);
k=m+n;
CreatC(A,B,C,k);
}

/* 2.12 设L是递增有序单链表，删除其中大于min且小于max的元素结点，并释放结点空间。
(有点部分和上次那份上机题的那道C卷的不一样，用法简单一点，大家看一下)
*/

#include<iostream>
usingnamespace std;
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode *LinkList;
void CreatList(LinkList &L,int n)
{
LinkList p,q;
L=new LNode;
L->next=NULL;
q=L;
cout<<"请从小到大输入链表的元素：\n";
for(int i=1;i<=n;i++)
{
p=new LNode;
cin>>p->data;
p->next=q->next;
q->next=p;
q=q->next;
}
cout<<"所创建得的递增有序链表为：";
p=L->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void Find(LinkList &L,ElemType min,ElemType max,int n)
{
LinkList p,t;
p=L;
while(p->next)
{
if((p->next->data>min)&&(p->next->data<max))
{
t=p->next;
p->next=t->next;
delete t;
n--;
}
else
{
p=p->next;
}
}
cout<<"操作后的递增有序链表为：";
p=L->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void main()
{
LinkList L;
int n;
ElemType min,max;
cout<<"请输入链表的长度：";
cin>>n;
CreatList(L,n);
cout<<"请输入min的值：";
cin>>min;
cout<<"请输入max的值：";
cin>>max;
Find(L,min,max,n);
}

/* 2.13 将单链表中值重复的结点删除，使所得的单链表中各结点值均不同。*/
#include<iostream>
usingnamespace std;
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode* LinkList;
void CreatLN(LinkList &L,int n)
{
L=new LNode;
L->next=NULL;
LinkList p,q;
q=L;
cout<<"请输入链表元素：";
for(int i=1;i<=n;i++)
{
p=new LNode;
cin>>p->data;
p->next=q->next;
q->next=p;
q=q->next;
}
cout<<"创建的单链表为：";
p=L->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void delet(LinkList &L,int n)
{
LinkList p,q,t,w;
p=L->next;
while(p)
{
t=p;
q=p->next;
while(q)
{
if(p->data!=q->data) {q=q->next;t=t->next;}
else
{
w=q;
t->next=q->next;
q=t->next;
delete w;
n--;
}
}
p=p->next;
}
cout<<"删除相同结点后的单链表为：";
p=L->next;
for(int j=1;j<=n;j++)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
void main()
{
LinkList L;
int n;
cout<<"请输入链表的元素个数:";
cin>>n;
CreatLN(L,n);
delet(L,n);
}

/*
建立一个数据为整数的单链表L,然后将该链表中的数据域值最小的那个结点移到链表的最前端
第一步：建立一个单链表
第2：显示该单链表
第3：查找链表中数据域最小的值，并将它移到到链表的最前端
第4：显示该单链表

*/

#include <iostream>
usingnamespace std;

#define LIST_INIT_SIZE 100 //存储空间初始分配量
#define LIST_INCREMENT 10 //存储空间增补量
/*线性表方法类*/
typedef int ElemType;
typedef struct LNode{
ElemType data; //
struct LNode *next; //
}LNode;

typedef LNode *LinkList; //

void InitList_L(LinkList &L,int n){
//构造空单链表L
LinkList p;
L=new LNode; L->next=NULL;
cout<<"请输入您要输入的数据(逆序)：\n";
for(int i=0;i<n;++i){
p=new LNode;
cin>>p->data;
p->next=L->next;
L->next=p;
}
} //InitList_L

void PrintList(LinkList L){
LinkList p;
cout<<"你输入的数据输出为：\n";
p=L->next;
while(p)
{
cout<<p->data<<"";
p=p->next;
}
}

void FindList(LinkList L)
{
LinkList o,p,q;
p=L->next;
o=L->next;
int n=p->data;
while(p)
{
if(n>p->data)
{
n=p->data;
q=p;
}
p=p->next;
}
cout<<"\n链表中最小的结点数据域值为：\n";
cout<<n<<endl;
cout<<"链表中最小的结点移到链表的最前端链表输出为:\n";
cout<<n<<"";
while(o)
{
if(o->data==n)
{
LNode *q=o;o=q->next;
delete q;
}
else
{
cout<<o->data<<"";
o=o->next;
}
}

}

void main(){
int n;
LinkList L;
cout<<"请输入链表中元素的个数：\n";
cin>>n;
InitList_L(L,n);
PrintList(L);
FindList(L);
cout<<endl;
}

附加:常用数据结构

数组 (Array)
在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来。这些按序排列的同类数据元素的集合称为数组。在Ｃ语言中，
数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

栈 (Stack)
是只能在某一端插入和删除的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。
队列 (Queue)
一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。

链表 (Linked List)
是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
树 (Tree)
是包含n（n>0）个结点的有穷集合K，且在K中定义了一个关系N，N满足以下条件：
（1）有且仅有一个结点
k0，他对于关系N来说没有前驱，称K0为树的根结点。简称为根（root）。　
（2）除K0外，k中的每个结点，对于关系N来说有且仅有一个前驱。
（3）K中各结点，对关系N来说可以有m个后继（m>=0）。
图 (Graph)
图是由结点的有穷集合V和边的集合E组成。其中，为了与树形结构加以区别，在图结构中常常将结点称为顶点，边是顶点的有序偶对，若两个顶点之间存在一条边，就表示这两个顶点具有相邻关系。
堆 (Heap)
在计算机科学中，堆是一种特殊的树形数据结构，每个结点都有一个值。通常我们所说的堆的数据结构，是指二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。
散列表 (Hash)
若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数(Hash function)，按这个思想建立的表为

后记
具体我就不调试结果出来了，要想知道结果怎么样，还得大家自己回去按照代码编程一遍，编写不对或者有其他问题可以留言交流，谢谢大家了！！！

参考：
        严蔚敏，吴伟民编著图书 ---《数据结构与算法》
        百度百科——数据结构

作者：类菌体
出处：http://www.cnblogs.com/bacteroid/archive/2011/07/31/2122910.html
关于作者：在校学生
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接
如有问题，可以通过303323670@qq.com 联系我，非常感谢。
本文链接

分享一个大学期间为企业做的个人CMS(使用ASP.NET+Access)

2011-07-05T04:21:00Z

前言：

笔者今年大三了，等7号最后一科考试结束，大三就结束了，等着去暑假实习，希望在大学还剩下一年的时间，把自己总结的知识以及可以看的东西分享一下，希望得到新手的喜欢，以及盼望得到园里很多高手的指点，个人CMS主要是实现文章内容管理，图片管理，管理员管理，留言互动管理等等..完美的三层架构，数据库采用Access,免去独立买数据库空间所需的费用...

看到好多园友回复，谢谢提醒，我把网站地址删除了，我担心园里高手比较多，因为这个还有很多注意的地方，以及用户的使用目的，我没有考虑到很多安全方面；我在这里声明一下，这个CMS本身还存有bug,所以请采用这个来学习的朋友，可以在这个基础上学习一下简单三层，温故一下面向对象的思想，做商业开发的朋友请在这个基础上克服各种bug...

在这里再一次感谢那么多园友，朋友的宝贵的意见，不管是好的意见还是无情的批评，我都把他们当作是一股学习动力，我会把你们的意见带回到暑假去实现，争取在安全还有其他技术上有所努力长进....（另外可以加我Q沟通:303323670）

下面都是我用个人CMS给企业做的一些样本，大家可以看一下，如果觉得做的不是很好，那请你们用熟悉的键盘，打下你宝贵的意见，谢谢了！付贴图分享：

1：邦华智能科技

完成时间是2011年5月-7月

用户是：邦华智能科技有限公司

开发者：类菌体

收入：1200元

截图：

2：臻琪装饰

完成时间是2010年10月-11月

用户是：臻琪装饰有限公司

开发者：类菌体

收入：1000元

截图：

3：索菲娅教育

完成时间是2009年7月-9月

用户是：索菲娅教育有限公司

开发者：类菌体

收入：1150元

截图：

4：学生会网站

完成时间是2009年5月

用户是：广西师范大学学生会

开发者：类菌体

备注：（单层模式新手学习参考超过100人）源码下载：xsh

截图：

总结：

大学做网站是我的一个兴趣而已，另一个方面是作为自己生活费的来源，完成一个网站有一千多块钱，够自己生活和学习的一点补贴，得知暑假实习的主要内容是

基于ASP.Net的WebGIS框架开发；
基于Android操作系统的桌面软件开发；

也许这以后可能也不会再做了，留着备份，回忆起来~大三快要结束了，我的大学也快要接近尾声，明年现在这个时候，我想我们就要离开学校走向社会了，不管结果怎么样，但是我一定会让自己在仍有青春活力的年龄里在拼一拼，加油~

请看下面附件，大家用代码来讨论吧

附件：

GXNUNC-code-PersonalCms

作者：类菌体
出处：http://www.cnblogs.com/bacteroid/archive/2011/07/05/2098187.html
关于作者：在校学生
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接
如有问题，可以通过303323670@qq.com 联系我，非常感谢。

本文链接