>

自定义日期的时分秒,NPOI管理Word文本中上下角标

- 编辑:云顶娱乐yd2221 -

自定义日期的时分秒,NPOI管理Word文本中上下角标

       //获取时间戳 .net framework
            /*
            DateTime dt = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1)); 
            int time = (int)(DateTime.Now - dt).TotalSeconds;
            String Timestamp = time.ToString();
            */
            // .net core 获取时间戳
            DateTime dt = new DateTime(1970, 1, 1,0, 0, 0, DateTimeKind.Utc);
            int time = (int)(DateTime.Now.AddHours(-8) - dt).TotalSeconds;
            String Timestamp = time.ToString();
            //随机正整数,用于防止重放攻击
            Random rd = new Random();
            int rd_i = rd.Next();
            String nonce = Convert.ToString(rd_i);
            //SecretId
            String SecretId = "";
            //参数(用于编码)
            String PostStr = string.Format("Action=DescribeLVBChannelList&Nonce={0}&Region=bj&SecretId={1}&Timestamp={2}", nonce, SecretId, Timestamp);
            //地址
            String url = "https://live.api.qcloud.com/v2/index.php";
            //编码
            UTF8Encoding enc = new UTF8Encoding();
            String qm = "POSTlive.api.qcloud.com/v2/index.php"  + "?" + PostStr;
            byte[] dataToHash = enc.GetBytes(qm);
            /*
            var sha1 = SHA1.Create();
            var result = sha1.ComputeHash(dataToHash);
            */  
            HMACSHA1 hmac = new HMACSHA1()
            {
                Key = enc.GetBytes("")
            };
            var result = hmac.ComputeHash(dataToHash);
            string Signature = Convert.ToBase64String(result);
            //完整参数
            var completeUrl = string.Format("Action=DescribeLVBChannelList&Nonce={0}&Region=bj&SecretId={1}&Signature={2}&Timestamp={3}", nonce, SecretId, Signature, Timestamp);

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.ProtocolVersion = HttpVersion.Version10;
            byte[] data = Encoding.UTF8.GetBytes(completeUrl);
            request.ContentLength = data.Length;
            Stream newStream = request.GetRequestStream();
            newStream.Write(data, 0, data.Length);
            newStream.Close();
            HttpWebResponse response = null;
            int httpStatus = 200;
            string content;
            try
            {
                response = (HttpWebResponse)request.GetResponse();
                httpStatus = (int)response.StatusCode;
                StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
                content = reader.ReadToEnd();
            }
            catch (WebException e)
            {
                response = (HttpWebResponse)e.Response;
                httpStatus = (int)response.StatusCode;
                using (Stream errData = response.GetResponseStream())
                {
                    using (StreamReader reader = new StreamReader(errData))
                    {
                        content = reader.ReadToEnd();
                    }
                }
            }

我们都学过了django,用django写了各样成效,写了bbs项目,写了路飞学城。

读取Word文书档案,并将文件转成html标签,前边发掘,平常常有带上下角标的情节,于是黄金时代并管理了。

1 DateTime beginTime = DateTime.Now.Date;
2 Console.WriteLine(beginTime);
3 DateTime endTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 23, 59, 59);
4 Console.WriteLine(endTime);
5 DateTime customTime = new DateTime(2018,09,03,14,30,20);
6 Console.WriteLine(customTime);

写在前边

全套项目都托管在了 Github 上:
追寻更为方便的版本见:
那大器晚成节内容也许会用到的库文件有 Quick,同样在 Github 上能够找到。
善用 Ctrl + F 查找难题。

 

大家都清楚django是四个web框架,方便大家异常的快支付web程序,http伏乞的动态数据就是由web框架来提供管理的。

着力在于对XWPFRun对象中Subscript属性的拍卖。

图片 1

习题&题解

前方邓超(Deng Chao卡塔尔国也对nginx简单的牵线了,本文将nginx、WSGI、uwsgi、uWSGI、django那多少个事关梳理一下。

 1         /// <summary>
 2         /// 读取Word,并识别文本中的上下角标
 3         /// </summary>
 4         /// <param name="fileName"></param>
 5         /// <returns></returns>
 6         public static string ReadWordTextExWithSubscript(string fileName)
 7         {
 8 
 9             string fileText = string.Empty;
10             StringBuilder sbFileText = new StringBuilder();
11 
12             #region 打开文档
13             XWPFDocument document = null;
14             try
15             {
16                 using (FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read))
17                 {
18                     document = new XWPFDocument(file);
19                 }
20             }
21             catch (Exception e)
22             {
23                 throw e;
24             }
25             #endregion
26             //正文段落
27             foreach (XWPFParagraph paragraph in document.Paragraphs)
28             {
29                 //获取段楼中的句列表
30                 IList<XWPFRun> runsLists = paragraph.Runs;
31 
32                 sbFileText.Append("<p>");
33                 foreach (XWPFRun run in runsLists)
34                 {
35                     switch (run.Subscript)
36                     {
37                         case VerticalAlign.BASELINE:
38                             sbFileText.Append(run.Text);
39                             break;
40                         //上角标
41                         case VerticalAlign.SUPERSCRIPT:
42                             sbFileText.Append("<sup>" + run.Text + "</sup>");
43                             break;
44                         //下角标
45                         case VerticalAlign.SUBSCRIPT:
46                             sbFileText.Append("<sub>" + run.Text + "</sub>");
47                             break;
48                         default:
49                             sbFileText.Append(run.Text);
50                             break;
51                     }
52                     
53                 }
54                 sbFileText.AppendLine("</p>");
55             }
56             fileText = sbFileText.ToString();
57 
58             return fileText;
59         }

2.3.1

wsgi    全称web server gateway interface,wsgi不是服务器,也不是python模块,只是一种协议,描述web server如何和web application通信的规则。
运行在wsgi上的web框架有bottle,flask,django

uwsgi    和wsgi一样是通信协议,是uWSGI服务器的单独协议,用于定义传输信息的类型

uWSGI    是一个web服务器,实现了WSGI协议,uwsgi协议。a

nginx    web服务器,更加安全,更好的处理处理静态资源,缓存功能,负载均衡,因此nginx的强劲性能,配合uWSGI服务器会更加安全,性能有保障。

django 高级的python web框架,用于快速开发,解决web开发的大部分麻烦,程序员可以更专注业务逻辑,无须重新造轮子

Word文档:

题目

根据 Partition() 方法的轨道的格式给出该情势是怎么切分数组 E A S Y Q U E S T I O N 的。

逻辑图

图片 2

web服务器

传统的c/s架构,请求的过程是
客户端 > 服务器 
服务器 > 客户端
服务器就是:1.接收请求 2.处理请求 3.返回响应

web框架层

HTTP的动态数据交给web框架,例如django遵循MTV模式处理请求。
HTTp协议使用url定位资源,urls.py将路由请求交给views视图处理,然后返回一个结果,完成一次请求。
web框架使用者只需要处理业务的逻辑即可。

比如将贰遍通讯转变为“对话”的进程

Nginx:hello wsgi,笔者刚接到一个伸手,你计划下然后让django来处理呢

WSGI:好的nginx,作者立时安装遭遇变量,然后把需要提交django

Django:谢谢WSGI,作者管理完央求登时给你响应结果

WSGI:好的,我在等着

Django:消除啦,麻烦wsgi吧响应结果传递给nginx

WSGI:太棒了,nginx,响应结果请收好,已经依照要求传递给您了

nginx:好滴。作者把响应交给客户。合营快乐

图片 3

解答

图片 4

Django Nginx+uwsgi 安装配置

在前面包车型客车章节中大家选用 python manage.py runserver 来运转服务器。这只适用测验景况中使用。

职业公布的服务,须要三个方可安静而不仅仅的服务器。

输出:

2.3.2

幼功开采遇到布署

yum groupinstall "Development tools"
yum install zlib-devel bzip2-devel pcre-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel

<p>测试<sup>上</sup><sub>下</sub>ok。</p>
<p>CO<sub>2</sub></p>
<p>面积约6000km<sup>2</sup></p>

题目

依据本节中急忙排序所示轨迹的格式给出快捷排序是何等将数组 E A S Y Q U E S T I O N 排序的(出于练习的指标,能够忽视最早打乱数组的片段卡塔尔。

超前设置好python3条件

https://www.cnblogs.com/pyyu/p/7402145.html

Html预览:

解答

图片 5

virtualenv

请确保你的虚拟环境正常工作
https://www.cnblogs.com/pyyu/p/9015317.html

图片 6

2.3.3

安装django1.11

pip3 install django==1.11
#创建django项目mysite
django-admin startproject mysite
#创建app01
python3 manage.py startapp app01

自定义日期的时分秒,NPOI管理Word文本中上下角标。mysite/settings.py

#settings.py设置
ALLOWED_HOSTS = ['*']
install app01

mysite/urls.py

from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^hello_django/', views.hello),
]

app01/views.py

from django.shortcuts import render,HttpResponse

# Create your views here.
def hello(request):
    print('request is :',request)
    return HttpResponse('django is ok ')

 

题目

对于长度为 N 的数组,在 Quick.sort() 实行时,其最大体素最多会被换到多少次?

安装uWSGI

进入虚拟环境venv,安装uwsgi
(venv) [root@slave 192.168.11.64 /opt]$pip3 install uwsgi
检查uwsgi版本
(venv) [root@slave 192.168.11.64 /opt]$uwsgi --version
2.0.17.1
#检查uwsgi python版本
uwsgi --python-version

运维简单的uWSGI

#启动一个python
uwsgi --http :8000 --wsgi-file test.py
  • http :8000: 使用http协议,端口8000
  • wsgi-file test.py: 加载钦命的文件,test.py
#test.py
def application(env, start_response):
    start_response('200 OK', [('Content-Type','text/html')])
    return [b"Hello World"] # python3

uWsgi热加载python程序

在启动命令后面加上参数
uwsgi --http :8088 --module mysite.wsgi --py-autoreload=1 
#发布命令
command= /home/venv/bin/uwsgi --uwsgi 0.0.0.0:8000 --chdir /opt/mysite --home=/home/venv --module mysite.wsgi

#此时修改django代码,uWSGI会自动加载django程序,页面生效

运行django程序

#mysite/wsgi.py  确保找到这个文件
uwsgi --http :8000 --module mysite.wsgi
  • module mysite.wsgi: 加载钦命的wsgi模块

uwsgi配置文件

图片 7图片 8

uwsgi支持ini、xml等多种配置方式,本文以 ini 为例, 在/etc/目录下新建uwsgi_nginx.ini,添加如下配置:

# mysite_uwsgi.ini file
[uwsgi]

# Django-related settings
# the base directory (full path)
chdir           = /opt/mysite
# Django's wsgi file
module          = mysite.wsgi
# the virtualenv (full path)
home            = /opt/venv
# process-related settings
# master
master          = true
# maximum number of worker processes
processes       = 1
# the socket (use the full path to be safe
socket          = 0.0.0.0:8000
# ... with appropriate permissions - may be needed
# chmod-socket    = 664
# clear environment on exit
vacuum          = true

uwsgi.ini

解答

N / 2
在高效排序中,二个成分要被换来,有以下二种情景
1.该因素是枢轴,在切分的结尾一步被换到
2.该因素位于枢轴错误的两旁,必要被换来到另大器晚成侧去
在乎,以上三种情景在贰次切分中只会产出一次

率先来看率先种状态,假设多个元素变为了枢轴
那么在后来的切分中该因素会被拔除,不设有继续的沟通。
据此大家的对象应该是:
最大的因素总是出以往错误的两旁,同不经常间切分的次数尽恐怕多。

接下去大家来构思什么组织那样的数组
出于大家本着的是最大的成分,由此「错误的边际」即是枢轴的左侧。
为了使切分的次数尽可能多,大家须求保持最大值移动的间隔尽量短。
但借使每一回只移动一个人的话,下二回切分时最大值就能成为枢轴
举个例子 4 10 3 5 6,枢轴为 4,调换后数组变为:
4 3 10 5 6
随后 4 和 3 交换
3 4 10 5 6
下一回切分时 10 会变成枢轴,不再参与后续的切分。
进而我们要求让最大值每一回运动四个因素。

构思下边包车型大巴数组:
2 10 4 1 6 3 8 5 7 9
率先次切分的时候,枢轴为 2,10 和 1 进行沟通
数组变为:
2 1 4 10 6 3 8 5 7 9
接着枢轴沟通,数组变为:
1 2 4 10 6 3 8 5 7 9
第1回切分,枢轴为 4,10 和 3 实行置换。
1 2 4 3 6 10 8 5 7 9
进而枢轴交换 数组变为:
1 2 3 4 6 10 8 5 7 9
其一回切分,枢轴为 6,10 和 5 沟通
1 2 3 4 6 5 8 10 7 9
接着枢轴沟通,数组变为:
1 2 3 4 5 6 8 10 7 9
第肆遍切分,枢轴为 8,10 和 7 交换
1 2 3 4 5 6 8 7 10 9
枢轴交流,数组变为
1 2 3 4 5 6 7 8 10 9
终极壹遍切分,枢轴为 10,直接沟通
1 2 3 4 5 6 7 8 9 10

咱俩得以计算出要结构那样的数组的沙盘
a2 max a3 a1
其中 a1 < a2 < a3 < max
max 每轮切分移动两格,总共切分 N/ 2 次。

钦定布署文件运行命令

uwsgi --ini  /etc/uwsgi_nginx.ini
另请参阅

Number of largest element exchanges for quicksort-Stack Overflow

配置nginx结合uWSGI

配置nginx.conf

worker_processes  1;
error_log  logs/error.log;
pid        logs/nginx.pid;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  logs/access.log  main;
    sendfile        on;
    keepalive_timeout  65;
   #nginx反向代理uwsgi
    server {
        listen       80;
        server_name  192.168.11.64;
        location / {
         include  /opt/nginx1-12/conf/uwsgi_params;
         uwsgi_pass 0.0.0.0:8000;
            root   html;
            index  index.html index.htm;
        }
      #nginx处理静态页面资源
      location /static{
        alias /opt/nginx1-12/static;   
         }
     #nginx处理媒体资源
     location /media{
        alias /opt/nginx1-12/media;   

         }
        error_page   500 502 503 504  /50x.html;

        location = /50x.html {
            root   html;
        }
    }
}

布置完运转nginx

2.3.4

supervisor

supervisor 是基于 python 的职责处理工科具,用来机关运维种种后台职分,当然你也能一直利用 nohup 命令使职分自动后台运行,但只要要重启职分,每一遍都和谐手动 kill 掉任务进度,那样很麻烦,况兼风姿洒脱旦程序错诱招致进度退出的话,系统也无从自行重载职务。

此地邓超(Deng Chao卡塔 尔(阿拉伯语:قطر‎要配置基于virtualenv的supervisor

出于supervisor在python3下非常的小概选择,由此只可以用python2去下载!!!!!!

#注意此时已经退出虚拟环境了!!!!!
yum install python-setuptools
easy_install supervisor

透过命令生成supervisor的配支文件

echo_supervisord_conf > /etc/supervisord.conf

下一场再/etc/supervisord.conf末尾增添上如下代码!!!!!!

[program:my]
#command=/opt/venv/bin/uwsgi --ini  /etc/uwsgi_nginx.ini  #这里是结合virtualenv的命令 和supervisor的精髓!!!!
command= /home/venv/bin/uwsgi --uwsgi 0.0.0.0:8000 --chdir /opt/mysite --home=/home/venv --module mysite.wsgi
#--home指的是虚拟环境目录  --module找到 mysite/wsgi.py

directory=/opt/mysite
startsecs=0
stopwaitsecs=0
autostart=true
autorestart=true

最后运维supervisor,实现uWSGI运维django,nginx反向代理

supervisord -c /etc/supervisord.conf #启动supervisor
supervisorctl -c /etxc/supervisord.conf restart my  #重启my项目
supervisorctl -c /etc/supervisord.conf [start|stop|restart] [program-name|all]

 重新加载supervisor

一、添加好配置文件后

二、更新新的配置到supervisord    

supervisorctl update
三、重新启动配置中的所有程序

supervisorctl reload
四、启动某个进程(program_name=你配置中写的程序名称)

supervisorctl start program_name
五、查看正在守候的进程

supervisorctl
六、停止某一进程 (program_name=你配置中写的程序名称)

pervisorctl stop program_name
七、重启某一进程 (program_name=你配置中写的程序名称)

supervisorctl restart program_name
八、停止全部进程

supervisorctl stop all
注意:显示用stop停止掉的进程,用reload或者update都不会自动重启。
题目

生机勃勃经跳过起来打乱数组的操作,
提交七个带有 10 个要素的数组,
使得 Quick.sort() 所需的可比次数高达最坏情状。

  django的静态文件与nginx配置

mysite/settings.py

STATIC_ROOT='/opt/nginx1-12/static'
STATIC_URL = '/static/'
STATICFILES_DIRS=[
    os.path.join(BASE_DIR,"static"),
]

上述的参数STATIC_ROOT用在哪?

由此python3 manage.py collectstatic 搜罗全部你使用的静态文件保留到STATIC_ROOT!

STATIC_ROOT 文件夹 是用来将所有STATICFILES_DIRS中所有文件夹中的文件,以及各app中static中的文件都复制过来
# 把这些文件放到一起是为了用nginx等部署的时候更方便

 

 

参考文书档案:

 uwsgi热加载:

解答

老是只让枢轴变为已排序,这就是最坏意况。
这种时候枢轴是当前子数组的最大值 / 最小值。
由于在大家的完毕中三回九转取子数组的率先个要素作为枢轴。
就此二个已排序的数组能够达到规定的标准最坏情状,比较次数高达 O(n^ 2)。
只要换作取最终三个因素,最坏景况会成为逆序数组。

大家的完结中只要遇到与枢轴相等的要素也会终止循环,
就此黄金年代旦数组中有重复的要素会减少比较次数。

例如:

1 2 3 4 5 6 7 8 9 10
2 3 4 5 6 7 8 9 10 11
3 4 5 6 7 8 9 10 11 12
4 5 6 7 8 9 10 11 12 13
5 6 7 8 9 10 11 12 13 14
6 7 8 9 10 11 12 13 14 15
另请参阅

Analysis of Quicksort-khanacademy
Worst case for QuickSort - When can it occur?-Stack Overflow

2.3.5

题目

付出风流倜傥段代码将已知独有三种主键值的数组排序。

解答

官方达成:

算法 gif 动图
图片 9

代码
namespace Quick
{
    /// <summary>
    /// 用于将只有两种元素的数组排序。
    /// </summary>
    public class Sort2Distinct : BaseSort
    {
        /// <summary>
        /// 默认构造函数。
        /// </summary>
        public Sort2Distinct() { }

        /// <summary>
        /// 对数组 a 进行排序。
        /// </summary>
        /// <typeparam name="T">数组 a 的元素类型。</typeparam>
        /// <param name="a"></param>
        public override void Sort<T>(T[] a)
        {
            int lt = 0, gt = a.Length - 1;
            int i = 0;
            while (i <= gt)
            {
                int cmp = a[i].CompareTo(a[lt]);
                if (cmp < 0)
                    Exch(a, lt++, i++);
                else if (cmp > 0)
                    Exch(a, i, gt--);
                else
                    i++;
            }
        }
    }
}
另请参阅

Quick 库

2.3.6

题目

编排生龙活虎段代码来总括 $ C_N $ 的正确值,
在 $ N=100、1000 $ 和 $10 000 $ 的气象下相比较准确值和预计值 $ 2NlnN $ 的异样。

解答

运转结果如下:
图片 10

代码

新建三个 QuickSortAnalyze 类,在 QuickSort 的底蕴上增多贰个 CompareCount 属性,用于记录相比较次数。重写 Less 方法,每调用三次就让 CompareCount 扩展1 。

using System;
using System.Diagnostics;

namespace Quick
{
    /// <summary>
    /// 自动记录比较次数以及子数组数量的快速排序类。
    /// </summary>
    public class QuickSortAnalyze : BaseSort
    {
        /// <summary>
        /// 比较次数。
        /// </summary>
        public int CompareCount { get; set; }

        /// <summary>
        /// 是否启用打乱。
        /// </summary>
        public bool NeedShuffle { get; set; }

        /// <summary>
        /// 是否显示轨迹。
        /// </summary>
        public bool NeedPath { get; set; }

        /// <summary>
        /// 大小为 0 的子数组数量。
        /// </summary>
        public int Array0Num { get; set; }

        /// <summary>
        /// 大小为 1 的子数组数量。
        /// </summary>
        public int Array1Num { get; set; }

        /// <summary>
        /// 大小为 2 的子数组数量。
        /// </summary>
        public int Array2Num { get; set; }

        /// <summary>
        /// 默认构造函数。
        /// </summary>
        public QuickSortAnalyze()
        {
            this.CompareCount = 0;
            this.NeedShuffle = true;
            this.NeedPath = false;
            this.Array0Num = 0;
            this.Array1Num = 0;
            this.Array2Num = 0;
        }

        /// <summary>
        /// 用快速排序对数组 a 进行升序排序。
        /// </summary>
        /// <typeparam name="T">需要排序的类型。</typeparam>
        /// <param name="a">需要排序的数组。</param>
        public override void Sort<T>(T[] a)
        {
            this.Array0Num = 0;
            this.Array1Num = 0;
            this.Array2Num = 0;
            this.CompareCount = 0;
            if (this.NeedShuffle)
                Shuffle(a);
            if (this.NeedPath)
            {
                for (int i = 0; i < a.Length; i++)
                {
                    Console.Write("  ");
                }
                Console.WriteLine("tlotjthi");
            }
            Sort(a, 0, a.Length - 1);
            Debug.Assert(IsSorted(a));
        }

        /// <summary>
        /// 用快速排序对数组 a 的 lo ~ hi 范围排序。
        /// </summary>
        /// <typeparam name="T">需要排序的数组类型。</typeparam>
        /// <param name="a">需要排序的数组。</param>
        /// <param name="lo">排序范围的起始下标。</param>
        /// <param name="hi">排序范围的结束下标。</param>
        private void Sort<T>(T[] a, int lo, int hi) where T : IComparable<T>
        {
            if (hi - lo == 1)
                this.Array2Num++;
            else if (hi == lo)
                this.Array1Num++;
            else if (hi < lo)
                this.Array0Num++;

            if (hi <= lo)                   // 别越界
                return;
            int j = Partition(a, lo, hi);
            if (this.NeedPath)
            {
                for (int i = 0; i < a.Length; i++)
                {
                    Console.Write(a[i] + " ");
                }
                Console.WriteLine("t" + lo + "t" + j + "t" + hi);
            }
            Sort(a, lo, j - 1);
            Sort(a, j + 1, hi);
        }

        /// <summary>
        /// 对数组进行切分,返回枢轴位置。
        /// </summary>
        /// <typeparam name="T">需要切分的数组类型。</typeparam>
        /// <param name="a">需要切分的数组。</param>
        /// <param name="lo">切分的起始点。</param>
        /// <param name="hi">切分的末尾点。</param>
        /// <returns>枢轴下标。</returns>
        private int Partition<T>(T[] a, int lo, int hi) where T : IComparable<T>
        {
            int i = lo, j = hi + 1;
            T v = a[lo];
            while (true)
            {
                while (Less(a[++i], v))
                    if (i == hi)
                        break;
                while (Less(v, a[--j]))
                    if (j == lo)
                        break;
                if (i >= j)
                    break;
                Exch(a, i, j);
            }
            Exch(a, lo, j);
            return j;
        }

        /// <summary>
        /// 打乱数组。
        /// </summary>
        /// <typeparam name="T">需要打乱的数组类型。</typeparam>
        /// <param name="a">需要打乱的数组。</param>
        private void Shuffle<T>(T[] a)
        {
            Random random = new Random();
            for (int i = 0; i < a.Length; i++)
            {
                int r = i + random.Next(a.Length - i);
                T temp = a[i];
                a[i] = a[r];
                a[r] = temp;
            }
        }

        /// <summary>
        /// 比较第一个元素是否小于第二个元素。
        /// </summary>
        /// <typeparam name="T">要比较的元素类型。</typeparam>
        /// <param name="a">第一个元素。</param>
        /// <param name="b">第二个元素。</param>
        /// <returns></returns>
        new protected bool Less<T>(T a, T b) where T : IComparable<T>
        {
            this.CompareCount++;
            return a.CompareTo(b) < 0;
        }
    }
}

主方法

using System;
using Quick;

namespace _2._3._6
{
    /*
     * 2.3.6
     * 
     * 编写一段代码来计算 C_N 的准确值,
     * 在 N=100、1000 和 10 000 的情况下比较准确值和估计值 2NlnN 的差距。
     * 
     */
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Nt准确值t估计值t比值");
            QuickSortAnalyze sort = new QuickSortAnalyze();
            int N = 100;
            int trialTime = 500;
            for (int i = 0; i < 3; i++)
            {
                int sumOfCompare = 0;
                int[] a = new int[N];
                for (int j = 0; j < trialTime; j++)
                {
                    for (int k = 0; k < N; k++)
                    {
                        a[k] = k;
                    }
                    SortCompare.Shuffle(a);
                    sort.Sort(a);
                    sumOfCompare += sort.CompareCount;
                }
                int averageCompare = sumOfCompare / trialTime;
                double estimatedCompare = 2 * N * Math.Log(N);
                Console.WriteLine(N + "t" + averageCompare + "t" + (int)estimatedCompare + "t" + averageCompare / estimatedCompare);
                N *= 10;
            }
        }
    }
}
另请参阅

Quick 库

2.3.7

题目

在选取高效排序将 N 个不另行的成分排序时,
测算大小为 0、1 和 2 的子数组的数目。倘使你喜欢数学,请推导;
万意气风发您不希罕,请做一些试验并提议嫌疑。

本文由云顶娱乐yd2221发布,转载请注明来源:自定义日期的时分秒,NPOI管理Word文本中上下角标