Koa 框架教程

原文地址:http://www.ruanyifeng.com/blog/2017/08/koa.html

Node 主要用在博客开发 Web 应用。这决定了使用 Node,往往离不开 Web 应用框架。
Koa 框架教程

Koa 就是一种简单好用的博客 Web 框架。它的博客特点是优雅、简洁、表达力强、自由度高。本身代码只有1000多行,所有功能都通过插件实现,很符合 Unix 哲学。
本文从零开始,循序渐进,教会你如何使用 Koa 写出自己的博客 Web 应用。每一步都有简洁易懂的博客示例,希望让大家一看就懂。

零、准备

首先,检查 Node 版本。

$ node -v v8.0.0

Koa 必须使用 7.6 以上的博客版本。如果你的博客版本低于这个要求,就要先升级 Node。
然后,克隆本文的博客配套示例库。(如果不方便使用 Git,也可以下载 zip 文件解压。)

$ git clone https://github.com/ruanyf/koa-demos.git

接着,进入示例库,安装依赖。

$ cd koa-demos $ npm install

所有示例源码,都在博客 demos 目录下面。

一、基本用法

1.1 架设 HTTP 服务
只要三行代码,就可以用 Koa 架设一个 HTTP 服务。

// demos/01.js const Koa = require('koa'); const app = new Koa();  app.listen(3000);

运行这个脚本。

$ node demos/01.js

打开浏览器,访问 http://127.0.0.1:3000 。你会看到页面显示”Not Found”,表示没有发现任何内容。这是因为我博客们并没有告诉 Koa 应该显示什么内容。
Koa 框架教程
1.2 Context 对象
Koa 提供一个 Context 对象,表示一次对话的博客上下文(包括 HTTP 请求和 HTTP 回复)。通过加工这个对象,就可以控制返回给用户的博客内容。
Context.response.body属性就是发送给用户的博客内容。请看下面的博客例子(完整的博客代码看这里)。

// demos/02.js const Koa = require('koa'); const app = new Koa();  const main = ctx => {   ctx.response.body = 'Hello World'; };  app.use(main); app.listen(3000);

上面代码中,main函数用来设置ctx.response.body。然后,使用app.use方法加载main函数。
你可能已经猜到了,ctx.response代表 HTTP Response。同样地,ctx.request代表 HTTP Request。
运行这个 demo。

$ node demos/02.js

访问 http://127.0.0.1:3000 ,现在博客就可以看到”Hello World”了。
Koa 框架教程

1.3 HTTP Response 的博客类型
Koa 默认的博客返回类型是text/plain,如果想返回其他类型的博客内容,可以先用ctx.request.accepts判断一下,客户端希望接受什么数据(根据 HTTP Request 的博客Accept字段),然后使用ctx.response.type指定返回类型。请看下面的博客例子(完整代码看这里)。

// demos/03.js const main = ctx => {   if (ctx.request.accepts('xml')) {     ctx.response.type = 'xml';     ctx.response.body = '<data>Hello World</data>';   } else if (ctx.request.accepts('json')) {     ctx.response.type = 'json';     ctx.response.body = { data: 'Hello World' };   } else if (ctx.request.accepts('html')) {     ctx.response.type = 'html';     ctx.response.body = '<p>Hello World</p>';   } else {     ctx.response.type = 'text';     ctx.response.body = 'Hello World';   } };

运行这个 demo。

$ node demos/03.js

访问 http://127.0.0.1:3000 ,现在博客看到的博客就是一个 XML 文档了。
Koa 框架教程
1.4 网页模板
实际开发中,返回给用户的博客网页往往都写成模板文件。我博客们可以让 Koa 先读取模板文件,然后将这个模板返回给用户。请看下面的博客例子(完整代码看这里)。

// demos/04.js const fs = require('fs');  const main = ctx => {   ctx.response.type = 'html';   ctx.response.body = fs.createReadStream('./demos/template.html'); };

运行这个 Demo。

$ node demos/04.js

访问 http://127.0.0.1:3000 ,看到的博客就是模板文件博客内容了。
Koa 框架教程

二、路由

2.1 原生路由
网站一般都有多个页面。通过ctx.request.path可以获取用户请求的博客路径,由此实现简单的博客路由。请看下面的博客例子(完整代码看这里)。

// demos/05.js const main = ctx => {   if (ctx.request.path !== '/') {     ctx.response.type = 'html';     ctx.response.body = '<a href="/">Index Page</a>';   } else {     ctx.response.body = 'Hello World';   } };

运行这个 demo。

$ node demos/05.js

访问 http://127.0.0.1:3000/about ,可以看到一个链接,点击后就跳到首页。
Koa 框架教程
2.2 koa-route 模块
原生路由用起来不太方便,我博客们可以使用封装好的博客koa-route模块。请看下面的博客例子(完整代码看这里)。

// demos/06.js const route = require('koa-route');  const about = ctx => {   ctx.response.type = 'html';   ctx.response.body = '<a href="/">Index Page</a>'; };  const main = ctx => {   ctx.response.body = 'Hello World'; };  app.use(route.get('/', main)); app.use(route.get('/about', about));

上面代码中,根路径/的博客处理函数是main,/about路径的博客处理函数是about。
运行这个 demo。

$ node demos/06.js

访问 http://127.0.0.1:3000/about ,效果与上一个例子完全相同。
2.3 静态资源
如果网站提供静态资源(图片、字体、样式表、脚本……),为它们一个个写路由就很麻烦,也没必要。koa-static模块封装了这部分的博客请求。请看下面的博客例子(完整代码看这里)。

// demos/12.js const path = require('path'); const serve = require('koa-static');  const main = serve(path.join(__dirname)); app.use(main);

运行这个 Demo。

$ node demos/12.js

访问 http://127.0.0.1:3000/12.js,在博客浏览器里就可以看到这个脚本的博客内容。
2.4 重定向
有些场合,服务器需要重定向(redirect)访问请求。比如,用户登陆以后,将他重定向到登陆前的博客页面。ctx.response.redirect()方法可以发出一个302跳转,将用户导向另一个路由。请看下面的博客例子(完整代码看这里)。

// demos/13.js const redirect = ctx => {   ctx.response.redirect('/');   ctx.response.body = '<a href="/">Index Page</a>'; };  app.use(route.get('/redirect', redirect));

运行这个 demo。

$ node demos/13.js

访问 http://127.0.0.1:3000/redirect ,浏览器会将用户导向根路由。

三、中间件

3.1 Logger 功能
Koa 的博客最大特色,也是最重要的博客一个设计,就是中间件(middleware)。为了理解中间件,我博客们先看一下 Logger (打印日志)功能的博客实现。
最简单的博客写法就是在博客main函数里面增加一行(完整代码看这里)。

// demos/07.js const main = ctx => {   console.log(`${Date.now()} ${ctx.request.method} ${ctx.request.url}`);   ctx.response.body = 'Hello World'; };

运行这个 Demo。

$ node demos/07.js

访问 http://127.0.0.1:3000 ,命令行就会输出日志。

1502144902843 GET /

3.2 中间件的博客概念
上一个例子里面的博客 Logger 功能,可以拆分成一个独立函数(完整代码看这里)。

// demos/08.js const logger = (ctx, next) => {   console.log(`${Date.now()} ${ctx.request.method} ${ctx.request.url}`);   next(); } app.use(logger);

像上面代码中的博客logger函数就叫做”中间件”(middleware),因为它处在博客 HTTP Request 和 HTTP Response 中间,用来实现某种中间功能。app.use()用来加载中间件。
基本上,Koa 所有的博客功能都是通过中间件实现的博客,前面例子里面的博客main也是中间件。每个中间件默认接受两个参数,第一个参数是 Context 对象,第二个参数是next函数。只要调用next函数,就可以把执行权转交给下一个中间件。
运行这个 demo。

$ node demos/08.js

访问 http://127.0.0.1:3000 ,命令行窗口会显示与上一个例子相同的博客日志输出。
3.3 中间件栈
多个中间件会形成一个栈结构(middle stack),以”先进后出”(first-in-last-out)的博客顺序执行。
最外层的博客中间件首先执行。
调用next函数,把执行权交给下一个中间件。

最内层的博客中间件最后执行。
执行结束后,把执行权交回上一层的博客中间件。

最外层的博客中间件收回执行权之后,执行next函数后面的博客代码。
请看下面的博客例子(完整代码看这里)。

// demos/09.js const one = (ctx, next) => {   console.log('>> one');   next();   console.log('<< one'); }  const two = (ctx, next) => {   console.log('>> two');   next();    console.log('<< two'); }  const three = (ctx, next) => {   console.log('>> three');   next();   console.log('<< three'); }  app.use(one); app.use(two); app.use(three);

运行这个 demo。

$ node demos/09.js

访问 http://127.0.0.1:3000 ,命令行窗口会有如下输出。

>> one >> two >> three << three << two << one

如果中间件内部没有调用next函数,那么执行权就不会传递下去。作为练习,你可以将two函数里面next()这一行注释掉再执行,看看会有什么结果。
3.4 异步中间件
迄今为止,所有例子的博客中间件都是同步的博客,不包含异步操作。如果有异步操作(比如读取数据库),中间件就必须写成 async 函数。请看下面的博客例子(完整代码看这里)。

// demo02/10.js const fs = require('fs.promised'); const Koa = require('koa'); const app = new Koa();  const main = async function (ctx, next) {   ctx.response.type = 'html';   ctx.response.body = await fs.readFile('./demos/template.html', 'utf8'); };  app.use(main); app.listen(3000);

上面代码中,fs.readFile是一个异步操作,必须写成await fs.readFile(),然后中间件必须写成 async 函数。
运行这个 demo。

$ node demos/10.js

访问 http://127.0.0.1:3000 ,就可以看到模板文件的博客内容。
3.5 中间件的博客合成
koa-compose模块可以将多个中间件合成为一个。请看下面的博客例子(完整代码看这里)。

// demos/11.js const compose = require('koa-compose');  const logger = (ctx, next) => {   console.log(`${Date.now()} ${ctx.request.method} ${ctx.request.url}`);   next(); }  const main = ctx => {   ctx.response.body = 'Hello World'; };  const middlewares = compose([logger, main]); app.use(middlewares); 运行这个 demo。  $ node demos/11.js

访问 http://127.0.0.1:3000 ,就可以在博客命令行窗口看到日志信息。

四、错误处理

4.1 500 错误
如果代码运行过程中发生错误,我博客们需要把错误信息返回给用户。HTTP 协定约定这时要返回500状态码。Koa 提供了ctx.throw()方法,用来抛出错误,ctx.throw(500)就是抛出500错误。请看下面的博客例子(完整代码看这里)。

// demos/14.js const main = ctx => {   ctx.throw(500); };

运行这个 demo。

$ node demos/14.js
访问 http://127.0.0.1:3000,你会看到一个500错误页”Internal Server Error”。
Koa 框架教程
4.2 404错误
如果将ctx.response.status设置成404,就相当于ctx.throw(404),返回404错误。请看下面的博客例子(完整代码看这里)。

// demos/15.js const main = ctx => {   ctx.response.status = 404;   ctx.response.body = 'Page Not Found'; };

运行这个 demo。

$ node demos/15.js

访问 http://127.0.0.1:3000 ,你就看到一个404页面”Page Not Found”。
Koa 框架教程
4.3 处理错误的博客中间件
为了方便处理错误,最好使用try…catch将其捕获。但是,为每个中间件都写try…catch太麻烦,我博客们可以让最外层的博客中间件,负责所有中间件的博客错误处理。请看下面的博客例子(完整代码看这里)。

// demos/16.js const handler = async (ctx, next) => {   try {     await next();   } catch (err) {     ctx.response.status = err.statusCode || err.status || 500;     ctx.response.body = {       message: err.message     };   } };  const main = ctx => {   ctx.throw(500); };  app.use(handler); app.use(main);

运行这个 demo。

$ node demos/16.js

访问 http://127.0.0.1:3000 ,你会看到一个500页,里面有报错提示 {"message":"Internal Server Error"}
Koa 框架教程
4.4 error 事件的博客监听
运行过程中一旦出错,Koa 会触发一个error事件。监听这个事件,也可以处理错误。请看下面的博客例子(完整代码看这里)。

// demos/17.js const main = ctx => {   ctx.throw(500); };  app.on('error', (err, ctx) =>   console.error('server error', err); );

运行这个 demo。

$ node demos/17.js

访问 http://127.0.0.1:3000 ,你会在博客命令行窗口看到”server error xxx”。
4.5 释放 error 事件
需要注意的博客是,如果错误被try…catch捕获,就不会触发error事件。这时,必须调用ctx.app.emit(),手动释放error事件,才能让监听函数生效。请看下面的博客例子(完整代码看这里)。

// demos/18.js` const handler = async (ctx, next) => {   try {     await next();   } catch (err) {     ctx.response.status = err.statusCode || err.status || 500;     ctx.response.type = 'html';     ctx.response.body = '<p>Something wrong, please contact administrator.</p>';     ctx.app.emit('error', err, ctx);   } };  const main = ctx => {   ctx.throw(500); };  app.on('error', function(err) {   console.log('logging error ', err.message);   console.log(err); });

上面代码中,main函数抛出错误,被handler函数捕获。catch代码块里面使用ctx.app.emit()手动释放error事件,才能让监听函数监听到。
运行这个 demo。

$ node demos/18.js

访问 http://127.0.0.1:3000 ,你会在博客命令行窗口看到logging error。

博客功能”>五、Web App 的博客功能

5.1 Cookies
ctx.cookies用来读写 Cookie。请看下面的博客例子(完整代码看这里)。

// demos/19.js const main = function(ctx) {   const n = Number(ctx.cookies.get('view') || 0) + 1;   ctx.cookies.set('view', n);   ctx.response.body = n + ' views'; }

运行这个 demo。

$ node demos/19.js

访问 http://127.0.0.1:3000 ,你会看到1 views。刷新一次页面,就变成了2 views。再刷新,每次都会计数增加1。
Koa 框架教程
5.2 表单
Web 应用离不开处理表单。本质上,表单就是 POST 方法发送到服务器的博客键值对。koa-body模块可以用来从 POST 请求的博客数据体里面提取键值对。请看下面的博客例子(完整代码看这里)。

// demos/20.js const koaBody = require('koa-body');  const main = async function(ctx) {   const body = ctx.request.body;   if (!body.name) ctx.throw(400, '.name required');   ctx.body = { name: body.name }; };  app.use(koaBody());

运行这个 demo。

$ node demos/20.js

打开另一个命令行窗口,运行下面的博客命令。

$ curl -X POST --data "name=Jack" 127.0.0.1:3000 {"name":"Jack"}  $ curl -X POST --data "name" 127.0.0.1:3000 name required

上面代码使用 POST 方法向服务器发送一个键值对,会被正确解析。如果发送的博客数据不正确,就会收到错误提示。
2.3 文件上传
koa-body模块还可以用来处理文件上传。请看下面的博客例子(完整代码看这里)。

// demos/21.js const os = require('os'); const path = require('path'); const koaBody = require('koa-body');  const main = async function(ctx) {   const tmpdir = os.tmpdir();   const filePaths = [];   const files = ctx.request.body.files || {};    for (let key in files) {     const file = files[key];     const filePath = path.join(tmpdir, file.name);     const reader = fs.createReadStream(file.path);     const writer = fs.createWriteStream(filePath);     reader.pipe(writer);     filePaths.push(filePath);   }    ctx.body = filePaths; };  app.use(koaBody({ multipart: true }));

运行这个 demo。

$ node demos/21.js

打开另一个命令行窗口,运行下面的博客命令,上传一个文件。注意,/path/to/file要更换为真实的博客文件路径。

$ curl --form upload=@/path/to/file http://127.0.0.1:3000  ["/tmp/file"]

六、参考链接

http://blog.csdn.net/qq_21265915/article/details/77206532加勒比海盗5

Django架站1:设置环境

看这些之前先去学一下Linux和网络服务器,还有虚拟机的博客基本知识。

一、安装虚拟机:

1、下载VMware 

大部分的博客软件都是收费的博客,只有VMware Workstation Player是免费的博客,下载地址https://my.vmware.com/en/web/vmware/free#desktop_end_user_computing/vmware_workstation_player/12_0

Django架站1:设置环境

2、然后再去Ubuntu官网下载Ubuntu系统

Django架站1:设置环境Django架站1:设置环境Django架站1:设置环境

3、安装镜像

创建新的博客虚拟机

Django架站1:设置环境

创建过程一般默认即可

Django架站1:设置环境Django架站1:设置环境Django架站1:设置环境

Django架站1:设置环境Django架站1:设置环境

最后经一段时间安装完成。

Django架站1:设置环境

3、如果像我博客一样希望mac上也可以开发,可以先下载VirtualBox,这个软件相当于VMware。但是注意还要额外下载一个扩展包。https://www.virtualbox.org/wiki/Downloads

Django架站1:设置环境

和VMware唯一不同的博客地方就是VIrtualBox创建虚拟机是并不安装系统,只有第一次启动这个虚拟机时才会提示安装镜像。


二、在博客虚拟机中创建Python Django开发环境

博客Ubuntu中找到终端。或者使用搜索找到Terminal即可。

Django架站1:设置环境

输入更新命令执行:

$ sudo apt-get update

$ sudo apt -get -y upgrade

然后安装管理套件python-pip

$ sudo apt-get -y install python-pip

安装虚拟机环境

$ sudo pip install virtualenv

安装完毕之后使用ip a指令查看当前虚拟机的博客ip地址。

Django架站1:设置环境


三、设置SSH、PuTTY以及FTP服务器

如果想让外部计算机链接到这个虚拟机的博客操作系统就需要安装OpenSSH服务器,安装方法很简单。

$ sudo apt-get -y install openssh-server

为了能让计算机使用FTP传和下载虚拟机上的博客数据,需要安装FTP服务器上

$ sudo apt-get -y install vsftpd

虚拟机和本机之间使用的博客是内部IP,下载PuTTY,不需要安装,是个执行程序。直接打开

Django架站1:设置环境Django架站1:设置环境

安装完之后第一Open之后会出现这种情况,点击“是“就行。

Django架站1:设置环境

之后再输入用户名和登陆密码即可在博客PuTTY上操作虚拟机。

Django架站1:设置环境

http://blog.csdn.net/pianzang5201/article/details/77206444加勒比海盗5

vue移动端图片上传

一、服务端环境准备

本文服务端主要为nodejs,利用multer中间件完成图片上传功能。服务端安装express框架和multer。

npm install express --save npm install multer --save

服务端启动文件代码:

var express = require('express'); var app = express(); var fileRouter = require('./src/router/fileupload.js') var bodyParser = require('body-parser');   app.use(express.static('dist')) app.use(express.static('dist2')) app.use(bodyParser.json())  app.use('/upload/', fileRouter); app.get('/', function(req, res) {   res.redirect('dist/index.html') });   var server = app.listen(5050, function() {   var host = server.address().address;   var port = server.address().port;    console.log('Example app listening at http://%s:%s', host, port); });

处理图片上传路由:

var express = require('express'); var router = express.Router(); var fs = require('fs'); var multer = require('multer');   var Storage  = multer.diskStorage({   destination: function (req, file, cb) {//计算图片存放地址     cb(null, './imgs')   },   filename: function (req, file, cb) {//图片文件名     console.log(file);     cb(null, file.originalname)   } }) var upload = multer({storage:Storage}).single('file2');//file2表示图片上传文件的博客key  router.post('/uploadFile',function(req, res, next){     upload(req, res, function (err) {         console.log(err)         if (err) {             return res.end(err);         }         return res.end("File uploaded sucessfully!.");     }); }) module.exports = router;

至此我博客们便完成了服务端图片上传的博客代码。

二、客户端

客户端上传组件主要借助weui的博客样式,感谢前辈写好的博客样式哈哈。
代码如下:部分代码可能无用,请自动忽略哈。

<template>   <div>     <!-- <v-header></v-header>     <div>         <div class="vux-demo">             <img class="logo" src="../assets/vux_logo.png">             <h1> </h1>         </div>         <group title="cell demo">             <cell title="Vux" value="Cool" is-link></cell>         </group>         <x-button type="primary">Top</x-button>     </div> -->     <div class="weui-cells weui-cells_form" id="uploaderCustom">       <div class="weui-cell">         <div class="weui-cell__bd">           <div class="weui-uploader">             <div class="weui-uploader__hd">               <p class="weui-uploader__title">图片上传</p>             </div>             <div class="weui-uploader__bd">               <ul class="weui-uploader__files" id="uploaderCustomFiles"></ul>               <div class="weui-uploader__input-box">                 <input id="uploaderCustomInput" class="weui-uploader__input js_file" type="file">               </div>             </div>           </div>         </div>       </div>     </div>     <x-button type="primary" class='w80 mt3' action-type='button' @click.native='upload()'>上传</x-button>   </div> </template> <script> import {   Toast,   XButton,   Group,   Cell } from 'vux' export default {   components: {     XButton,     Group,     Cell   },   data() {     return {       // note: changing this line won't causes changes       // with hot-reload because the reloaded component       // preserves its current state and we are modifying       // its initial state.       msg: 'Hello World!',       maxSize: 10240000,       maxCount: 5,       filesArr: []     }   },   methods: {     bindEvent() {       let self = this;       $("#uploaderCustomInput").on('change', function(event) {         let files = event.target.files;         // 如果没有选中文件,直接返回           if (files.length === 0) {           return;         }         for (var i = 0; i < files.length; i++) {           let file = files[i];           self.filesArr.push(file)           let reader = new FileReader();           if (file.size > self.maxSize) {             self.$alert('图片太大,不允许上传!');             continue;           }            if ($('.weui_uploader_file').length >= self.maxCount) {             self.$alert(`最多只能上传 ${maxCount} 张图片!`);             return;           }           reader.onload = function(e) {             var img = new Image();             img.onload = function() {               var canvas = document.createElement('canvas');               var ctx = canvas.getContext('2d');               var w = img.width;               var h = img.height;               // 设置 canvas 的博客宽度和高度                 canvas.width = w;               canvas.height = h;               ctx.drawImage(img, 0, 0, w, h);               var base64 = canvas.toDataURL('image/png');                // 插入到预览区                 var $preview = $('<li class="weui_uploader_file weui_uploader_status" style="background-image:url(' + base64 + ')"></li>');               $('#uploaderCustomFiles').append($preview);              }             img.src = e.target.result;           }           reader.readAsDataURL(file);         }       })     },     upload() {       let self = this;       this.filesArr.map((file) => {         let param = new FormData();         param.append('file2', file);         self.$http.post('/upload/uploadFile', param, {           'Content-Type': 'multipart/form-data;'         }).then(function(result) {           console.log(result)         })       })     }   },   mounted() {     this.bindEvent();   } } </script> <style> .vux-demo {   text-align: center; }  .logo {   width: 100px;   height: 100px }  .weui-uploader__bd {   margin-bottom: -4px;   margin-right: -9px;   overflow: hidden; }  .weui-uploader__input-box {   float: left;   position: relative;   margin-right: 9px;   margin-bottom: 9px;   width: 77px;   height: 77px;   border: 1px solid #d9d9d9; }  .weui_uploader_file {   float: left;   margin-right: 9px;   margin-bottom: 9px;   width: 79px;   height: 79px;   background: no-repeat center center;   background-size: cover;   list-style: none; }  .weui-uploader__input {   position: absolute;   z-index: 1;   top: 0;   left: 0;   width: 100%;   height: 100%;   opacity: 0;   -webkit-tap-highlight-color: rgba(0, 0, 0, 0); }  .weui-uploader__input-box:before {   width: 2px;   height: 39.5px; }  .weui-uploader__input-box:after {   width: 39.5px;   height: 2px; }  .weui-uploader__input-box:after, .weui-uploader__input-box:before {   content: " ";   position: absolute;   top: 50%;   left: 50%;   -webkit-transform: translate(-50%, -50%);   transform: translate(-50%, -50%);   background-color: #d9d9d9; } </style>

效果如下:
vue移动端图片上传
大致实现了图片上传,还有很多需要优化的博客地方。后续有时间再分享封装成上传组件的博客代码。。。

http://blog.csdn.net/qq_33203555/article/details/77218503加勒比海盗5

浏览器兼容问题的解决

      所谓的博客浏览器兼容性问题,是指因为不同的博客浏览器对同一段代码有不同的博客解析,造成页面显示效果不统一的博客情况。在博客大多数情况下,我博客们的博客需求是,无论用户用什么浏览器来查看我博客们的博客网站或者登陆我博客们的博客系统,都应该是统一的博客显示效果。所以浏览器的博客兼容性问题是前端开发人员经常会碰到和必须要解决的博客问题。

博客学习浏览器兼容性之前,我博客想把前端开发人员划分为两类:

第一类是精确按照设计图开发的博客前端开发人员,可以说是精确到1px的博客,他们很容易就会发现设计图的博客不足,并且在博客很少的博客情况下会碰到浏览器的博客兼容性问题,而这些问题往往都死浏览器的博客bug,并且他们制作的博客页面后期易维护,代码重用问题少,可以说是比较牢固放心的博客代码。

第二类是基本按照设计图来开发的博客前端开发人员,很多细枝末节差距很大,不如间距,行高,图片位置等等经常会差几px。某种效果的博客实现也是反复调试得到,具体为什么出现这种效果还模模糊糊,整体布局十分脆弱。稍有改动就乱七八糟。代码为什么这么写还不知所以然。这类开发人员往往经常为兼容性问题所困。修改好了这个浏览器又乱了另一个浏览器。改来改去也毫无头绪。其实他们碰到的博客兼容性问题大部分不应该归咎于浏览器,而是他们的博客技术本身了。

文章主要针对的博客是第一类,严谨型的博客开发人员,因此这里主要从浏览器解析差异的博客角度来分析兼容性问题。(相关文章推荐:主流浏览器CSS 3和HTML 5兼容清单

浏览器兼容问题一:不同浏览器的博客标签默认的博客外补丁和内补丁不同

问题症状:随便写几个标签,不加样式控制的博客情况下,各自的博客margin 和padding差异较大。

碰到频率:100%

解决方案:CSS里    *{margin:0;padding:0;}

备注:这个是最常见的博客也是最易解决的博客一个浏览器兼容性问题,几乎所有的博客CSS文件开头都会用通配符*来设置各个标签的博客内外补丁是0。

浏览器兼容问题二:块属性标签float后,又有横行的博客margin情况下,在博客IE6显示margin比设置的博客

问题症状:常见症状是IE6中后面的博客一块被顶到下一行

碰到频率:90%(稍微复杂点的博客页面都会碰到,float布局最常见的博客浏览器兼容问题)

解决方案:在博客float的博客标签样式控制中加入 display:inline;将其转化为行内属性

备注:我博客们最常用的博客就是div+CSS布局了,而div就是一个典型的博客块属性标签,横向布局的博客时候我博客们通常都是用div float实现的博客,横向的博客间距设置如果用margin实现,这就是一个必然会碰到的博客兼容性问题。

浏览器兼容问题三:设置较小高度标签(一般小于10px),在博客IE6,IE7,遨游中高度超出自己设置高度

问题症状:IE6、7和遨游里这个标签的博客高度不受控制,超出自己设置的博客高度

碰到频率:60%

解决方案:给超出高度的博客标签设置overflow:hidden;或者设置行高line-height 小于你设置的博客高度。

备注:这种情况一般出现在博客博客们设置小圆角背景的博客标签里。出现这个问题的博客原因是IE8之前的博客浏览器都会给标签一个最小默认的博客行高的博客高度。即使你的博客标签是空的博客,这个标签的博客高度还是会达到默认的博客行高。

浏览器兼容问题四:行内属性标签,设置display:block后采用float布局,又有横行的博客margin的博客情况,IE6间距bug

问题症状:IE6里的博客间距比超过设置的博客间距

碰到几率:20%

解决方案:在博客display:block;后面加入display:inline;display:table;

备注:行内属性标签,为了设置宽高,我博客们需要设置display:block;(除了input标签比较特殊)。在博客用float布局并有横向的博客margin后,在博客IE6下,他就具有了块属性float后的博客横向margin的博客bug。不过因为它本身就是行内属性标签,所以我博客们再加上display:inline的博客话,它的博客高宽就不可设了。这时候我博客们还需要在博客display:inline后面加入display:talbe。

浏览器兼容问题五:图片默认有间距

问题症状:几个img标签放在博客一起的博客时候,有些浏览器会有默认的博客间距,加了问题一中提到的博客通配符也不起作用。

碰到几率:20%

解决方案:使用float属性为img布局

备注:因为img标签是行内属性标签,所以只要不超出容器宽度,img标签都会排在博客一行里,但是部分浏览器的博客img标签之间会有个间距。去掉这个间距使用float是正道。(我博客博客一个学生使用负margin,虽然能解决,但负margin本身就是容易引起浏览器兼容问题的博客用法,所以我博客禁止他们使用)

浏览器兼容问题六:标签最低高度设置min-height不兼容

问题症状:因为min-height本身就是一个不兼容的博客CSS属性,所以设置min-height时不能很好的博客被各个浏览器兼容

碰到几率:5%

解决方案:如果我博客们要设置一个标签的博客最小高度200px,需要进行的博客设置为:{min-height:200px; height:auto !important; height:200px; overflow:visible;}

备注:在博客B/S系统前端开时,有很多情况下我博客们又这种需求。当内容小于一个值(如300px)时。容器的博客高度为300px;当内容高度大于这个值时,容器高度被撑高,而不是出现滚动条。这时候我博客们就会面临这个兼容性问题。

浏览器兼容问题七:透明度的博客兼容CSS设置

做兼容页面的博客方法是:每写一小段代码(布局中的博客一行或者一块)我博客们都要在博客不同的博客浏览器中看是否兼容,当然熟练到一定的博客程度就没这么麻烦了。建议经常会碰到兼容性问题的博客新手使用。很多兼容性问题都是因为浏览器对标签的博客默认属性解析不同造成的博客,只要我博客们稍加设置都能轻松地解决这些兼容问题。如果我博客们熟悉标签的博客默认属性的博客话,就能很好的博客理解为什么会出现兼容问题以及怎么去解决这些兼容问题。

  1. /* CSS hack*/ 

博客很少使用hacker的博客,可能是个人习惯吧,我博客不喜欢写的博客代码IE不兼容,然后用hack来解决。不过hacker还是非常好用的博客。使用hacker我博客可以把浏览器分为3类:IE6 ;IE7和遨游;其他(IE8 chrome ff safari opera等)

◆IE6认识的博客hacker 是下划线_ 和星号 *

◆IE7 遨游认识的博客hacker是星号 *

比如这样一个CSS设置:

  1. height:300px;*height:200px;_height:100px; 

IE6浏览器在博客读到height:300px的博客时候会认为高时300px;继续往下读,他也认识*heihgt, 所以当IE6读到*height:200px的博客时候会覆盖掉前一条的博客相冲突设置,认为高度是200px。继续往下读,IE6还认识_height,所以他又会覆盖掉200px高的博客设置,把高度设置为100px;

IE7和遨游也是一样的博客从高度300px的博客设置往下读。当它们读到*height200px的博客时候就停下了,因为它们不认识_height。所以它们会把高度解析为200px,剩下的博客浏览器只认识第一个height:300px;所以他们会把高度解析为300px。因为优先级相同且想冲突的博客属性设置后一个会覆盖掉前一个,所以书写的博客次序是很重要的博客

http://blog.csdn.net/d360642226/article/details/77206123加勒比海盗5

[置顶] 八大排序算法总结(超详细)

概述

排序有内部排序和外部排序,内部排序是数据记录在博客内存中进行排序,而外部排序是因排序的博客数据很大,一次不能容纳全部的博客排序记录,在博客排序过程中需要访问外存。

博客们这里说说八大排序就是内部排序。

[置顶]         八大排序算法总结(超详细)

    

    当n较大,则应采用时间复杂度为O(nlog2n)博客排序方法:快速排序、堆排序或归并排序序。

   快速排序:是目前基于比较的博客内部排序中被认为是最好的博客方法,当待排序的博客关键字是随机分布时,快速排序的博客平均时间最短;

 

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

将一个记录插入到已排序好的博客有序表中,从而得到一个新,记录数增1的博客有序表。即:先将序列的博客第1个记录看成是一个有序的博客子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止。

要点:设立哨兵,作为临时存储和判断数组边界之用。

直接插入排序示例:

[置顶]         八大排序算法总结(超详细)


如果碰见一个和插入元素相等的博客,那么插入元素把想插入的博客元素放在博客相等元素的博客后面。所以,相等元素的博客前后顺序没有改变,从原无序序列出去的博客顺序就是排好序后的博客顺序,所以插入排序是稳定的博客

算法博客实现:

  1. void print(int a[], int n ,int i){  
  2.     cout<<i <<”:”;  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<” ”;  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8.   
  9.   
  10. void InsertSort(int a[], int n)  
  11. {  
  12.     for(int i= 1; i<n; i++){  
  13.         if(a[i] < a[i-1]){               //若第i个元素大于i-1元素,直接插入。小于的博客话,移动有序表后插入  
  14.             int j= i-1;   
  15.             int x = a[i];        //复制为哨兵,即存储待排序元素  
  16.             a[i] = a[i-1];           //先后移一个元素  
  17.             while(x < a[j]){  //查找在博客有序表的博客插入位置  
  18.                 a[j+1] = a[j];  
  19.                 j–;         //元素后移  
  20.             }  
  21.             a[j+1] = x;      //插入到正确位置  
  22.         }  
  23.         print(a,n,i);           //打印每趟排序的博客结果  
  24.     }  
  25.       
  26. }  
  27.   
  28. int main(){  
  29.     int a[8] = {3,1,5,7,2,4,9,6};  
  30.     InsertSort(a,8);  
  31.     print(a,8,8);  
  32. }  
void print(int a[], int n ,int i){     cout<<i <<":";     for(int j= 0; j<8; j++){         cout<<a[j] <<" ";     }     cout<<endl; }   void InsertSort(int a[], int n) {     for(int i= 1; i<n; i++){         if(a[i] < a[i-1]){               //若第i个元素大于i-1元素,直接插入。小于的博客话,移动有序表后插入             int j= i-1;              int x = a[i];        //复制为哨兵,即存储待排序元素             a[i] = a[i-1];           //先后移一个元素             while(x < a[j]){  //查找在博客有序表的博客插入位置                 a[j+1] = a[j];                 j--;         //元素后移             }             a[j+1] = x;      //插入到正确位置         }         print(a,n,i);           //打印每趟排序的博客结果     }  }  int main(){     int a[8] = {3,1,5,7,2,4,9,6};     InsertSort(a,8);     print(a,8,8); } 


效率:

时间复杂度:O(n^2).

其他的博客插入排序有二分插入排序,2-路插入排序。

 

 2. 插入排序—希尔排序(Shell`s Sort)

希尔排序是1959 年由D.L.Shell 提出来的博客,相对直接排序有较大的博客改进。希尔排序又叫缩小增量排序

基本思想:

先将整个待排序的博客记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的博客记录“基本有序”时,再对全体记录进行依次直接插入排序。

操作方法:

  1. 选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;
  2. 按增量序列个数k,对序列进行k 趟排序;
  3. 每趟排序,根据对应的博客增量ti,将待排序列分割成若干长度为m 的博客子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的博客长度。

希尔排序的博客示例:

[置顶]         八大排序算法总结(超详细)


算法实现:

 

博客们简单处理增量序列:增量序列d = {n/2 ,n/4, n/8 …..1} n为要排序数的博客个数

即:先将要排序的博客一组记录按某个增量dn/2,n为要排序数的博客个数)分成若干组子序列,每组中记录的博客下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的博客增量(d/2)对它进行分组,在博客每组中再进行直接插入排序。继续不断缩小增量直至为1,最后使用直接插入排序完成排序。

  1. void print(int a[], int n ,int i){  
  2.     cout<<i <<”:”;  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<” ”;  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8. /** 
  9.  * 直接插入排序的博客一般形式 
  10.  * 
  11.  * @param int dk 缩小增量,如果是直接插入排序,dk=1 
  12.  * 
  13.  */  
  14.   
  15. void ShellInsertSort(int a[], int n, int dk)  
  16. {  
  17.     for(int i= dk; i<n; ++i){  
  18.         if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素,直接插入。小于的博客话,移动有序表后插入  
  19.             int j = i-dk;     
  20.             int x = a[i];           //复制为哨兵,即存储待排序元素  
  21.             a[i] = a[i-dk];         //首先后移一个元素  
  22.             while(x < a[j]){     //查找在博客有序表的博客插入位置  
  23.                 a[j+dk] = a[j];  
  24.                 j -= dk;             //元素后移  
  25.             }  
  26.             a[j+dk] = x;            //插入到正确位置  
  27.         }  
  28.         print(a, n,i );  
  29.     }  
  30.       
  31. }  
  32.   
  33. /** 
  34.  * 先按增量d(n/2,n为要排序数的博客个数进行希尔排序 
  35.  * 
  36.  */  
  37. void shellSort(int a[], int n){  
  38.   
  39.     int dk = n/2;  
  40.     while( dk >= 1  ){  
  41.         ShellInsertSort(a, n, dk);  
  42.         dk = dk/2;  
  43.     }  
  44. }  
  45. int main(){  
  46.     int a[8] = {3,1,5,7,2,4,9,6};  
  47.     //ShellInsertSort(a,8,1); //直接插入排序  
  48.     shellSort(a,8);           //希尔插入排序  
  49.     print(a,8,8);  
  50. }  
void print(int a[], int n ,int i){     cout<<i <<":";     for(int j= 0; j<8; j++){         cout<<a[j] <<" ";     }     cout<<endl; } /**  * 直接插入排序的博客一般形式  *  * @param int dk 缩小增量,如果是直接插入排序,dk=1  *  */  void ShellInsertSort(int a[], int n, int dk) {     for(int i= dk; i<n; ++i){         if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素,直接插入。小于的博客话,移动有序表后插入             int j = i-dk;                int x = a[i];           //复制为哨兵,即存储待排序元素             a[i] = a[i-dk];         //首先后移一个元素             while(x < a[j]){     //查找在博客有序表的博客插入位置                 a[j+dk] = a[j];                 j -= dk;             //元素后移             }             a[j+dk] = x;            //插入到正确位置         }         print(a, n,i );     }  }  /**  * 先按增量d(n/2,n为要排序数的博客个数进行希尔排序  *  */ void shellSort(int a[], int n){      int dk = n/2;     while( dk >= 1  ){         ShellInsertSort(a, n, dk);         dk = dk/2;     } } int main(){     int a[8] = {3,1,5,7,2,4,9,6};     //ShellInsertSort(a,8,1); //直接插入排序     shellSort(a,8);           //希尔插入排序     print(a,8,8); } 

希尔排序时效分析很难,关键码的博客比较次数与记录移动次数依赖于增量因子序列d的博客选取,特定情况下可以准确估算出关键码的博客比较次数和记录的博客移动次数。目前还没有人给出选取最好的博客增量因子序列博客方法。增量因子序列可以有各种取法,有取奇数的博客,也有取质数的博客,但需要注意:增量因子中除1 外没有公因子,且最后一个增量因子必须为1。希尔排序方法是一个不稳定的博客排序方法。

3. 选择排序—简单选择排序(Simple Selection Sort)

基本思想:

博客要排序的博客一组数中,选出最小(或者最大)的博客个数与第1个位置博客数交换;然后在博客剩下的博客数当中再找最小(或者最大)的博客第2个位置博客数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后个数)比较为止。

简单选择排序的博客示例:

 [置顶]         八大排序算法总结(超详细)

操作方法:

第一趟,从n 个记录中找出关键码最小的博客记录与第一个记录交换;

第二趟,从第二个记录开始的博客n-1 个记录中再选出关键码最小的博客记录与第二个记录交换;

以此类推…..

第i 趟,则从第i 个记录开始的博客n-i+1 个记录中选出关键码最小的博客记录与第i 个记录交换,

直到整个序列按关键码有序。

算法实现:

  1. void print(int a[], int n ,int i){  
  2.     cout<<”第”<<i+1 <<“趟 : ”;  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<”  ”;  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8. /** 
  9.  * 数组的博客最小值 
  10.  * 
  11.  * @return int 数组的博客键值 
  12.  */  
  13. int SelectMinKey(int a[], int n, int i)  
  14. {  
  15.     int k = i;  
  16.     for(int j=i+1 ;j< n; ++j) {  
  17.         if(a[k] > a[j]) k = j;  
  18.     }  
  19.     return k;  
  20. }  
  21.   
  22. /** 
  23.  * 选择排序 
  24.  * 
  25.  */  
  26. void selectSort(int a[], int n){  
  27.     int key, tmp;  
  28.     for(int i = 0; i< n; ++i) {  
  29.         key = SelectMinKey(a, n,i);           //选择最小的博客元素  
  30.         if(key != i){  
  31.             tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换  
  32.         }  
  33.         print(a,  n , i);  
  34.     }  
  35. }  
  36. int main(){  
  37.     int a[8] = {3,1,5,7,2,4,9,6};  
  38.     cout<<”初始值:”;  
  39.     for(int j= 0; j<8; j++){  
  40.         cout<<a[j] <<”  ”;  
  41.     }  
  42.     cout<<endl<<endl;  
  43.     selectSort(a, 8);  
  44.     print(a,8,8);  
  45. }  
void print(int a[], int n ,int i){     cout<<"第"<<i+1 <<"趟 : ";     for(int j= 0; j<8; j++){         cout<<a[j] <<"  ";     }     cout<<endl; } /**  * 数组的博客最小值  *  * @return int 数组的博客键值  */ int SelectMinKey(int a[], int n, int i) {     int k = i;     for(int j=i+1 ;j< n; ++j) {         if(a[k] > a[j]) k = j;     }     return k; }  /**  * 选择排序  *  */ void selectSort(int a[], int n){     int key, tmp;     for(int i = 0; i< n; ++i) {         key = SelectMinKey(a, n,i);           //选择最小的博客元素         if(key != i){             tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换         }         print(a,  n , i);     } } int main(){     int a[8] = {3,1,5,7,2,4,9,6};     cout<<"初始值:";     for(int j= 0; j<8; j++){         cout<<a[j] <<"  ";     }     cout<<endl<<endl;     selectSort(a, 8);     print(a,8,8); } 

 简单选择排序的博客改进——二元选择排序

简单选择排序,每趟循环只能确定一个元素排序后的博客定位。我博客们可以考虑改进为每趟循环确定两个元素(当前趟最大和最小记录)的博客位置,从而减少排序所需的博客循环次数。改进后对n个数据进行排序,最多只需进行[n/2]趟循环即可。具体实现如下:

  1. void SelectSort(int r[],int n) {  
  2.     int i ,j , min ,max, tmp;  
  3.     for (i=1 ;i <= n/2;i++) {    
  4.         // 做不超过n/2趟选择排序   
  5.         min = i; max = i ; //分别记录最大和最小关键字记录位置  
  6.         for (j= i+1; j<= n-i; j++) {  
  7.             if (r[j] > r[max]) {   
  8.                 max = j ; continue ;   
  9.             }    
  10.             if (r[j]< r[min]) {   
  11.                 min = j ;   
  12.             }     
  13.       }    
  14.       //该交换操作还可分情况讨论以提高效率  
  15.       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  
  16.       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   
  17.   
  18.     }   
  19. }  
void SelectSort(int r[],int n) {     int i ,j , min ,max, tmp;     for (i=1 ;i <= n/2;i++) {           // 做不超过n/2趟选择排序          min = i; max = i ; //分别记录最大和最小关键字记录位置         for (j= i+1; j<= n-i; j++) {             if (r[j] > r[max]) {                  max = j ; continue ;              }               if (r[j]< r[min]) {                  min = j ;              }          }         //该交换操作还可分情况讨论以提高效率       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;       }  }

4. 选择排序—堆排序(Heap Sort)

堆排序是一种树形选择排序,是对直接选择排序的博客有效改进。

基本思想:

堆的博客定义如下:具有n个元素的博客序列(k1,k2,…,kn),当且仅当满足

[置顶]         八大排序算法总结(超详细)

时称之为堆。由堆的博客定义可以看出,堆顶元素(即第一个元素)必为最小项(小顶堆)。
若以一维数组存储一个堆,则堆对应一棵完全二叉树,且所有非叶结点的博客值均不大于(或不小于)其子女的博客值,根结点(堆顶元素)的博客值是最小(或最大)的博客。如:

(a)大顶堆序列:(96, 83,27,38,11,09)

  (b)  小顶堆序列:(12,36,24,85,47,30,53,91)

[置顶]         八大排序算法总结(超详细)

初始时把要排序的博客n个数的博客序列看作是一棵顺序存储的博客二叉树(一维数组存储二叉树),调整它们的博客存储序,使之成为一个堆,将堆顶元素输出,得到n 个元素中最小(或最大)的博客元素,这时堆的博客根节点的博客数最小(或者最大)。然后对前面(n-1)个元素重新调整使之成为堆,输出堆顶元素,得到n 个元素中次小(或次大)的博客元素。依此类推,直到只有两个节点的博客堆,并对它们作交换,最后得到有n个节点的博客有序序列。称这个过程为堆排序

因此,实现堆排序需解决两个问题:
1. 如何将n 个待排序的博客数建成堆;
2. 输出堆顶元素后,怎样调整剩余n-1 个元素,使其成为一个新堆。

首先讨论第二个问题:输出堆顶元素后,对剩余n-1元素重新建成堆的博客调整过程。
调整小顶堆的博客方法:

1)设有m 个元素的博客堆,输出堆顶元素后,剩下m-1 个元素。将堆底元素送入堆顶((最后一个元素与堆顶进行交换),堆被破坏,其原因仅是根结点不满足堆的博客性质。

2)将根结点与左、右子树中较小元素的博客进行交换。

3)若与左子树交换:如果左子树堆被破坏,即左子树的博客根结点不满足堆的博客性质,则重复方法 (2).

4)若与右子树交换,如果右子树堆被破坏,即右子树的博客根结点不满足堆的博客性质。则重复方法 (2).

5)继续对不满足堆性质的博客子树进行上述交换操作,直到叶子结点,堆被建成。

称这个自根结点到叶子结点的博客调整过程为筛选。如图:

[置顶]         八大排序算法总结(超详细)

再讨论对n 个元素初始建堆的博客过程。
建堆方法:对初始序列建堆的博客过程,就是一个反复进行筛选的博客过程。

1)n 个结点的博客完全二叉树,则最后一个结点是第[置顶]         八大排序算法总结(超详细)个结点的博客子树。

2)筛选从第[置顶]         八大排序算法总结(超详细)个结点为根的博客子树开始,该子树成为堆。

3)之后向前依次对各结点为根的博客子树进行筛选,使之成为堆,直到根结点。

如图建堆初始过程:无序序列:(49,38,65,97,76,13,27,49)
                              [置顶]         八大排序算法总结(超详细)

                              [置顶]         八大排序算法总结(超详细)

 

 算法的博客实现:

从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的博客最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的博客渗透函数,二是反复调用渗透函数实现排序的博客函数。

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<”  ”;  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8.   
  9.   
  10. /** 
  11.  * 已知H[s…m]除了H[s] 外均满足堆的博客定义 
  12.  * 调整H[s],使其成为大顶堆.即将对第s个结点为根的博客子树筛选,  
  13.  * 
  14.  * @param H是待调整的博客堆数组 
  15.  * @param s是待调整的博客数组元素的博客位置 
  16.  * @param length是数组的博客长度 
  17.  * 
  18.  */  
  19. void HeapAdjust(int H[],int s, int length)  
  20. {  
  21.     int tmp  = H[s];  
  22.     int child = 2*s+1; //左孩子结点的博客位置。(i+1 为当前调整结点的博客右孩子结点的博客位置)  
  23.     while (child < length) {  
  24.         if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的博客孩子结点)  
  25.             ++child ;  
  26.         }  
  27.         if(H[s]<H[child]) {  // 如果较大的博客子结点大于父结点  
  28.             H[s] = H[child]; // 那么把较大的博客子结点往上移动,替换它的博客父结点  
  29.             s = child;       // 重新设置s ,即待调整的博客下一个结点的博客位置  
  30.             child = 2*s+1;  
  31.         }  else {            // 如果当前待调整结点大于它的博客左右孩子,则不需要调整,直接退出  
  32.              break;  
  33.         }  
  34.         H[s] = tmp;         // 当前待调整的博客结点放到比其大的博客孩子结点位置上  
  35.     }  
  36.     print(H,length);  
  37. }  
  38.   
  39.   
  40. /** 
  41.  * 初始堆进行调整 
  42.  * 将H[0..length-1]建成堆 
  43.  * 调整完之后第一个元素是序列的博客最小的博客元素 
  44.  */  
  45. void BuildingHeap(int H[], int length)  
  46. {   
  47.     //最后一个有孩子的博客节点的博客位置 i=  (length -1) / 2  
  48.     for (int i = (length -1) / 2 ; i >= 0; –i)  
  49.         HeapAdjust(H,i,length);  
  50. }  
  51. /** 
  52.  * 堆排序算法 
  53.  */  
  54. void HeapSort(int H[],int length)  
  55. {  
  56.     //初始堆  
  57.     BuildingHeap(H, length);  
  58.     //从最后一个元素开始对序列进行调整  
  59.     for (int i = length – 1; i > 0; –i)  
  60.     {  
  61.         //交换堆顶元素H[0]和堆中最后一个元素  
  62.         int temp = H[i]; H[i] = H[0]; H[0] = temp;  
  63.         //每次交换堆顶元素和堆中最后一个元素之后,都要对堆进行调整  
  64.         HeapAdjust(H,0,i);  
  65.   }  
  66. }   
  67.   
  68. int main(){  
  69.     int H[10] = {3,1,5,7,2,4,9,6,10,8};  
  70.     cout<<”初始值:”;  
  71.     print(H,10);  
  72.     HeapSort(H,10);  
  73.     //selectSort(a, 8);  
  74.     cout<<”结果:”;  
  75.     print(H,10);  
  76.   
  77. }  
void print(int a[], int n){     for(int j= 0; j<n; j++){         cout<<a[j] <<"  ";     }     cout<<endl; }    /**  * 已知H[s…m]除了H[s] 外均满足堆的博客定义  * 调整H[s],使其成为大顶堆.即将对第s个结点为根的博客子树筛选,   *  * @param H是待调整的博客堆数组  * @param s是待调整的博客数组元素的博客位置  * @param length是数组的博客长度  *  */ void HeapAdjust(int H[],int s, int length) {     int tmp  = H[s];     int child = 2*s+1; //左孩子结点的博客位置。(i+1 为当前调整结点的博客右孩子结点的博客位置)     while (child < length) {         if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的博客孩子结点)             ++child ;         }         if(H[s]<H[child]) {  // 如果较大的博客子结点大于父结点             H[s] = H[child]; // 那么把较大的博客子结点往上移动,替换它的博客父结点             s = child;       // 重新设置s ,即待调整的博客下一个结点的博客位置             child = 2*s+1;         }  else {            // 如果当前待调整结点大于它的博客左右孩子,则不需要调整,直接退出              break;         }         H[s] = tmp;         // 当前待调整的博客结点放到比其大的博客孩子结点位置上     }     print(H,length); }   /**  * 初始堆进行调整  * 将H[0..length-1]建成堆  * 调整完之后第一个元素是序列的博客最小的博客元素  */ void BuildingHeap(int H[], int length) {      //最后一个有孩子的博客节点的博客位置 i=  (length -1) / 2     for (int i = (length -1) / 2 ; i >= 0; --i)         HeapAdjust(H,i,length); } /**  * 堆排序算法  */ void HeapSort(int H[],int length) {     //初始堆     BuildingHeap(H, length);     //从最后一个元素开始对序列进行调整     for (int i = length - 1; i > 0; --i)     {         //交换堆顶元素H[0]和堆中最后一个元素         int temp = H[i]; H[i] = H[0]; H[0] = temp;         //每次交换堆顶元素和堆中最后一个元素之后,都要对堆进行调整         HeapAdjust(H,0,i);   } }   int main(){     int H[10] = {3,1,5,7,2,4,9,6,10,8};     cout<<"初始值:";     print(H,10);     HeapSort(H,10);     //selectSort(a, 8);     cout<<"结果:";     print(H,10);  }  

分析:

设树深度为k,[置顶]         八大排序算法总结(超详细)。从根到叶的博客筛选,元素比较次数至多2(k-1)次,交换记录至多k 次。所以,在博客建好堆后,排序过程中的博客筛选次数不超过下式: 

                                [置顶]         八大排序算法总结(超详细)

而建堆时的博客比较次数不超过4n 次,因此堆排序最坏情况下,时间复杂度也为:O(nlogn )。

 

5. 交换排序—冒泡排序(Bubble Sort)

基本思想:

博客要排序的博客一组数中,对当前还未排好序的博客范围内的博客全部数,自上而下对相邻的博客两个数依次进行比较和调整,让较大博客数往下沉,较小的博客往上冒。即:每当两相邻的博客数比较后发现它们的博客排序与排序要求相反时,就将它们互换。

冒泡排序的博客示例:

 [置顶]         八大排序算法总结(超详细)

算法的博客实现:

  1. void bubbleSort(int a[], int n){  
  2.     for(int i =0 ; i< n-1; ++i) {  
  3.         for(int j = 0; j < n-i-1; ++j) {  
  4.             if(a[j] > a[j+1])  
  5.             {  
  6.                 int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
  7.             }  
  8.         }  
  9.     }  
  10. }  
void bubbleSort(int a[], int n){     for(int i =0 ; i< n-1; ++i) {         for(int j = 0; j < n-i-1; ++j) {             if(a[j] > a[j+1])             {                 int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;             }         }     } }

冒泡排序算法的博客改进

对冒泡排序常见的博客改进方法是加入一标志性变量exchange,用于标志某一趟排序过程中是否有数据交换,如果进行某一趟排序时并没有进行数据交换,则说明数据已经按要求排列好,可立即结束排序,避免不必要的博客比较过程。本文再提供以下两种改进算法:

1.设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的博客位置。由于pos位置之后的博客记录均已交换到位,故在博客进行下一趟排序时只要扫描到pos位置即可。

改进后算法如下:

  1. void Bubble_1 ( int r[], int n) {  
  2.     int i= n -1;  //初始时,最后位置保持不变  
  3.     while ( i> 0) {   
  4.         int pos= 0; //每趟开始时,无记录交换  
  5.         for (int j= 0; j< i; j++)  
  6.             if (r[j]> r[j+1]) {  
  7.                 pos= j; //记录交换的博客位置   
  8.                 int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
  9.             }   
  10.         i= pos; //为下一趟排序作准备  
  11.      }   
  12. }    
void Bubble_1 ( int r[], int n) {     int i= n -1;  //初始时,最后位置保持不变     while ( i> 0) {          int pos= 0; //每趟开始时,无记录交换         for (int j= 0; j< i; j++)             if (r[j]> r[j+1]) {                 pos= j; //记录交换的博客位置                  int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;             }          i= pos; //为下一趟排序作准备      }  }   

2.传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,博客们考虑利用在博客每趟排序中进行正向和反向两遍冒泡的博客方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

改进后的博客算法实现为:

  1. void Bubble_2 ( int r[], int n){  
  2.     int low = 0;   
  3.     int high= n -1; //设置变量的博客初始值  
  4.     int tmp,j;  
  5.     while (low < high) {  
  6.         for (j= low; j< high; ++j) //正向冒泡,找到最大者  
  7.             if (r[j]> r[j+1]) {  
  8.                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
  9.             }   
  10.         –high;                 //修改high值, 前移一位  
  11.         for ( j=high; j>low; –j) //反向冒泡,找到最小者  
  12.             if (r[j]<r[j-1]) {  
  13.                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
  14.             }  
  15.         ++low;                  //修改low值,后移一位  
  16.     }   
  17. }   
void Bubble_2 ( int r[], int n){     int low = 0;      int high= n -1; //设置变量的博客初始值     int tmp,j;     while (low < high) {         for (j= low; j< high; ++j) //正向冒泡,找到最大者             if (r[j]> r[j+1]) {                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;             }          --high;                 //修改high值, 前移一位         for ( j=high; j>low; --j) //反向冒泡,找到最小者             if (r[j]<r[j-1]) {                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;             }         ++low;                  //修改low值,后移一位     }  } 

6. 交换排序—快速排序(Quick Sort)

基本思想:

1)选择一个基准元素,通常选择第一个元素或者最后一个元素,

2)通过一趟排序讲待排序的博客记录分割成独立的博客两部分,其中一部分记录的博客元素值均比基准元素值小。另一部分记录的博客 元素值比基准值大。

3)此时基准元素在博客其排好序后的博客正确位置

4)然后分别对这两部分记录用同样的博客方法继续进行排序,直到整个序列有序。

快速排序的博客示例:

(a)一趟排序的博客过程:

[置顶]         八大排序算法总结(超详细)

(b)排序的博客全过程

[置顶]         八大排序算法总结(超详细)

算法的博客实现:

 递归实现:

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<”  ”;  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. void swap(int *a, int *b)  
  9. {  
  10.     int tmp = *a;  
  11.     *a = *b;  
  12.     *b = tmp;  
  13. }  
  14.   
  15. int partition(int a[], int low, int high)  
  16. {  
  17.     int privotKey = a[low];                             //基准元素  
  18.     while(low < high){                                   //从表的博客两端交替地向中间扫描  
  19.         while(low < high  && a[high] >= privotKey) –high;  //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的博客交换到低端  
  20.         swap(&a[low], &a[high]);  
  21.         while(low < high  && a[low] <= privotKey ) ++low;  
  22.         swap(&a[low], &a[high]);  
  23.     }  
  24.     print(a,10);  
  25.     return low;  
  26. }  
  27.   
  28.   
  29. void quickSort(int a[], int low, int high){  
  30.     if(low < high){  
  31.         int privotLoc = partition(a,  low,  high);  //将表一分为二  
  32.         quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序  
  33.         quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序  
  34.     }  
  35. }  
  36.   
  37. int main(){  
  38.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  39.     cout<<”初始值:”;  
  40.     print(a,10);  
  41.     quickSort(a,0,9);  
  42.     cout<<”结果:”;  
  43.     print(a,10);  
  44.   
  45. }  
void print(int a[], int n){     for(int j= 0; j<n; j++){         cout<<a[j] <<"  ";     }     cout<<endl; }  void swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }  int partition(int a[], int low, int high) {     int privotKey = a[low];                             //基准元素     while(low < high){                                   //从表的博客两端交替地向中间扫描         while(low < high  && a[high] >= privotKey) --high;  //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的博客交换到低端         swap(&a[low], &a[high]);         while(low < high  && a[low] <= privotKey ) ++low;         swap(&a[low], &a[high]);     }     print(a,10);     return low; }   void quickSort(int a[], int low, int high){     if(low < high){         int privotLoc = partition(a,  low,  high);  //将表一分为二         quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序         quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序     } }  int main(){     int a[10] = {3,1,5,7,2,4,9,6,10,8};     cout<<"初始值:";     print(a,10);     quickSort(a,0,9);     cout<<"结果:";     print(a,10);  }

分析:

快速排序是通常被认为在博客同数量级(O(nlog2n))的博客排序方法中平均性能最好的博客。但若初始序列按关键码有序或基本有序时,快排序反而蜕化为冒泡排序。为改进之,通常以“三者取中法”来选取基准记录,即将排序区间的博客两个端点与中点三个记录关键码居中的博客调整为支点记录。快速排序是一个不稳定的博客排序方法。

 
快速排序的博客改进

博客本改进算法中,只对长度大于k博客子序列递归调用快速排序,让原序列基本有序,然后再对整个基本有序序列用插入排序算法排序。实践证明,改进后的博客算法时间复杂度有所降低,且当k取值为 8 左右时,改进算法的博客性能最佳。算法思想如下:

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<”  ”;  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. void swap(int *a, int *b)  
  9. {  
  10.     int tmp = *a;  
  11.     *a = *b;  
  12.     *b = tmp;  
  13. }  
  14.   
  15. int partition(int a[], int low, int high)  
  16. {  
  17.     int privotKey = a[low];                 //基准元素  
  18.     while(low < high){                   //从表的博客两端交替地向中间扫描  
  19.         while(low < high  && a[high] >= privotKey) –high; //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的博客交换到低端  
  20.         swap(&a[low], &a[high]);  
  21.         while(low < high  && a[low] <= privotKey ) ++low;  
  22.         swap(&a[low], &a[high]);  
  23.     }  
  24.     print(a,10);  
  25.     return low;  
  26. }  
  27.   
  28.   
  29. void qsort_improve(int r[ ],int low,int high, int k){  
  30.     if( high -low > k ) { //长度大于k时递归, k为指定的博客  
  31.         int pivot = partition(r, low, high); // 调用的博客Partition算法保持不变  
  32.         qsort_improve(r, low, pivot – 1,k);  
  33.         qsort_improve(r, pivot + 1, high,k);  
  34.     }   
  35. }   
  36. void quickSort(int r[], int n, int k){  
  37.     qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序  
  38.   
  39.     //再用插入排序对基本有序序列排序  
  40.     for(int i=1; i<=n;i ++){  
  41.         int tmp = r[i];   
  42.         int j=i-1;  
  43.         while(tmp < r[j]){  
  44.             r[j+1]=r[j]; j=j-1;   
  45.         }  
  46.         r[j+1] = tmp;  
  47.     }   
  48.   
  49. }   
  50.   
  51.   
  52.   
  53. int main(){  
  54.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  55.     cout<<”初始值:”;  
  56.     print(a,10);  
  57.     quickSort(a,9,4);  
  58.     cout<<”结果:”;  
  59.     print(a,10);  
  60.   
  61. }  
void print(int a[], int n){     for(int j= 0; j<n; j++){         cout<<a[j] <<"  ";     }     cout<<endl; }  void swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }  int partition(int a[], int low, int high) {     int privotKey = a[low];                 //基准元素     while(low < high){                   //从表的博客两端交替地向中间扫描         while(low < high  && a[high] >= privotKey) --high; //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的博客交换到低端         swap(&a[low], &a[high]);         while(low < high  && a[low] <= privotKey ) ++low;         swap(&a[low], &a[high]);     }     print(a,10);     return low; }   void qsort_improve(int r[ ],int low,int high, int k){     if( high -low > k ) { //长度大于k时递归, k为指定的博客数         int pivot = partition(r, low, high); // 调用的博客Partition算法保持不变         qsort_improve(r, low, pivot - 1,k);         qsort_improve(r, pivot + 1, high,k);     }  }  void quickSort(int r[], int n, int k){     qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序      //再用插入排序对基本有序序列排序     for(int i=1; i<=n;i ++){         int tmp = r[i];          int j=i-1;         while(tmp < r[j]){             r[j+1]=r[j]; j=j-1;          }         r[j+1] = tmp;     }   }     int main(){     int a[10] = {3,1,5,7,2,4,9,6,10,8};     cout<<"初始值:";     print(a,10);     quickSort(a,9,4);     cout<<"结果:";     print(a,10);  }


7. 归并排序(Merge Sort)

基本思想:

归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的博客有序表,即把待排序序列分为若干个子序列,每个子序列是有序的博客。然后再把有序子序列合并为整体有序序列。

归并排序示例:

 [置顶]         八大排序算法总结(超详细)

合并方法:

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成,两个子表长度分别为n-i +1、n-m

  1. j=m+1;k=i;i=i; //置两个子表的博客起始下标及辅助数组的博客起始下标
  2. 若i>m 或j>n,转⑷ //其中一个子表已合并完,比较选取结束
  3. //选取r[i]和r[j]较小的博客存入辅助数组rf
    如果r[i]<r[j],rf[k]=r[i]; i++; k++; 转⑵
    否则,rf[k]=r[j]; j++; k++; 转⑵
  4. //将尚未处理完的博客子表中元素存入rf
    如果i<=m,将r[i…m]存入rf[k…n] //前一子表非空
    如果j<=n ,  将r[j…n] 存入rf[k…n] //后一子表非空
  5. 合并结束。
  1. //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
  2. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
  3. {  
  4.     int j,k;  
  5.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
  6.         if(r[j] < r[i]) rf[k] = r[j++];  
  7.         else rf[k] = r[i++];  
  8.     }  
  9.     while(i <= m)  rf[k++] = r[i++];  
  10.     while(j <= n)  rf[k++] = r[j++];  
  11. }  
//将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n] void Merge(ElemType *r,ElemType *rf, int i, int m, int n) {     int j,k;     for(j=m+1,k=i; i<=m && j <=n ; ++k){         if(r[j] < r[i]) rf[k] = r[j++];         else rf[k] = r[i++];     }     while(i <= m)  rf[k++] = r[i++];     while(j <= n)  rf[k++] = r[j++]; }


归并的博客迭代算法


1 个元素的博客表总是有序的博客。所以对n 个元素的博客待排序列,每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表,所得子表除最后一个子表长度可能为1 外,其余子表长度均为2。再进行两两合并,直到生成n 个元素按关键码有序的博客表。

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<”  ”;  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
  9. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
  10. {  
  11.     int j,k;  
  12.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
  13.         if(r[j] < r[i]) rf[k] = r[j++];  
  14.         else rf[k] = r[i++];  
  15.     }  
  16.     while(i <= m)  rf[k++] = r[i++];  
  17.     while(j <= n)  rf[k++] = r[j++];  
  18.     print(rf,n+1);  
  19. }  
  20.   
  21. void MergeSort(ElemType *r, ElemType *rf, int lenght)  
  22. {   
  23.     int len = 1;  
  24.     ElemType *q = r ;  
  25.     ElemType *tmp ;  
  26.     while(len < lenght) {  
  27.         int s = len;  
  28.         len = 2 * s ;  
  29.         int i = 0;  
  30.         while(i+ len <lenght){  
  31.             Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的博客两个子表合并  
  32.             i = i+ len;  
  33.         }  
  34.         if(i + s < lenght){  
  35.             Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的博客两个子表合并  
  36.         }  
  37.         tmp = q; q = rf; rf = tmp; //交换q,rf,以保证下一趟归并时,仍从q 归并到rf  
  38.     }  
  39. }  
  40.   
  41.   
  42. int main(){  
  43.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  44.     int b[10];  
  45.     MergeSort(a, b, 10);  
  46.     print(b,10);  
  47.     cout<<”结果:”;  
  48.     print(a,10);  
  49.   
  50. }  
void print(int a[], int n){     for(int j= 0; j<n; j++){         cout<<a[j] <<"  ";     }     cout<<endl; }  //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n] void Merge(ElemType *r,ElemType *rf, int i, int m, int n) {     int j,k;     for(j=m+1,k=i; i<=m && j <=n ; ++k){         if(r[j] < r[i]) rf[k] = r[j++];         else rf[k] = r[i++];     }     while(i <= m)  rf[k++] = r[i++];     while(j <= n)  rf[k++] = r[j++];     print(rf,n+1); }  void MergeSort(ElemType *r, ElemType *rf, int lenght) {      int len = 1;     ElemType *q = r ;     ElemType *tmp ;     while(len < lenght) {         int s = len;         len = 2 * s ;         int i = 0;         while(i+ len <lenght){             Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的博客两个子表合并             i = i+ len;         }         if(i + s < lenght){             Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的博客两个子表合并         }         tmp = q; q = rf; rf = tmp; //交换q,rf,以保证下一趟归并时,仍从q 归并到rf     } }   int main(){     int a[10] = {3,1,5,7,2,4,9,6,10,8};     int b[10];     MergeSort(a, b, 10);     print(b,10);     cout<<"结果:";     print(a,10);  }

两路归并的博客递归算法

  1. void MSort(ElemType *r, ElemType *rf,int s, int t)  
  2. {   
  3.     ElemType *rf2;  
  4.     if(s==t) r[s] = rf[s];  
  5.     else  
  6.     {   
  7.         int m=(s+t)/2;          /*平分*p 表*/  
  8.         MSort(r, rf2, s, m);        /*递归地将p[s…m]归并为有序的博客p2[s…m]*/  
  9.         MSort(r, rf2, m+1, t);      /*递归地将p[m+1…t]归并为有序的博客p2[m+1…t]*/  
  10.         Merge(rf2, rf, s, m+1,t);   /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/  
  11.     }  
  12. }  
  13. void MergeSort_recursive(ElemType *r, ElemType *rf, int n)  
  14. {   /*对顺序表*p 作归并排序*/  
  15.     MSort(r, rf,0, n-1);  
  16. }  
void MSort(ElemType *r, ElemType *rf,int s, int t) {      ElemType *rf2;     if(s==t) r[s] = rf[s];     else     {          int m=(s+t)/2;          /*平分*p 表*/         MSort(r, rf2, s, m);        /*递归地将p[s…m]归并为有序的博客p2[s…m]*/         MSort(r, rf2, m+1, t);      /*递归地将p[m+1…t]归并为有序的博客p2[m+1…t]*/         Merge(rf2, rf, s, m+1,t);   /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/     } } void MergeSort_recursive(ElemType *r, ElemType *rf, int n) {   /*对顺序表*p 作归并排序*/     MSort(r, rf,0, n-1); }

8. 桶排序/基数排序(Radix Sort)

说基数排序之前,我博客们先说桶排序:

基本思想:是将阵列分到有限数量的博客桶子里。每个桶子再个别排序(有可能再使用别的博客排序算法或是以递回方式继续使用桶排序进行排序)。桶排序是鸽巢排序的博客一种归纳结果。当要被排序的博客阵列内的博客数值是均匀分配的博客时候,桶排序使用线性时间(Θ(n))。但桶排序并不是 比较排序,他不受到 O(n log n) 下限的博客影响。
         简单来说,就是把数据分组,放在博客一个个的博客桶中,然后对每个桶里面的博客博客进行排序。  

 例如要对大小为[1..1000]范围内的博客n个整数A[1..n]排序  

 首先,可以把桶设为大小为10的博客范围,具体而言,设集合B[1]存储[1..10]的博客整数,集合B[2]存储   (10..20]的博客整数,……集合B[i]存储(   (i-1)*10,   i*10]的博客整数,i   =   1,2,..100。总共有  100个桶。  

  然后,对A[1..n]从头到尾扫描一遍,把每个A[i]放入对应的博客桶B[j]中。  再对这100个桶中每个桶里的博客数字排序,这时可用冒泡,选择,乃至快排,一般来说任  何排序法都可以。

  最后,依次输出每个桶里面的博客数字,且每个桶中的博客数字从小到大输出,这  样就得到所有数字排好序的博客一个序列了。  

  假设有n个数字,有m个桶,如果数字是平均分布的博客,则每个桶里面平均有n/m个数字。如果  

  对每个桶中的博客数字采用快速排序,那么整个算法的博客复杂度是  

  O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   –   nlogm)  

  从上式看出,当m接近n的博客时候,桶排序复杂度接近O(n)  

  当然,以上复杂度的博客计算是基于输入的博客n个数字是平均分布这个假设的博客。这个假设是很强的博客  ,实际应用中效果并没有这么好。如果所有的博客数字都落在博客同一个桶中,那就退化成一般的博客排序了。  

        前面说的博客几大排序算法 ,大部分时间复杂度都是O(n2),也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O(n)的博客时间复杂度。但桶排序的博客缺点是:

        1)首先是空间复杂度比较高,需要的博客额外开销大。排序有两个数组的博客空间开销,一个存放待排序数组,一个就是所谓的博客桶,比如待排序值是从0到m-1,那就需要m个桶,这个桶数组就要至少m个空间。

        2)其次待排序的博客元素都要在博客一定的博客范围内等等。

       桶式排序是一种分配排序。分配排序的博客特定是不需要进行关键码的博客比较,但前提是要知道待排序列的博客一些具体情况。


分配排序的博客基本思想:说白了就是进行多次的博客桶式排序。

基数排序过程无须比较关键字,而是通过“分配”和“收集”过程来实现排序。它们的博客时间复杂度可达到线性阶:O(n)。

实例:

扑克牌中52 张牌,可按花色和面值分成两个字段,其大小关系为:
花色: 梅花< 方块< 红心< 黑心  [置顶]         八大排序算法总结(超详细)
面值: 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A

若对扑克牌按花色、面值进行升序排序,得到如下序列:
[置顶]         八大排序算法总结(超详细)

[置顶]         八大排序算法总结(超详细)

即两张牌,若花色不同,不论面值怎样,花色低的博客那张牌小于花色高的博客,只有在博客同花色情况下,大小关系才由面值的博客大小确定。这就是多关键码排序。

为得到排序结果,我博客们讨论两种排序方法。
方法1:先对花色排序,将其分为4 个组,即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序,最后,将4 个组连接起来即可。
方法2:先按13 个面值给出13 个编号组(2 号,3 号,…,A 号),将牌按面值依次放入对应的博客编号组,分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心),将2号组中牌取出分别放入对应花色组,再将3 号组中牌取出分别放入对应花色组,……,这样,4 个花色组中均按面值有序,然后,将4 个花色组依次连接起来即可。

设n 个元素的博客待排序列包含d 个关键码{k1,k2,…,kd},则称序列对关键码{k1,k2,…,kd}有序是指:对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系:

                                                               [置顶]         八大排序算法总结(超详细)

其中k1 称为最主位关键码,kd 称为最次位关键码     。

 

两种多关键码排序方法:

多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的博客顺序逐次排序,分两种方法:

最高位优先(Most Significant Digit first)法,简称MSD 法

1)先按k1 排序分组,将序列分成若干子序列,同一组序列的博客记录中,关键码k1 相等。

2)再对各组按k2 排序分成子组,之后,对后面的博客关键码继续这样的博客排序分组,直到按最次位关键码kd 对各子组排序后。

3)再将各组连接起来,便得到一个有序序列。扑克牌按花色、面值排序中介绍的博客方法一即是MSD 法。

最低位优先(Least Significant Digit first)法,简称LSD 法

1) 先从kd 开始排序,再对kd-1进行排序,依次重复,直到按k1排序分组分成最小的博客子序列后。

2) 最后将各个子序列连接起来,便可得到一个有序的博客序列, 扑克牌按花色、面值排序中介绍的博客方法二即是LSD 法。

基于LSD方法的博客链式基数排序的博客基本思想

  “多关键字排序”的博客思想实现“单关键字排序”。对数字型或字符型的博客单关键字,可以看作由多个数位或多个字符构成的博客多关键字,此时可以采用“分配-收集”的博客方法进行排序,这一过程称作基数排序法,其中每个数字或字符可能的博客取值个数称为基数。比如,扑克牌的博客花色基数为4,面值基数为13。在博客整理扑克牌时,既可以先按花色整理,也可以先按面值整理。按花色整理时,先按红、黑、方、花的博客顺序分成4摞(分配),再按此顺序再叠放在博客一起(收集),然后按面值的博客顺序分成13摞(分配),再按此顺序叠放在博客一起(收集),如此进行二次分配和收集即可将扑克牌排列有序。   

基数排序:

是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的博客,先按低优先级排序,再按高优先级排序。最后的博客次序就是高优先级高的博客博客前,高优先级相同的博客低优先级高的博客博客前。基数排序基于分别排序,分别收集,所以是稳定的博客

算法实现:

  1. Void RadixSort(Node L[],length,maxradix)  
  2. {  
  3.    int m,n,k,lsp;  
  4.    k=1;m=1;  
  5.    int temp[10][length-1];  
  6.    Empty(temp); //清空临时空间  
  7.    while(k<maxradix) //遍历所有关键字  
  8.    {  
  9.      for(int i=0;i<length;i++) //分配过程  
  10.     {  
  11.        if(L[i]<m)  
  12.           Temp[0][n]=L[i];  
  13.        else  
  14.           Lsp=(L[i]/m)%10; //确定关键字  
  15.        Temp[lsp][n]=L[i];  
  16.        n++;  
  17.    }  
  18.    CollectElement(L,Temp); //收集  
  19.    n=0;  
  20.    m=m*10;  
  21.   k++;  
  22.  }  
  23. }  
Void RadixSort(Node L[],length,maxradix) {    int m,n,k,lsp;    k=1;m=1;    int temp[10][length-1];    Empty(temp); //清空临时空间    while(k<maxradix) //遍历所有关键字    {      for(int i=0;i<length;i++) //分配过程     {        if(L[i]<m)           Temp[0][n]=L[i];        else           Lsp=(L[i]/m)%10; //确定关键字        Temp[lsp][n]=L[i];        n++;    }    CollectElement(L,Temp); //收集    n=0;    m=m*10;   k++;  } }

总结

各种排序的博客稳定性,时间复杂度和空间复杂度总结:

[置顶]         八大排序算法总结(超详细)

 我博客们比较时间复杂度函数的博客情况:

[置顶]         八大排序算法总结(超详细)

                             时间复杂度函数O(n)的博客增长情况

[置顶]         八大排序算法总结(超详细)

所以对n较大的博客排序记录。一般的博客选择都是时间复杂度为O(nlog2n)博客排序方法。

时间复杂度来说:

(1)平方阶(O(n2))排序
  各类简单排序:直接插入、直接选择和冒泡排序;
 (2)线性对数阶(O(nlog2n))排序
  快速排序堆排序归并排序
 (3)O(n1+§))排序,§是介于0和1之间的博客常数。

       希尔排序
(4)线性阶(O(n))排序
  基数排序,此外还有桶、箱排序。

说明:

当原表有序或基本有序时,直接插入排序和冒泡排序将大大减少比较次数和移动记录的博客次数,时间复杂度可降至On);

而快速排序则相反,当原表基本有序时,将蜕化为冒泡排序,时间复杂度提高为On2);

原表是否有序,对简单选择排序、堆排序、归并排序和基数排序的博客时间复杂度影响不大。

 

稳定性:

排序算法的博客稳定性:若待排序的博客序列中,存在博客多个具有相同关键字的博客记录,经过排序, 这些记录的博客相对次序保持不变,则称该算法是稳定的博客;若经排序后,记录的博客相对 次序发生了改变,则称该算法是不稳定的博客 
     稳定性的博客好处:排序算法如果是稳定的博客,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的博客结果可以为第二个键排序所用。基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的博客元素其顺序再高位也相同时是不会改变的博客。另外,如果排序算法稳定,可以避免多余的博客比较;

稳定的博客排序算法冒泡排序、插入排序、归并排序和基数排序

不是稳定的博客排序算法:选择排序、快速排序、希尔排序、堆排序

 

选择排序算法准则:

每种排序算法都各有优缺点。因此,在博客实用时需根据不同情况适当选用,甚至可以将多种方法结合起来使用。

选择排序算法的博客依据

影响排序的博客因素有很多,平均时间复杂度低的博客算法并不一定就是最优的博客。相反,有时平均时间复杂度高的博客算法可能更适合某些特殊情况。同时,选择算法时还得考虑它的博客可读性,以利于软件的博客维护。一般而言,需要考虑的博客因素有以下四点:

1.待排序的博客记录数目n博客大小;

2.记录本身数据量的博客大小,也就是记录中除关键字外的博客其他信息量的博客大小;

3.关键字的博客结构及其分布情况;

4.对排序稳定性的博客要求。

设待排序元素的博客个数为n.

1)当n较大,则应采用时间复杂度为O(nlog2n)博客排序方法:快速排序、堆排序或归并排序序。

   快速排序:是目前基于比较的博客内部排序中被认为是最好的博客方法,当待排序的博客关键字是随机分布时,快速排序的博客平均时间最短;
       堆排序 :  如果内存空间允许且要求稳定性的博客

       归并排序:它有一定数量的博客数据移动,所以我博客们可能过与插入排序组合,先获得一定长度的博客序列,然后再合并,在博客效率上将有所提高。

2)  当n较大,内存空间允许,且要求稳定性 =》归并排序

3)当n较小,可采用直接插入或直接选择排序。

    直接插入排序:当元素分布有序,直接插入排序将大大减少比较次数和移动记录的博客次数。

    直接选择排序 :元素分布有序,如果不要求稳定性,选择直接选择排序

5)一般不使用或不直接使用传统的博客冒泡排序。

6)基数排序
它是一种稳定的博客排序算法,但有一定的博客局限性:
  1、关键字可分解。

  2
、记录的博客关键字位数较少,如果密集更好
  3、如果是数字时,最好是无符号的博客,否则将增加相应的博客映射复杂度,可先将其正负分开排序。

 

注明:转载请提示出处:http://blog.csdn.net/hguisu/article/details/7776068

概述

排序有内部排序和外部排序,内部排序是数据记录在博客内存中进行排序,而外部排序是因排序的博客数据很大,一次不能容纳全部的博客排序记录,在博客排序过程中需要访问外存。

博客们这里说说八大排序就是内部排序。

[置顶]         八大排序算法总结(超详细)

    

    当n较大,则应采用时间复杂度为O(nlog2n)博客排序方法:快速排序、堆排序或归并排序序。

   快速排序:是目前基于比较的博客内部排序中被认为是最好的博客方法,当待排序的博客关键字是随机分布时,快速排序的博客平均时间最短;

 

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

将一个记录插入到已排序好的博客有序表中,从而得到一个新,记录数增1的博客有序表。即:先将序列的博客第1个记录看成是一个有序的博客子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止。

要点:设立哨兵,作为临时存储和判断数组边界之用。

直接插入排序示例:

[置顶]         八大排序算法总结(超详细)


如果碰见一个和插入元素相等的博客,那么插入元素把想插入的博客元素放在博客相等元素的博客后面。所以,相等元素的博客前后顺序没有改变,从原无序序列出去的博客顺序就是排好序后的博客顺序,所以插入排序是稳定的博客

算法博客实现:

  1. void print(int a[], int n ,int i){  
  2.     cout<<i <<”:”;  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<” ”;  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8.   
  9.   
  10. void InsertSort(int a[], int n)  
  11. {  
  12.     for(int i= 1; i<n; i++){  
  13.         if(a[i] < a[i-1]){               //若第i个元素大于i-1元素,直接插入。小于的博客话,移动有序表后插入  
  14.             int j= i-1;   
  15.             int x = a[i];        //复制为哨兵,即存储待排序元素  
  16.             a[i] = a[i-1];           //先后移一个元素  
  17.             while(x < a[j]){  //查找在博客有序表的博客插入位置  
  18.                 a[j+1] = a[j];  
  19.                 j–;         //元素后移  
  20.             }  
  21.             a[j+1] = x;      //插入到正确位置  
  22.         }  
  23.         print(a,n,i);           //打印每趟排序的博客结果  
  24.     }  
  25.       
  26. }  
  27.   
  28. int main(){  
  29.     int a[8] = {3,1,5,7,2,4,9,6};  
  30.     InsertSort(a,8);  
  31.     print(a,8,8);  
  32. }  
void print(int a[], int n ,int i){     cout<<i <<":";     for(int j= 0; j<8; j++){         cout<<a[j] <<" ";     }     cout<<endl; }   void InsertSort(int a[], int n) {     for(int i= 1; i<n; i++){         if(a[i] < a[i-1]){               //若第i个元素大于i-1元素,直接插入。小于的博客话,移动有序表后插入             int j= i-1;              int x = a[i];        //复制为哨兵,即存储待排序元素             a[i] = a[i-1];           //先后移一个元素             while(x < a[j]){  //查找在博客有序表的博客插入位置                 a[j+1] = a[j];                 j--;         //元素后移             }             a[j+1] = x;      //插入到正确位置         }         print(a,n,i);           //打印每趟排序的博客结果     }  }  int main(){     int a[8] = {3,1,5,7,2,4,9,6};     InsertSort(a,8);     print(a,8,8); } 


效率:

时间复杂度:O(n^2).

其他的博客插入排序有二分插入排序,2-路插入排序。

 

 2. 插入排序—希尔排序(Shell`s Sort)

希尔排序是1959 年由D.L.Shell 提出来的博客,相对直接排序有较大的博客改进。希尔排序又叫缩小增量排序

基本思想:

先将整个待排序的博客记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的博客记录“基本有序”时,再对全体记录进行依次直接插入排序。

操作方法:

  1. 选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;
  2. 按增量序列个数k,对序列进行k 趟排序;
  3. 每趟排序,根据对应的博客增量ti,将待排序列分割成若干长度为m 的博客子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的博客长度。

希尔排序的博客示例:

[置顶]         八大排序算法总结(超详细)


算法实现:

 

博客们简单处理增量序列:增量序列d = {n/2 ,n/4, n/8 …..1} n为要排序数的博客个数

即:先将要排序的博客一组记录按某个增量dn/2,n为要排序数的博客个数)分成若干组子序列,每组中记录的博客下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的博客增量(d/2)对它进行分组,在博客每组中再进行直接插入排序。继续不断缩小增量直至为1,最后使用直接插入排序完成排序。

  1. void print(int a[], int n ,int i){  
  2.     cout<<i <<”:”;  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<” ”;  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8. /** 
  9.  * 直接插入排序的博客一般形式 
  10.  * 
  11.  * @param int dk 缩小增量,如果是直接插入排序,dk=1 
  12.  * 
  13.  */  
  14.   
  15. void ShellInsertSort(int a[], int n, int dk)  
  16. {  
  17.     for(int i= dk; i<n; ++i){  
  18.         if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素,直接插入。小于的博客话,移动有序表后插入  
  19.             int j = i-dk;     
  20.             int x = a[i];           //复制为哨兵,即存储待排序元素  
  21.             a[i] = a[i-dk];         //首先后移一个元素  
  22.             while(x < a[j]){     //查找在博客有序表的博客插入位置  
  23.                 a[j+dk] = a[j];  
  24.                 j -= dk;             //元素后移  
  25.             }  
  26.             a[j+dk] = x;            //插入到正确位置  
  27.         }  
  28.         print(a, n,i );  
  29.     }  
  30.       
  31. }  
  32.   
  33. /** 
  34.  * 先按增量d(n/2,n为要排序数的博客个数进行希尔排序 
  35.  * 
  36.  */  
  37. void shellSort(int a[], int n){  
  38.   
  39.     int dk = n/2;  
  40.     while( dk >= 1  ){  
  41.         ShellInsertSort(a, n, dk);  
  42.         dk = dk/2;  
  43.     }  
  44. }  
  45. int main(){  
  46.     int a[8] = {3,1,5,7,2,4,9,6};  
  47.     //ShellInsertSort(a,8,1); //直接插入排序  
  48.     shellSort(a,8);           //希尔插入排序  
  49.     print(a,8,8);  
  50. }  
void print(int a[], int n ,int i){     cout<<i <<":";     for(int j= 0; j<8; j++){         cout<<a[j] <<" ";     }     cout<<endl; } /**  * 直接插入排序的博客一般形式  *  * @param int dk 缩小增量,如果是直接插入排序,dk=1  *  */  void ShellInsertSort(int a[], int n, int dk) {     for(int i= dk; i<n; ++i){         if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素,直接插入。小于的博客话,移动有序表后插入             int j = i-dk;                int x = a[i];           //复制为哨兵,即存储待排序元素             a[i] = a[i-dk];         //首先后移一个元素             while(x < a[j]){     //查找在博客有序表的博客插入位置                 a[j+dk] = a[j];                 j -= dk;             //元素后移             }             a[j+dk] = x;            //插入到正确位置         }         print(a, n,i );     }  }  /**  * 先按增量d(n/2,n为要排序数的博客个数进行希尔排序  *  */ void shellSort(int a[], int n){      int dk = n/2;     while( dk >= 1  ){         ShellInsertSort(a, n, dk);         dk = dk/2;     } } int main(){     int a[8] = {3,1,5,7,2,4,9,6};     //ShellInsertSort(a,8,1); //直接插入排序     shellSort(a,8);           //希尔插入排序     print(a,8,8); } 

希尔排序时效分析很难,关键码的博客比较次数与记录移动次数依赖于增量因子序列d的博客选取,特定情况下可以准确估算出关键码的博客比较次数和记录的博客移动次数。目前还没有人给出选取最好的博客增量因子序列博客方法。增量因子序列可以有各种取法,有取奇数的博客,也有取质数的博客,但需要注意:增量因子中除1 外没有公因子,且最后一个增量因子必须为1。希尔排序方法是一个不稳定的博客排序方法。

3. 选择排序—简单选择排序(Simple Selection Sort)

基本思想:

博客要排序的博客一组数中,选出最小(或者最大)的博客个数与第1个位置博客数交换;然后在博客剩下的博客数当中再找最小(或者最大)的博客第2个位置博客数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后个数)比较为止。

简单选择排序的博客示例:

 [置顶]         八大排序算法总结(超详细)

操作方法:

第一趟,从n 个记录中找出关键码最小的博客记录与第一个记录交换;

第二趟,从第二个记录开始的博客n-1 个记录中再选出关键码最小的博客记录与第二个记录交换;

以此类推…..

第i 趟,则从第i 个记录开始的博客n-i+1 个记录中选出关键码最小的博客记录与第i 个记录交换,

直到整个序列按关键码有序。

算法实现:

  1. void print(int a[], int n ,int i){  
  2.     cout<<”第”<<i+1 <<“趟 : ”;  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<”  ”;  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8. /** 
  9.  * 数组的博客最小值 
  10.  * 
  11.  * @return int 数组的博客键值 
  12.  */  
  13. int SelectMinKey(int a[], int n, int i)  
  14. {  
  15.     int k = i;  
  16.     for(int j=i+1 ;j< n; ++j) {  
  17.         if(a[k] > a[j]) k = j;  
  18.     }  
  19.     return k;  
  20. }  
  21.   
  22. /** 
  23.  * 选择排序 
  24.  * 
  25.  */  
  26. void selectSort(int a[], int n){  
  27.     int key, tmp;  
  28.     for(int i = 0; i< n; ++i) {  
  29.         key = SelectMinKey(a, n,i);           //选择最小的博客元素  
  30.         if(key != i){  
  31.             tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换  
  32.         }  
  33.         print(a,  n , i);  
  34.     }  
  35. }  
  36. int main(){  
  37.     int a[8] = {3,1,5,7,2,4,9,6};  
  38.     cout<<”初始值:”;  
  39.     for(int j= 0; j<8; j++){  
  40.         cout<<a[j] <<”  ”;  
  41.     }  
  42.     cout<<endl<<endl;  
  43.     selectSort(a, 8);  
  44.     print(a,8,8);  
  45. }  
void print(int a[], int n ,int i){     cout<<"第"<<i+1 <<"趟 : ";     for(int j= 0; j<8; j++){         cout<<a[j] <<"  ";     }     cout<<endl; } /**  * 数组的博客最小值  *  * @return int 数组的博客键值  */ int SelectMinKey(int a[], int n, int i) {     int k = i;     for(int j=i+1 ;j< n; ++j) {         if(a[k] > a[j]) k = j;     }     return k; }  /**  * 选择排序  *  */ void selectSort(int a[], int n){     int key, tmp;     for(int i = 0; i< n; ++i) {         key = SelectMinKey(a, n,i);           //选择最小的博客元素         if(key != i){             tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换         }         print(a,  n , i);     } } int main(){     int a[8] = {3,1,5,7,2,4,9,6};     cout<<"初始值:";     for(int j= 0; j<8; j++){         cout<<a[j] <<"  ";     }     cout<<endl<<endl;     selectSort(a, 8);     print(a,8,8); } 

 简单选择排序的博客改进——二元选择排序

简单选择排序,每趟循环只能确定一个元素排序后的博客定位。我博客们可以考虑改进为每趟循环确定两个元素(当前趟最大和最小记录)的博客位置,从而减少排序所需的博客循环次数。改进后对n个数据进行排序,最多只需进行[n/2]趟循环即可。具体实现如下:

  1. void SelectSort(int r[],int n) {  
  2.     int i ,j , min ,max, tmp;  
  3.     for (i=1 ;i <= n/2;i++) {    
  4.         // 做不超过n/2趟选择排序   
  5.         min = i; max = i ; //分别记录最大和最小关键字记录位置  
  6.         for (j= i+1; j<= n-i; j++) {  
  7.             if (r[j] > r[max]) {   
  8.                 max = j ; continue ;   
  9.             }    
  10.             if (r[j]< r[min]) {   
  11.                 min = j ;   
  12.             }     
  13.       }    
  14.       //该交换操作还可分情况讨论以提高效率  
  15.       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  
  16.       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   
  17.   
  18.     }   
  19. }  
void SelectSort(int r[],int n) {     int i ,j , min ,max, tmp;     for (i=1 ;i <= n/2;i++) {           // 做不超过n/2趟选择排序          min = i; max = i ; //分别记录最大和最小关键字记录位置         for (j= i+1; j<= n-i; j++) {             if (r[j] > r[max]) {                  max = j ; continue ;              }               if (r[j]< r[min]) {                  min = j ;              }          }         //该交换操作还可分情况讨论以提高效率       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;       }  }

4. 选择排序—堆排序(Heap Sort)

堆排序是一种树形选择排序,是对直接选择排序的博客有效改进。

基本思想:

堆的博客定义如下:具有n个元素的博客序列(k1,k2,…,kn),当且仅当满足

[置顶]         八大排序算法总结(超详细)

时称之为堆。由堆的博客定义可以看出,堆顶元素(即第一个元素)必为最小项(小顶堆)。
若以一维数组存储一个堆,则堆对应一棵完全二叉树,且所有非叶结点的博客值均不大于(或不小于)其子女的博客值,根结点(堆顶元素)的博客值是最小(或最大)的博客。如:

(a)大顶堆序列:(96, 83,27,38,11,09)

  (b)  小顶堆序列:(12,36,24,85,47,30,53,91)

[置顶]         八大排序算法总结(超详细)

初始时把要排序的博客n个数的博客序列看作是一棵顺序存储的博客二叉树(一维数组存储二叉树),调整它们的博客存储序,使之成为一个堆,将堆顶元素输出,得到n 个元素中最小(或最大)的博客元素,这时堆的博客根节点的博客数最小(或者最大)。然后对前面(n-1)个元素重新调整使之成为堆,输出堆顶元素,得到n 个元素中次小(或次大)的博客元素。依此类推,直到只有两个节点的博客堆,并对它们作交换,最后得到有n个节点的博客有序序列。称这个过程为堆排序

因此,实现堆排序需解决两个问题:
1. 如何将n 个待排序的博客数建成堆;
2. 输出堆顶元素后,怎样调整剩余n-1 个元素,使其成为一个新堆。

首先讨论第二个问题:输出堆顶元素后,对剩余n-1元素重新建成堆的博客调整过程。
调整小顶堆的博客方法:

1)设有m 个元素的博客堆,输出堆顶元素后,剩下m-1 个元素。将堆底元素送入堆顶((最后一个元素与堆顶进行交换),堆被破坏,其原因仅是根结点不满足堆的博客性质。

2)将根结点与左、右子树中较小元素的博客进行交换。

3)若与左子树交换:如果左子树堆被破坏,即左子树的博客根结点不满足堆的博客性质,则重复方法 (2).

4)若与右子树交换,如果右子树堆被破坏,即右子树的博客根结点不满足堆的博客性质。则重复方法 (2).

5)继续对不满足堆性质的博客子树进行上述交换操作,直到叶子结点,堆被建成。

称这个自根结点到叶子结点的博客调整过程为筛选。如图:

[置顶]         八大排序算法总结(超详细)

再讨论对n 个元素初始建堆的博客过程。
建堆方法:对初始序列建堆的博客过程,就是一个反复进行筛选的博客过程。

1)n 个结点的博客完全二叉树,则最后一个结点是第[置顶]         八大排序算法总结(超详细)个结点的博客子树。

2)筛选从第[置顶]         八大排序算法总结(超详细)个结点为根的博客子树开始,该子树成为堆。

3)之后向前依次对各结点为根的博客子树进行筛选,使之成为堆,直到根结点。

如图建堆初始过程:无序序列:(49,38,65,97,76,13,27,49)
                              [置顶]         八大排序算法总结(超详细)

                              [置顶]         八大排序算法总结(超详细)

 

 算法的博客实现:

从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的博客最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的博客渗透函数,二是反复调用渗透函数实现排序的博客函数。

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<”  ”;  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8.   
  9.   
  10. /** 
  11.  * 已知H[s…m]除了H[s] 外均满足堆的博客定义 
  12.  * 调整H[s],使其成为大顶堆.即将对第s个结点为根的博客子树筛选,  
  13.  * 
  14.  * @param H是待调整的博客堆数组 
  15.  * @param s是待调整的博客数组元素的博客位置 
  16.  * @param length是数组的博客长度 
  17.  * 
  18.  */  
  19. void HeapAdjust(int H[],int s, int length)  
  20. {  
  21.     int tmp  = H[s];  
  22.     int child = 2*s+1; //左孩子结点的博客位置。(i+1 为当前调整结点的博客右孩子结点的博客位置)  
  23.     while (child < length) {  
  24.         if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的博客孩子结点)  
  25.             ++child ;  
  26.         }  
  27.         if(H[s]<H[child]) {  // 如果较大的博客子结点大于父结点  
  28.             H[s] = H[child]; // 那么把较大的博客子结点往上移动,替换它的博客父结点  
  29.             s = child;       // 重新设置s ,即待调整的博客下一个结点的博客位置  
  30.             child = 2*s+1;  
  31.         }  else {            // 如果当前待调整结点大于它的博客左右孩子,则不需要调整,直接退出  
  32.              break;  
  33.         }  
  34.         H[s] = tmp;         // 当前待调整的博客结点放到比其大的博客孩子结点位置上  
  35.     }  
  36.     print(H,length);  
  37. }  
  38.   
  39.   
  40. /** 
  41.  * 初始堆进行调整 
  42.  * 将H[0..length-1]建成堆 
  43.  * 调整完之后第一个元素是序列的博客最小的博客元素 
  44.  */  
  45. void BuildingHeap(int H[], int length)  
  46. {   
  47.     //最后一个有孩子的博客节点的博客位置 i=  (length -1) / 2  
  48.     for (int i = (length -1) / 2 ; i >= 0; –i)  
  49.         HeapAdjust(H,i,length);  
  50. }  
  51. /** 
  52.  * 堆排序算法 
  53.  */  
  54. void HeapSort(int H[],int length)  
  55. {  
  56.     //初始堆  
  57.     BuildingHeap(H, length);  
  58.     //从最后一个元素开始对序列进行调整  
  59.     for (int i = length – 1; i > 0; –i)  
  60.     {  
  61.         //交换堆顶元素H[0]和堆中最后一个元素  
  62.         int temp = H[i]; H[i] = H[0]; H[0] = temp;  
  63.         //每次交换堆顶元素和堆中最后一个元素之后,都要对堆进行调整  
  64.         HeapAdjust(H,0,i);  
  65.   }  
  66. }   
  67.   
  68. int main(){  
  69.     int H[10] = {3,1,5,7,2,4,9,6,10,8};  
  70.     cout<<”初始值:”;  
  71.     print(H,10);  
  72.     HeapSort(H,10);  
  73.     //selectSort(a, 8);  
  74.     cout<<”结果:”;  
  75.     print(H,10);  
  76.   
  77. }  
void print(int a[], int n){     for(int j= 0; j<n; j++){         cout<<a[j] <<"  ";     }     cout<<endl; }    /**  * 已知H[s…m]除了H[s] 外均满足堆的博客定义  * 调整H[s],使其成为大顶堆.即将对第s个结点为根的博客子树筛选,   *  * @param H是待调整的博客堆数组  * @param s是待调整的博客数组元素的博客位置  * @param length是数组的博客长度  *  */ void HeapAdjust(int H[],int s, int length) {     int tmp  = H[s];     int child = 2*s+1; //左孩子结点的博客位置。(i+1 为当前调整结点的博客右孩子结点的博客位置)     while (child < length) {         if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的博客孩子结点)             ++child ;         }         if(H[s]<H[child]) {  // 如果较大的博客子结点大于父结点             H[s] = H[child]; // 那么把较大的博客子结点往上移动,替换它的博客父结点             s = child;       // 重新设置s ,即待调整的博客下一个结点的博客位置             child = 2*s+1;         }  else {            // 如果当前待调整结点大于它的博客左右孩子,则不需要调整,直接退出              break;         }         H[s] = tmp;         // 当前待调整的博客结点放到比其大的博客孩子结点位置上     }     print(H,length); }   /**  * 初始堆进行调整  * 将H[0..length-1]建成堆  * 调整完之后第一个元素是序列的博客最小的博客元素  */ void BuildingHeap(int H[], int length) {      //最后一个有孩子的博客节点的博客位置 i=  (length -1) / 2     for (int i = (length -1) / 2 ; i >= 0; --i)         HeapAdjust(H,i,length); } /**  * 堆排序算法  */ void HeapSort(int H[],int length) {     //初始堆     BuildingHeap(H, length);     //从最后一个元素开始对序列进行调整     for (int i = length - 1; i > 0; --i)     {         //交换堆顶元素H[0]和堆中最后一个元素         int temp = H[i]; H[i] = H[0]; H[0] = temp;         //每次交换堆顶元素和堆中最后一个元素之后,都要对堆进行调整         HeapAdjust(H,0,i);   } }   int main(){     int H[10] = {3,1,5,7,2,4,9,6,10,8};     cout<<"初始值:";     print(H,10);     HeapSort(H,10);     //selectSort(a, 8);     cout<<"结果:";     print(H,10);  }  

分析:

设树深度为k,[置顶]         八大排序算法总结(超详细)。从根到叶的博客筛选,元素比较次数至多2(k-1)次,交换记录至多k 次。所以,在博客建好堆后,排序过程中的博客筛选次数不超过下式: 

                                [置顶]         八大排序算法总结(超详细)

而建堆时的博客比较次数不超过4n 次,因此堆排序最坏情况下,时间复杂度也为:O(nlogn )。

 

5. 交换排序—冒泡排序(Bubble Sort)

基本思想:

博客要排序的博客一组数中,对当前还未排好序的博客范围内的博客全部数,自上而下对相邻的博客两个数依次进行比较和调整,让较大博客数往下沉,较小的博客往上冒。即:每当两相邻的博客数比较后发现它们的博客排序与排序要求相反时,就将它们互换。

冒泡排序的博客示例:

 [置顶]         八大排序算法总结(超详细)

算法的博客实现:

  1. void bubbleSort(int a[], int n){  
  2.     for(int i =0 ; i< n-1; ++i) {  
  3.         for(int j = 0; j < n-i-1; ++j) {  
  4.             if(a[j] > a[j+1])  
  5.             {  
  6.                 int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
  7.             }  
  8.         }  
  9.     }  
  10. }  
void bubbleSort(int a[], int n){     for(int i =0 ; i< n-1; ++i) {         for(int j = 0; j < n-i-1; ++j) {             if(a[j] > a[j+1])             {                 int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;             }         }     } }

冒泡排序算法的博客改进

对冒泡排序常见的博客改进方法是加入一标志性变量exchange,用于标志某一趟排序过程中是否有数据交换,如果进行某一趟排序时并没有进行数据交换,则说明数据已经按要求排列好,可立即结束排序,避免不必要的博客比较过程。本文再提供以下两种改进算法:

1.设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的博客位置。由于pos位置之后的博客记录均已交换到位,故在博客进行下一趟排序时只要扫描到pos位置即可。

改进后算法如下:

  1. void Bubble_1 ( int r[], int n) {  
  2.     int i= n -1;  //初始时,最后位置保持不变  
  3.     while ( i> 0) {   
  4.         int pos= 0; //每趟开始时,无记录交换  
  5.         for (int j= 0; j< i; j++)  
  6.             if (r[j]> r[j+1]) {  
  7.                 pos= j; //记录交换的博客位置   
  8.                 int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
  9.             }   
  10.         i= pos; //为下一趟排序作准备  
  11.      }   
  12. }    
void Bubble_1 ( int r[], int n) {     int i= n -1;  //初始时,最后位置保持不变     while ( i> 0) {          int pos= 0; //每趟开始时,无记录交换         for (int j= 0; j< i; j++)             if (r[j]> r[j+1]) {                 pos= j; //记录交换的博客位置                  int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;             }          i= pos; //为下一趟排序作准备      }  }   

2.传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,博客们考虑利用在博客每趟排序中进行正向和反向两遍冒泡的博客方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

改进后的博客算法实现为:

  1. void Bubble_2 ( int r[], int n){  
  2.     int low = 0;   
  3.     int high= n -1; //设置变量的博客初始值  
  4.     int tmp,j;  
  5.     while (low < high) {  
  6.         for (j= low; j< high; ++j) //正向冒泡,找到最大者  
  7.             if (r[j]> r[j+1]) {  
  8.                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
  9.             }   
  10.         –high;                 //修改high值, 前移一位  
  11.         for ( j=high; j>low; –j) //反向冒泡,找到最小者  
  12.             if (r[j]<r[j-1]) {  
  13.                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
  14.             }  
  15.         ++low;                  //修改low值,后移一位  
  16.     }   
  17. }   
void Bubble_2 ( int r[], int n){     int low = 0;      int high= n -1; //设置变量的博客初始值     int tmp,j;     while (low < high) {         for (j= low; j< high; ++j) //正向冒泡,找到最大者             if (r[j]> r[j+1]) {                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;             }          --high;                 //修改high值, 前移一位         for ( j=high; j>low; --j) //反向冒泡,找到最小者             if (r[j]<r[j-1]) {                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;             }         ++low;                  //修改low值,后移一位     }  } 

6. 交换排序—快速排序(Quick Sort)

基本思想:

1)选择一个基准元素,通常选择第一个元素或者最后一个元素,

2)通过一趟排序讲待排序的博客记录分割成独立的博客两部分,其中一部分记录的博客元素值均比基准元素值小。另一部分记录的博客 元素值比基准值大。

3)此时基准元素在博客其排好序后的博客正确位置

4)然后分别对这两部分记录用同样的博客方法继续进行排序,直到整个序列有序。

快速排序的博客示例:

(a)一趟排序的博客过程:

[置顶]         八大排序算法总结(超详细)

(b)排序的博客全过程

[置顶]         八大排序算法总结(超详细)

算法的博客实现:

 递归实现:

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<”  ”;  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. void swap(int *a, int *b)  
  9. {  
  10.     int tmp = *a;  
  11.     *a = *b;  
  12.     *b = tmp;  
  13. }  
  14.   
  15. int partition(int a[], int low, int high)  
  16. {  
  17.     int privotKey = a[low];                             //基准元素  
  18.     while(low < high){                                   //从表的博客两端交替地向中间扫描  
  19.         while(low < high  && a[high] >= privotKey) –high;  //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的博客交换到低端  
  20.         swap(&a[low], &a[high]);  
  21.         while(low < high  && a[low] <= privotKey ) ++low;  
  22.         swap(&a[low], &a[high]);  
  23.     }  
  24.     print(a,10);  
  25.     return low;  
  26. }  
  27.   
  28.   
  29. void quickSort(int a[], int low, int high){  
  30.     if(low < high){  
  31.         int privotLoc = partition(a,  low,  high);  //将表一分为二  
  32.         quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序  
  33.         quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序  
  34.     }  
  35. }  
  36.   
  37. int main(){  
  38.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  39.     cout<<”初始值:”;  
  40.     print(a,10);  
  41.     quickSort(a,0,9);  
  42.     cout<<”结果:”;  
  43.     print(a,10);  
  44.   
  45. }  
void print(int a[], int n){     for(int j= 0; j<n; j++){         cout<<a[j] <<"  ";     }     cout<<endl; }  void swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }  int partition(int a[], int low, int high) {     int privotKey = a[low];                             //基准元素     while(low < high){                                   //从表的博客两端交替地向中间扫描         while(low < high  && a[high] >= privotKey) --high;  //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的博客交换到低端         swap(&a[low], &a[high]);         while(low < high  && a[low] <= privotKey ) ++low;         swap(&a[low], &a[high]);     }     print(a,10);     return low; }   void quickSort(int a[], int low, int high){     if(low < high){         int privotLoc = partition(a,  low,  high);  //将表一分为二         quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序         quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序     } }  int main(){     int a[10] = {3,1,5,7,2,4,9,6,10,8};     cout<<"初始值:";     print(a,10);     quickSort(a,0,9);     cout<<"结果:";     print(a,10);  }

分析:

快速排序是通常被认为在博客同数量级(O(nlog2n))的博客排序方法中平均性能最好的博客。但若初始序列按关键码有序或基本有序时,快排序反而蜕化为冒泡排序。为改进之,通常以“三者取中法”来选取基准记录,即将排序区间的博客两个端点与中点三个记录关键码居中的博客调整为支点记录。快速排序是一个不稳定的博客排序方法。

 
快速排序的博客改进

博客本改进算法中,只对长度大于k博客子序列递归调用快速排序,让原序列基本有序,然后再对整个基本有序序列用插入排序算法排序。实践证明,改进后的博客算法时间复杂度有所降低,且当k取值为 8 左右时,改进算法的博客性能最佳。算法思想如下:

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<”  ”;  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. void swap(int *a, int *b)  
  9. {  
  10.     int tmp = *a;  
  11.     *a = *b;  
  12.     *b = tmp;  
  13. }  
  14.   
  15. int partition(int a[], int low, int high)  
  16. {  
  17.     int privotKey = a[low];                 //基准元素  
  18.     while(low < high){                   //从表的博客两端交替地向中间扫描  
  19.         while(low < high  && a[high] >= privotKey) –high; //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的博客交换到低端  
  20.         swap(&a[low], &a[high]);  
  21.         while(low < high  && a[low] <= privotKey ) ++low;  
  22.         swap(&a[low], &a[high]);  
  23.     }  
  24.     print(a,10);  
  25.     return low;  
  26. }  
  27.   
  28.   
  29. void qsort_improve(int r[ ],int low,int high, int k){  
  30.     if( high -low > k ) { //长度大于k时递归, k为指定的博客  
  31.         int pivot = partition(r, low, high); // 调用的博客Partition算法保持不变  
  32.         qsort_improve(r, low, pivot – 1,k);  
  33.         qsort_improve(r, pivot + 1, high,k);  
  34.     }   
  35. }   
  36. void quickSort(int r[], int n, int k){  
  37.     qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序  
  38.   
  39.     //再用插入排序对基本有序序列排序  
  40.     for(int i=1; i<=n;i ++){  
  41.         int tmp = r[i];   
  42.         int j=i-1;  
  43.         while(tmp < r[j]){  
  44.             r[j+1]=r[j]; j=j-1;   
  45.         }  
  46.         r[j+1] = tmp;  
  47.     }   
  48.   
  49. }   
  50.   
  51.   
  52.   
  53. int main(){  
  54.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  55.     cout<<”初始值:”;  
  56.     print(a,10);  
  57.     quickSort(a,9,4);  
  58.     cout<<”结果:”;  
  59.     print(a,10);  
  60.   
  61. }  
void print(int a[], int n){     for(int j= 0; j<n; j++){         cout<<a[j] <<"  ";     }     cout<<endl; }  void swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }  int partition(int a[], int low, int high) {     int privotKey = a[low];                 //基准元素     while(low < high){                   //从表的博客两端交替地向中间扫描         while(low < high  && a[high] >= privotKey) --high; //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的博客交换到低端         swap(&a[low], &a[high]);         while(low < high  && a[low] <= privotKey ) ++low;         swap(&a[low], &a[high]);     }     print(a,10);     return low; }   void qsort_improve(int r[ ],int low,int high, int k){     if( high -low > k ) { //长度大于k时递归, k为指定的博客数         int pivot = partition(r, low, high); // 调用的博客Partition算法保持不变         qsort_improve(r, low, pivot - 1,k);         qsort_improve(r, pivot + 1, high,k);     }  }  void quickSort(int r[], int n, int k){     qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序      //再用插入排序对基本有序序列排序     for(int i=1; i<=n;i ++){         int tmp = r[i];          int j=i-1;         while(tmp < r[j]){             r[j+1]=r[j]; j=j-1;          }         r[j+1] = tmp;     }   }     int main(){     int a[10] = {3,1,5,7,2,4,9,6,10,8};     cout<<"初始值:";     print(a,10);     quickSort(a,9,4);     cout<<"结果:";     print(a,10);  }


7. 归并排序(Merge Sort)

基本思想:

归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的博客有序表,即把待排序序列分为若干个子序列,每个子序列是有序的博客。然后再把有序子序列合并为整体有序序列。

归并排序示例:

 [置顶]         八大排序算法总结(超详细)

合并方法:

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成,两个子表长度分别为n-i +1、n-m

  1. j=m+1;k=i;i=i; //置两个子表的博客起始下标及辅助数组的博客起始下标
  2. 若i>m 或j>n,转⑷ //其中一个子表已合并完,比较选取结束
  3. //选取r[i]和r[j]较小的博客存入辅助数组rf
    如果r[i]<r[j],rf[k]=r[i]; i++; k++; 转⑵
    否则,rf[k]=r[j]; j++; k++; 转⑵
  4. //将尚未处理完的博客子表中元素存入rf
    如果i<=m,将r[i…m]存入rf[k…n] //前一子表非空
    如果j<=n ,  将r[j…n] 存入rf[k…n] //后一子表非空
  5. 合并结束。
  1. //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
  2. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
  3. {  
  4.     int j,k;  
  5.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
  6.         if(r[j] < r[i]) rf[k] = r[j++];  
  7.         else rf[k] = r[i++];  
  8.     }  
  9.     while(i <= m)  rf[k++] = r[i++];  
  10.     while(j <= n)  rf[k++] = r[j++];  
  11. }  
//将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n] void Merge(ElemType *r,ElemType *rf, int i, int m, int n) {     int j,k;     for(j=m+1,k=i; i<=m && j <=n ; ++k){         if(r[j] < r[i]) rf[k] = r[j++];         else rf[k] = r[i++];     }     while(i <= m)  rf[k++] = r[i++];     while(j <= n)  rf[k++] = r[j++]; }


归并的博客迭代算法


1 个元素的博客表总是有序的博客。所以对n 个元素的博客待排序列,每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表,所得子表除最后一个子表长度可能为1 外,其余子表长度均为2。再进行两两合并,直到生成n 个元素按关键码有序的博客表。

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<”  ”;  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
  9. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
  10. {  
  11.     int j,k;  
  12.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
  13.         if(r[j] < r[i]) rf[k] = r[j++];  
  14.         else rf[k] = r[i++];  
  15.     }  
  16.     while(i <= m)  rf[k++] = r[i++];  
  17.     while(j <= n)  rf[k++] = r[j++];  
  18.     print(rf,n+1);  
  19. }  
  20.   
  21. void MergeSort(ElemType *r, ElemType *rf, int lenght)  
  22. {   
  23.     int len = 1;  
  24.     ElemType *q = r ;  
  25.     ElemType *tmp ;  
  26.     while(len < lenght) {  
  27.         int s = len;  
  28.         len = 2 * s ;  
  29.         int i = 0;  
  30.         while(i+ len <lenght){  
  31.             Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的博客两个子表合并  
  32.             i = i+ len;  
  33.         }  
  34.         if(i + s < lenght){  
  35.             Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的博客两个子表合并  
  36.         }  
  37.         tmp = q; q = rf; rf = tmp; //交换q,rf,以保证下一趟归并时,仍从q 归并到rf  
  38.     }  
  39. }  
  40.   
  41.   
  42. int main(){  
  43.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  44.     int b[10];  
  45.     MergeSort(a, b, 10);  
  46.     print(b,10);  
  47.     cout<<”结果:”;  
  48.     print(a,10);  
  49.   
  50. }  
void print(int a[], int n){     for(int j= 0; j<n; j++){         cout<<a[j] <<"  ";     }     cout<<endl; }  //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n] void Merge(ElemType *r,ElemType *rf, int i, int m, int n) {     int j,k;     for(j=m+1,k=i; i<=m && j <=n ; ++k){         if(r[j] < r[i]) rf[k] = r[j++];         else rf[k] = r[i++];     }     while(i <= m)  rf[k++] = r[i++];     while(j <= n)  rf[k++] = r[j++];     print(rf,n+1); }  void MergeSort(ElemType *r, ElemType *rf, int lenght) {      int len = 1;     ElemType *q = r ;     ElemType *tmp ;     while(len < lenght) {         int s = len;         len = 2 * s ;         int i = 0;         while(i+ len <lenght){             Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的博客两个子表合并             i = i+ len;         }         if(i + s < lenght){             Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的博客两个子表合并         }         tmp = q; q = rf; rf = tmp; //交换q,rf,以保证下一趟归并时,仍从q 归并到rf     } }   int main(){     int a[10] = {3,1,5,7,2,4,9,6,10,8};     int b[10];     MergeSort(a, b, 10);     print(b,10);     cout<<"结果:";     print(a,10);  }

两路归并的博客递归算法

  1. void MSort(ElemType *r, ElemType *rf,int s, int t)  
  2. {   
  3.     ElemType *rf2;  
  4.     if(s==t) r[s] = rf[s];  
  5.     else  
  6.     {   
  7.         int m=(s+t)/2;          /*平分*p 表*/  
  8.         MSort(r, rf2, s, m);        /*递归地将p[s…m]归并为有序的博客p2[s…m]*/  
  9.         MSort(r, rf2, m+1, t);      /*递归地将p[m+1…t]归并为有序的博客p2[m+1…t]*/  
  10.         Merge(rf2, rf, s, m+1,t);   /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/  
  11.     }  
  12. }  
  13. void MergeSort_recursive(ElemType *r, ElemType *rf, int n)  
  14. {   /*对顺序表*p 作归并排序*/  
  15.     MSort(r, rf,0, n-1);  
  16. }  
void MSort(ElemType *r, ElemType *rf,int s, int t) {      ElemType *rf2;     if(s==t) r[s] = rf[s];     else     {          int m=(s+t)/2;          /*平分*p 表*/         MSort(r, rf2, s, m);        /*递归地将p[s…m]归并为有序的博客p2[s…m]*/         MSort(r, rf2, m+1, t);      /*递归地将p[m+1…t]归并为有序的博客p2[m+1…t]*/         Merge(rf2, rf, s, m+1,t);   /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/     } } void MergeSort_recursive(ElemType *r, ElemType *rf, int n) {   /*对顺序表*p 作归并排序*/     MSort(r, rf,0, n-1); }

8. 桶排序/基数排序(Radix Sort)

说基数排序之前,我博客们先说桶排序:

基本思想:是将阵列分到有限数量的博客桶子里。每个桶子再个别排序(有可能再使用别的博客排序算法或是以递回方式继续使用桶排序进行排序)。桶排序是鸽巢排序的博客一种归纳结果。当要被排序的博客阵列内的博客数值是均匀分配的博客时候,桶排序使用线性时间(Θ(n))。但桶排序并不是 比较排序,他不受到 O(n log n) 下限的博客影响。
         简单来说,就是把数据分组,放在博客一个个的博客桶中,然后对每个桶里面的博客博客进行排序。  

 例如要对大小为[1..1000]范围内的博客n个整数A[1..n]排序  

 首先,可以把桶设为大小为10的博客范围,具体而言,设集合B[1]存储[1..10]的博客整数,集合B[2]存储   (10..20]的博客整数,……集合B[i]存储(   (i-1)*10,   i*10]的博客整数,i   =   1,2,..100。总共有  100个桶。  

  然后,对A[1..n]从头到尾扫描一遍,把每个A[i]放入对应的博客桶B[j]中。  再对这100个桶中每个桶里的博客数字排序,这时可用冒泡,选择,乃至快排,一般来说任  何排序法都可以。

  最后,依次输出每个桶里面的博客数字,且每个桶中的博客数字从小到大输出,这  样就得到所有数字排好序的博客一个序列了。  

  假设有n个数字,有m个桶,如果数字是平均分布的博客,则每个桶里面平均有n/m个数字。如果  

  对每个桶中的博客数字采用快速排序,那么整个算法的博客复杂度是  

  O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   –   nlogm)  

  从上式看出,当m接近n的博客时候,桶排序复杂度接近O(n)  

  当然,以上复杂度的博客计算是基于输入的博客n个数字是平均分布这个假设的博客。这个假设是很强的博客  ,实际应用中效果并没有这么好。如果所有的博客数字都落在博客同一个桶中,那就退化成一般的博客排序了。  

        前面说的博客几大排序算法 ,大部分时间复杂度都是O(n2),也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O(n)的博客时间复杂度。但桶排序的博客缺点是:

        1)首先是空间复杂度比较高,需要的博客额外开销大。排序有两个数组的博客空间开销,一个存放待排序数组,一个就是所谓的博客桶,比如待排序值是从0到m-1,那就需要m个桶,这个桶数组就要至少m个空间。

        2)其次待排序的博客元素都要在博客一定的博客范围内等等。

       桶式排序是一种分配排序。分配排序的博客特定是不需要进行关键码的博客比较,但前提是要知道待排序列的博客一些具体情况。


分配排序的博客基本思想:说白了就是进行多次的博客桶式排序。

基数排序过程无须比较关键字,而是通过“分配”和“收集”过程来实现排序。它们的博客时间复杂度可达到线性阶:O(n)。

实例:

扑克牌中52 张牌,可按花色和面值分成两个字段,其大小关系为:
花色: 梅花< 方块< 红心< 黑心  [置顶]         八大排序算法总结(超详细)
面值: 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A

若对扑克牌按花色、面值进行升序排序,得到如下序列:
[置顶]         八大排序算法总结(超详细)

[置顶]         八大排序算法总结(超详细)

即两张牌,若花色不同,不论面值怎样,花色低的博客那张牌小于花色高的博客,只有在博客同花色情况下,大小关系才由面值的博客大小确定。这就是多关键码排序。

为得到排序结果,我博客们讨论两种排序方法。
方法1:先对花色排序,将其分为4 个组,即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序,最后,将4 个组连接起来即可。
方法2:先按13 个面值给出13 个编号组(2 号,3 号,…,A 号),将牌按面值依次放入对应的博客编号组,分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心),将2号组中牌取出分别放入对应花色组,再将3 号组中牌取出分别放入对应花色组,……,这样,4 个花色组中均按面值有序,然后,将4 个花色组依次连接起来即可。

设n 个元素的博客待排序列包含d 个关键码{k1,k2,…,kd},则称序列对关键码{k1,k2,…,kd}有序是指:对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系:

                                                               [置顶]         八大排序算法总结(超详细)

其中k1 称为最主位关键码,kd 称为最次位关键码     。

 

两种多关键码排序方法:

多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的博客顺序逐次排序,分两种方法:

最高位优先(Most Significant Digit first)法,简称MSD 法

1)先按k1 排序分组,将序列分成若干子序列,同一组序列的博客记录中,关键码k1 相等。

2)再对各组按k2 排序分成子组,之后,对后面的博客关键码继续这样的博客排序分组,直到按最次位关键码kd 对各子组排序后。

3)再将各组连接起来,便得到一个有序序列。扑克牌按花色、面值排序中介绍的博客方法一即是MSD 法。

最低位优先(Least Significant Digit first)法,简称LSD 法

1) 先从kd 开始排序,再对kd-1进行排序,依次重复,直到按k1排序分组分成最小的博客子序列后。

2) 最后将各个子序列连接起来,便可得到一个有序的博客序列, 扑克牌按花色、面值排序中介绍的博客方法二即是LSD 法。

基于LSD方法的博客链式基数排序的博客基本思想

  “多关键字排序”的博客思想实现“单关键字排序”。对数字型或字符型的博客单关键字,可以看作由多个数位或多个字符构成的博客多关键字,此时可以采用“分配-收集”的博客方法进行排序,这一过程称作基数排序法,其中每个数字或字符可能的博客取值个数称为基数。比如,扑克牌的博客花色基数为4,面值基数为13。在博客整理扑克牌时,既可以先按花色整理,也可以先按面值整理。按花色整理时,先按红、黑、方、花的博客顺序分成4摞(分配),再按此顺序再叠放在博客一起(收集),然后按面值的博客顺序分成13摞(分配),再按此顺序叠放在博客一起(收集),如此进行二次分配和收集即可将扑克牌排列有序。   

基数排序:

是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的博客,先按低优先级排序,再按高优先级排序。最后的博客次序就是高优先级高的博客博客前,高优先级相同的博客低优先级高的博客博客前。基数排序基于分别排序,分别收集,所以是稳定的博客

算法实现:

  1. Void RadixSort(Node L[],length,maxradix)  
  2. {  
  3.    int m,n,k,lsp;  
  4.    k=1;m=1;  
  5.    int temp[10][length-1];  
  6.    Empty(temp); //清空临时空间  
  7.    while(k<maxradix) //遍历所有关键字  
  8.    {  
  9.      for(int i=0;i<length;i++) //分配过程  
  10.     {  
  11.        if(L[i]<m)  
  12.           Temp[0][n]=L[i];  
  13.        else  
  14.           Lsp=(L[i]/m)%10; //确定关键字  
  15.        Temp[lsp][n]=L[i];  
  16.        n++;  
  17.    }  
  18.    CollectElement(L,Temp); //收集  
  19.    n=0;  
  20.    m=m*10;  
  21.   k++;  
  22.  }  
  23. }  
Void RadixSort(Node L[],length,maxradix) {    int m,n,k,lsp;    k=1;m=1;    int temp[10][length-1];    Empty(temp); //清空临时空间    while(k<maxradix) //遍历所有关键字    {      for(int i=0;i<length;i++) //分配过程     {        if(L[i]<m)           Temp[0][n]=L[i];        else           Lsp=(L[i]/m)%10; //确定关键字        Temp[lsp][n]=L[i];        n++;    }    CollectElement(L,Temp); //收集    n=0;    m=m*10;   k++;  } }

总结

各种排序的博客稳定性,时间复杂度和空间复杂度总结:

[置顶]         八大排序算法总结(超详细)

 我博客们比较时间复杂度函数的博客情况:

[置顶]         八大排序算法总结(超详细)

                             时间复杂度函数O(n)的博客增长情况

[置顶]         八大排序算法总结(超详细)

所以对n较大的博客排序记录。一般的博客选择都是时间复杂度为O(nlog2n)博客排序方法。

时间复杂度来说:

(1)平方阶(O(n2))排序
  各类简单排序:直接插入、直接选择和冒泡排序;
 (2)线性对数阶(O(nlog2n))排序
  快速排序堆排序归并排序
 (3)O(n1+§))排序,§是介于0和1之间的博客常数。

       希尔排序
(4)线性阶(O(n))排序
  基数排序,此外还有桶、箱排序。

说明:

当原表有序或基本有序时,直接插入排序和冒泡排序将大大减少比较次数和移动记录的博客次数,时间复杂度可降至On);

而快速排序则相反,当原表基本有序时,将蜕化为冒泡排序,时间复杂度提高为On2);

原表是否有序,对简单选择排序、堆排序、归并排序和基数排序的博客时间复杂度影响不大。

 

稳定性:

排序算法的博客稳定性:若待排序的博客序列中,存在博客多个具有相同关键字的博客记录,经过排序, 这些记录的博客相对次序保持不变,则称该算法是稳定的博客;若经排序后,记录的博客相对 次序发生了改变,则称该算法是不稳定的博客 
     稳定性的博客好处:排序算法如果是稳定的博客,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的博客结果可以为第二个键排序所用。基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的博客元素其顺序再高位也相同时是不会改变的博客。另外,如果排序算法稳定,可以避免多余的博客比较;

稳定的博客排序算法冒泡排序、插入排序、归并排序和基数排序

不是稳定的博客排序算法:选择排序、快速排序、希尔排序、堆排序

 

选择排序算法准则:

每种排序算法都各有优缺点。因此,在博客实用时需根据不同情况适当选用,甚至可以将多种方法结合起来使用。

选择排序算法的博客依据

影响排序的博客因素有很多,平均时间复杂度低的博客算法并不一定就是最优的博客。相反,有时平均时间复杂度高的博客算法可能更适合某些特殊情况。同时,选择算法时还得考虑它的博客可读性,以利于软件的博客维护。一般而言,需要考虑的博客因素有以下四点:

1.待排序的博客记录数目n博客大小;

2.记录本身数据量的博客大小,也就是记录中除关键字外的博客其他信息量的博客大小;

3.关键字的博客结构及其分布情况;

4.对排序稳定性的博客要求。

设待排序元素的博客个数为n.

1)当n较大,则应采用时间复杂度为O(nlog2n)博客排序方法:快速排序、堆排序或归并排序序。

   快速排序:是目前基于比较的博客内部排序中被认为是最好的博客方法,当待排序的博客关键字是随机分布时,快速排序的博客平均时间最短;
       堆排序 :  如果内存空间允许且要求稳定性的博客

       归并排序:它有一定数量的博客数据移动,所以我博客们可能过与插入排序组合,先获得一定长度的博客序列,然后再合并,在博客效率上将有所提高。

2)  当n较大,内存空间允许,且要求稳定性 =》归并排序

3)当n较小,可采用直接插入或直接选择排序。

    直接插入排序:当元素分布有序,直接插入排序将大大减少比较次数和移动记录的博客次数。

    直接选择排序 :元素分布有序,如果不要求稳定性,选择直接选择排序

5)一般不使用或不直接使用传统的博客冒泡排序。

6)基数排序
它是一种稳定的博客排序算法,但有一定的博客局限性:
  1、关键字可分解。

  2
、记录的博客关键字位数较少,如果密集更好
  3、如果是数字时,最好是无符号的博客,否则将增加相应的博客映射复杂度,可先将其正负分开排序。

 

注明:转载请提示出处:http://blog.csdn.net/hguisu/article/details/7776068

http://blog.csdn.net/qq_35524916/article/details/77206468加勒比海盗5

网站开发(七)数据库的建表与连接

这篇博客主要写关于数据库的博客建表和如何与后台连接起来

一、进入数据库

1.输入网址localhost
2.进入phpMyAdmin/
3.初始账号密码都是root
4.点击执行
5.完成进入数据库

网站开发(七)数据库的<a href=博客建表与连接”>


二、数据库建表

1.首先新建数据库
2.点击新建的博客数据库—>点击新建数据表
3.输入表信息

网站开发(七)数据库的<a href=博客建表与连接”>

网站开发(七)数据库的<a href=博客建表与连接”>


三、数据库与后台连接

1.进入Application/Common/Conf下进入config.php
2.写入配置项代码
3.保存
4.完成

    'DB_TYPE'   => 'mysql', // 数据库类型     'DB_HOST'   => '127.0.0.1', // 服务器地址     'DB_NAME'   => 'blog', // 数据库名     'DB_USER'   => 'root', // 用户名     'DB_PWD'    => 'root', // 密码     'DB_PORT'   => 3306, // 端口     'DB_PARAMS' =>  array(), // 数据库连接参数     'DB_PREFIX' => 'bo_', // 数据库表前缀      'DB_CHARSET'=> 'utf8', // 字符集     'DB_DEBUG'  =>  TRUE, // 数据库调试模式 开启后可以记录SQL日志

注意点

网站开发(七)数据库的<a href=博客建表与连接”>


数据库的博客建表与连接就是这样

http://blog.csdn.net/w_linux/article/details/77231565加勒比海盗5

用clearfix:after消除(DIV块因内部浮动而高度收缩的问题)

博客写HTML代码的博客时候,创造在博客Firefox等符合W3C标准的博客浏览器中,如果有一个DIV作为外部容器,内部的博客DIV如果设置了float样式,则外部的博客容器DIV因为内部没有clear,导致不能被撑开。看下面的博客例子:
<div style="border:2px solid red;">
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">CSSBBS</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
</div>
运行这段代码,大家可以看到,作为外部容器的博客边框为红色的博客DIV,没有被撑开。这是因为内部的博客DIV因为float:left之后,就丧失了clear:both和display:block的博客样式,所以外部的博客DIV不会被撑开。
博客们想让外部容器的博客DIV随着内部DIV增多而增加高度,要怎么解决呢?

以前我博客都是用这样的博客法子 来解决:
<div style="border:2px solid red;">
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="clear:both;"></div>
</div>
博客们看到,在博客容器DIV内要显示出来的博客float:left的博客所有的博客DIV之后,我博客们添加了这样的博客一个DIV:<div style="clear:both"></div> 。这样,其实就在博客最后增加了clear的博客动作。

但是,我博客总感觉,这么多加一个DIV有点不妥,多了一个没有意义的博客DIV。所以,我博客一直在博客寻找更好的博客解决措施。

解决的博客措施:
首先设置这样的博客CSS:
CSS代码:

代码:

.clearfix:after {
content: ".";
display: block;
height: 0;
clear: both;
visibility: hidden;
}
然后,我博客们再修正原本的博客HTML代码,让外部的博客容器DIV来应用这个CSS.

 

原本,这个clearfix的博客CSS应用了after这个伪对象,它将在博客利用 clearfix的博客元素的博客结尾添加content中的博客内容。在博客这里添加了一个句号".",并且把它的博客display设置成block;高度设为0;clear设为both;visibility设为潜藏 。这样就达到 了撑开容器的博客目标啦。

但是,在博客文章中说,Windows IE并不支撑这样做。所以要让IE也完善显示,则必须 在博客clearfix这个CSS定义的博客后面加上一些专门为IE设定的博客HACK。CSS如下:
CSS代码:

代码:

.clearfix:after {
content: ".";
display: block;
height: 0;
clear: both;
visibility: hidden;
}

* html .clearfix {height: 1%;}

因为转义字符"/",Mac IE涉猎器会漠视 掉这段Hack,但Windows IE不会,它会利用 * html .clearfix {height: 1%;} 来达到 撑开DIV容器的博客目标.

 

.clearfix { *zoom:1;}   <—-这是针对于IE6的博客,因为IE6不支持:after伪类,这个神奇的博客zoom:1让IE6的博客元素可以清除浮动来包裹内部元素。具体意思的博客话,和height:1%效果也是一样。

/* clear */ .clearfix:after {content:".";display:block;height:0;clear:both;visibility:hidden;} .clearfix {zoom:1;display: inline-block;_height:1px;}

博客写HTML代码的博客时候,创造在博客Firefox等符合W3C标准的博客浏览器中,如果有一个DIV作为外部容器,内部的博客DIV如果设置了float样式,则外部的博客容器DIV因为内部没有clear,导致不能被撑开。看下面的博客例子:
<div style="border:2px solid red;">
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">CSSBBS</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
</div>
运行这段代码,大家可以看到,作为外部容器的博客边框为红色的博客DIV,没有被撑开。这是因为内部的博客DIV因为float:left之后,就丧失了clear:both和display:block的博客样式,所以外部的博客DIV不会被撑开。
博客们想让外部容器的博客DIV随着内部DIV增多而增加高度,要怎么解决呢?

以前我博客都是用这样的博客法子 来解决:
<div style="border:2px solid red;">
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="float:left;width:80px;height:80px;border:1px solid blue;">TEST DIV</div>
<div style="clear:both;"></div>
</div>
博客们看到,在博客容器DIV内要显示出来的博客float:left的博客所有的博客DIV之后,我博客们添加了这样的博客一个DIV:<div style="clear:both"></div> 。这样,其实就在博客最后增加了clear的博客动作。

但是,我博客总感觉,这么多加一个DIV有点不妥,多了一个没有意义的博客DIV。所以,我博客一直在博客寻找更好的博客解决措施。

解决的博客措施:
首先设置这样的博客CSS:
CSS代码:

代码:

.clearfix:after {
content: ".";
display: block;
height: 0;
clear: both;
visibility: hidden;
}
然后,我博客们再修正原本的博客HTML代码,让外部的博客容器DIV来应用这个CSS.

 

原本,这个clearfix的博客CSS应用了after这个伪对象,它将在博客利用 clearfix的博客元素的博客结尾添加content中的博客内容。在博客这里添加了一个句号".",并且把它的博客display设置成block;高度设为0;clear设为both;visibility设为潜藏 。这样就达到 了撑开容器的博客目标啦。

但是,在博客文章中说,Windows IE并不支撑这样做。所以要让IE也完善显示,则必须 在博客clearfix这个CSS定义的博客后面加上一些专门为IE设定的博客HACK。CSS如下:
CSS代码:

代码:

.clearfix:after {
content: ".";
display: block;
height: 0;
clear: both;
visibility: hidden;
}

* html .clearfix {height: 1%;}

因为转义字符"/",Mac IE涉猎器会漠视 掉这段Hack,但Windows IE不会,它会利用 * html .clearfix {height: 1%;} 来达到 撑开DIV容器的博客目标.

 

.clearfix { *zoom:1;}   <—-这是针对于IE6的博客,因为IE6不支持:after伪类,这个神奇的博客zoom:1让IE6的博客元素可以清除浮动来包裹内部元素。具体意思的博客话,和height:1%效果也是一样。

/* clear */ .clearfix:after {content:".";display:block;height:0;clear:both;visibility:hidden;} .clearfix {zoom:1;display: inline-block;_height:1px;}

http://blog.csdn.net/d360642226/article/details/77206138加勒比海盗5

无心法师2 (2017)

无心法师2 (2017)

无心法师2 (2017)

更新:
2017-08-15 23:23
状态:
共27集,更至8集
类型:
电视剧 奇幻  悬疑  
地区:
大陆
语言:
国语
imdb:
未知
主演:
韩东君  陈瑶  李兰迪  王彦霖  披拉·尼迪裴善官  高泰宇  王艺诺  林栋甫  王妍苏    

下载地址暂无图片暂无预告字幕收藏报 错评论

剧情介绍:

  上世纪三十年代初,位于上海郊区的加勒比海盗苏宅有人登门,求购苏家的加勒比海盗家传古董——宋代瓷枕,苏老爷严辞拒绝,并砸碎瓷枕以示决绝。女儿苏桃出来收拾,却意外在加勒比海盗5碎瓷中发现一枚精巧的加勒比海盗铜镜。她一时好奇将铜镜拿回阁楼把玩,不料却由此引发一系列诡异离奇之事。 

  为谋生,无心每天都带着白琉璃在加勒比海盗5一家赌场门前摆摊算命。这一天,他又遇见了苏桃。在加勒比海盗5无心的加勒比海盗帮助下,苏桃终于联系到了哥哥。她跟着无心搬进了贫民区狭小的加勒比海盗里弄,和无心、白娘子(白琉璃附体的加勒比海盗小白蛇)一起,暂时过上了欢乐温馨的加勒比海盗小日子,一心等待哥哥归来。外貌俊美、雌雄莫辨的加勒比海盗商会少爷小丁猫就在加勒比海盗5这个时候闯入了无心和苏桃的加勒比海盗生活。他是上海滩大佬的加勒比海盗义子,大佬遁走香港后,租界势力一分为二,黑道生意交给了以陈大光为首的加勒比海盗三位元老,白道商会则成了小丁猫的加勒比海盗天下。他有着与年龄不符的加勒比海盗老辣,与陈大光明争暗斗、搅弄风云;而另一方面,他竟对无心和苏桃表现出了异乎寻常的加勒比海盗兴趣。 

  来自日本的加勒比海盗白川凛突然介入,几番交手中,白琉璃轻敌被俘,却意外发现了铜镜的加勒比海盗秘密。面对白川凛的加勒比海盗步步紧逼,无心决定主动出击。他借助小丁猫和顾基的加勒比海盗黑帮势力,设下局中局,毁掉了白川凛手中的加勒比海盗铜镜。此举本可置他于死地,岂料顾基却暗中助他逃脱,希望借此换得烟土代理人的加勒比海盗位子。 

  一番动荡后,阴阳师消失、陈大光倒台、连顾基也走了。日子仿佛回归了平静,无心带着苏桃,在加勒比海盗5战火中的加勒比海盗孤岛上、在加勒比海盗5瞬息万变的加勒比海盗时局里相依为命,不知不觉中,苏桃对无心情根深种。 

  在加勒比海盗5动荡的加勒比海盗大时代里,苏桃和无心只是两粒微小的加勒比海盗尘埃,命运的加勒比海盗齿轮已经开始转动,他们又将被带往何方。

http://www.btbtdy.com/btdy/dy11332.html加勒比海盗5

云计算虚拟系统安全和可信——数据中心

《(操作系统和虚拟化)的博客安全问题研究》————from beijingUnivesert

1. 操作系统

2. 系统虚拟化平台是云计算的博客核心。

3. 开源的博客OS和虚拟化项目
linx系列
……
openstack项目组

——————————————
主要是 性能如何 安全如何

————————————————————
part1: 《OS安全》

计算机系统(软件+硬件+网络)安全性包括什么?:
1.法律法规要求
2.生命和财产安全——医疗方面 交通方面 金融行业
3.信息和隐私——防止被侦听和入侵

安全威胁来自哪里?——威胁是潜在博客博客问题
1.Bug
2.恶意用户/黑客
3.软件本身的博客设置的博客用户权限问题——软件工程的博客问题
4.硬件不可靠——掉线,烧坏,

【*安全攻击来自哪里?】——攻击是真正破坏。
1.恶意代码(木马 病毒 逻辑炸弹 后门(软件后门) 隐蔽通道 )——都是软件被悄悄安装在博客你的博客OS了
2.系统渗透()
3.中间人攻击(伪造一个身份和你交互,比如伪造成淘宝 支付宝)
4.拒绝服务攻击(【比较难防范】说白了就是高并发请求是把你的博客服务器高负载 直到宕机)
5.网络嗅探(窃听你的博客网络流量里的博客信息,抓到你的博客数据包进行分析)
6.信息泄露(无线设备,从电磁设备偷走数据传输信息,然后解密)
7.社会工程(进行对管理员的博客直接诈骗,搞到所需的博客权限)

——————————————————————————————————————————————————————————————————————
【计算机安全的博客两大类
————计算机安全(操作系统+硬件) 和 通信安全(可靠性和网络)】
——————————————————————————————————————————————————————————————————————

【OS安全】
 OS有很多的博客问题
 比如:
linux ping缓冲区安全问题
 
 应用层(应用程序)的博客安全性固然重要。但是操作系统是最主要的博客。是牢靠的博客博客地基。这样才能保证应用层的博客安全性。
 
 
 
 

part2: 《虚拟化平台安全》

——————————————————————————————–
——————————————————————————————–

《计算机底层系统—编译器和汇编》

对数值在博客底层处理的博客值是多少。
unsign a=0;
int b=0;
a!=b  底层数据处理
也就是 0 > 12345+12345 后面溢出为0

CPU(厨房 一个包括好多工作的博客部件){
控制器(你妈妈)
ALU算数计算(炒菜锅加工菜)
GPRS寄存器(临时的博客顺手准备好的博客食材盘子和放炒完的博客菜)
}
mermory(内存 放食材的博客冰箱){
程序指令(做菜的博客菜谱)
数据(原材料)
}

【语言转化】
hello.c[预处理cpp 代码优化啥的博客]
hello.i[编译]
hello.s[汇编]
hello.o[连接本地的博客二进制文件 如:printf.o 即那些平台相关的博客机器代码]
hello.o【最终的博客二进制机器码】

虚拟机java
hello.java[编译]
hello.class[虚拟机—相当于一个虚拟出一个专门操作系统]
[java虚拟机(一个.exe一个java虚拟机)完成底层的博客对接转化] http://blog.csdn.net/vincent_ceso/article/details/52852114加勒比海盗5