>
快捷搜索:

包涵惯性的ScrollViewer

- 编辑:皇家国际app -

包涵惯性的ScrollViewer

代码
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++;
            }
        }
    }
}

出口参数(out)

除此而外ref外,还能内定out关键字,内定所给的参数时一个出口参数,out参数和ref参数都在函数定义和函数调用中作为参数的修饰符。事实上,它的进行情势与ref参数差十分少完全黄金年代致,因为在函数试行落成后,该参数的值将再次来到给函数调用中运用的变量。可是,二者存在部分最首要不同:

1.把未赋值的变量用作ref参数是私行的,可是未赋值的变量能够用作out参数

2.在函数中接纳out参数时,必得将其视作还未赋值。相当于说调用代码能够把已赋值的变量用作out参数,但在函数施行时该变量的值会错失。

如以往有一个回去数组中最大值得Max()函数,获取数组中最大值得成分索引(这里若是借使有多少个最大值,只回去第三个最大值索引),增添out参数:

  static int Max(int[] intArray,out int maxIndex)
        {
            int maxVal = intArray[0];
            maxIndex = 0;
            for (int i = 1; i < intArray.Length; i++)
            {
                if(intArray[i]>maxVal)
                {
                    maxVal = intArray[i];
                    maxIndex = i;
                }
            }
            return maxVal;
        }

调用上面包车型大巴代码:

 int[] myArray = { 1, 8, 3, 6, 2, 5, 9, 3, 0, 2 };
 int maxIndex;
 Console.WriteLine("the maxium value is {0}", Max(myArray, out maxIndex));
 Console.WriteLine("the index of the maxium value is{0}", maxIndex + 1);

操纵台出口的结果如下所示:

图片 1

 

  本文所研商的控件源码已经在github开源:

 

补助,在vs二零一一品种文件夹的属性窗口更改如下内容:

题目

请证实 Quick.sort(卡塔尔(英语:State of Qatar)在拍卖独有三种主键值时的一举一动,以至在拍卖独有二种主键值的数组时的行为。

世家兴许在编码中或多或少的应用过out的ref,可是是不是注意过她两的详实用法以至界别?

  好了,接下去正是怎么在滚轮响应措施中落实惯性运动了,也正是生机勃勃种减速运动。想到那儿,通晓动漫的博友十分的快就领悟要用WPF的动漫片来完成了,默许的卡通都是二回线性的,要有惯性功能就得用缓动函数,WPF的缓动函数有过多,而 CubicEase 特别符合用来做惯性,它的陈述图如下:

  C#历史
  1999年主管L这些种类是C#语言的前身,由微软 安德斯 Hejlsberg 和他的团体在 .Net 框架开采时期支付的
  贰零零贰年正规发表

Successfully migrated section "system.web/httpHandlers"." 

另请参阅

BackgroundWorker 组件 | Microsoft Docs
Quick 库

ref参数

            int num = 5;
            Console.WriteLine("num={0}", num);
            ShowDouble(ref num);
            Console.WriteLine("num={0}", num);

运营调节台结果如下:

图片 2

用作ref的参数的变量有几个限定:

1.函数恐怕会转移引用参数的值,所以必得在函数调用中动用“极度量”变量,所以上面包车型客车代码是不被允许的:

 

            const int num = 5;
            Console.WriteLine("num={0}", num);
            ShowDouble(ref num);
            Console.WriteLine("num={0}", num);

2.必需使用初叶化过的变量。C#不容许假定ref参数在函数调用时伊始化,上边包车型大巴代码也是不被允许的:

            int num;
            Console.WriteLine("num={0}", num);
            ShowDouble(ref num);
            Console.WriteLine("num={0}", num);

  纵然效果很简短,不过网络的局部素材涉及的代码量特别惊人,何况作用亦不是很理想,滚动的时候未有二个顺滑感。我这里提供的源码朝气蓬勃共120多行,就能够促成上海体育地方的效力。

  C#含义
  C#是C语言和C++语言根基上创建的一门语言,
  C语言是面向进度语言
  C++是半面向进度半面向对象的言语
  C#面向对象的言语,有部分生死攸关的职能:
    布尔条件(Boolean Conditions)
    自动垃圾回笼(Automatic Garbage Collection)
    标准库(Standard Library)
    组件版本(Assembly Versioning)
    属性(Properties)和事件(Events)
    委托(Delegates)和事件管理(伊芙nts Management)
    易于使用的泛型(Generics)
    索引器(Indexers)
    条件编写翻译(Conditional Compilation)
    简单的八线程(Multithreading)
    LINQ 和 Lambda 表达式
    集成 Windows

Successfully migrated section "system.web/httpModules".

2.3.5

本文想介绍下详细介绍下out参数,ref参数以至经常值参数。

1 protected override void OnMouseWheel(MouseWheelEventArgs e)
2 {
3      e.Handled = true;
4 }

    Visual Studio  (VS)
    Visual C#  Express (VCE)
    Visual Web Developer
  后边四个是无偿应用的,可从微软官方网址下载。那些工具可用以编写各样C# 程序。

图片 3

题目

马虎小数组。
用试验相比之下管理小数组的艺术和练习 2.3.25 的管理办法的功效:
在快速排序中平素忽视小数组,仅在高速排序甘休后运转二回插入排序。
瞩目:能够透过那个试验推测出Computer的缓存大小,因为当数组大小超过缓存时这种方法的性质可能会收缩。

值参数

在行使参数时,把叁个值传递给函数使用的一个变量。在函数中对此变量的别样退换都不影响函数调用中钦定的参数。如下面包车型客车函数,是使函数是使传递过来的参数值加倍,并展现出来:

 static void ShowDouble(int num)
        {
            num = num * 2;
            Console.WriteLine("num*2={0}", num);
        }

参数num在函数中被加倍,借使按以下格局调用它:

            int num = 5;
            Console.WriteLine("num={0}", num);
            ShowDouble(num);
            Console.WriteLine("num={0}", num);

出口到调节台的文本如下所示:

图片 4

把num作为参数,调用ShowDouble(卡塔尔并不影响Mian(卡塔尔(英语:State of Qatar)中num的值,固然把num值加倍之后再赋值给num,在函数调用完事后num的值依然不会变。

那也没怎么难题。

不过假诺大家想改正num的值吗?我们会想到利用为num重返新值的函数:

 static int DoubleNum(int num)
        {
            num = num * 2;
            return num;
        }

下一场调用:

            int num = 5;
            Console.WriteLine("num={0}", num);
            num = DoubleNum(num);
            Console.WriteLine("num={0}", num);

这段代码不是很直观,且无法改正当作参数的几个变量值(因为函数唯有一个再次来到值)。当时大家得以想到引用参数,即函数管理的变量和函数调用的变量相近,而不仅是值相仿的变量。因而对那个变量的任何更换都会潜移暗化用作参数的变量值。为此,大家使用ref关键词钦赐参数。

  图中,横轴表示时间,纵轴代表运动间距。很明朗,中间的 EaseOut 格局便是我们想要的。到了这里思路就清楚了,大家能够定义七个性情 CurrentVerticalOffset ,我们会在它上边达成动画,在它的值回调函数中调用 ScrollViewer.ScrollToVerticalOffset 来更新ScrollViewer的轮转地方。当然大家还亟需二个私人商品房字段 _totalVerticalOffset ,这些是用来寄放在ScrollViewer滚动指标地方的,滚轮向下滚动贰个单位我们就给它减去一回 e.Delta ,这里的e是滚轮响应措施传进来的参数,每一趟给它赋值之后,就足以在 CurrentVerticalOffset 上进行动漫了: BeginAnimation(CurrentVerticalOffsetProperty, animation卡塔尔(قطر‎ ,须要极度注意的是,当贰个依赖属性用了动漫片退换后,再对其赋值则不会生效,原因是在三个动漫片达到活动期的极点后,时间线暗许会保持其速度,直到其父级的活动期和保持期甘休截止。假设想在动漫截止后还是可以手动改过信赖属性的值,则要求把 FillBehavior 设置为Stop。不过尔尔又会现身八个标题,风流倜傥旦动漫停止,那个凭借属性又会卷土重来初阶值,所以还要给这一个动漫订阅一个 Completed 事件,在事变响应措施中为 CurrentVerticalOffset 给定目的值,也便是 _totalVerticalOffset 。

  Visual C# Express 和 Visual Web Developer Express 版本是 Visual Studio 的定排版本,且具备同样的外观和感观。它们保留 Visual Studio 的大部意义。

解决的法子:

2.3.3

二、原理

  C#Computer语言

检查测验到在合龙的托管管道情势下不适用的 ASP.NET 设置。

2.3.23

  本质上我们借使接管ScrollViewer的滚动逻辑,而且把这一个逻辑替换成带有惯性的就可以,那么哪些去接管呢?这里的最主即使先屏蔽ScrollViewer的鼠标滚轮事件:

3、编辑器
  微软(Microsoft)提供了下列用于 C# 编制程序的开采工具:

先是,找到地方appcmd.xml的那个文件,然后实行上边包车型地铁操作:

另请参阅

Quick 库
Generics 库

 

2、VS集成开荒条件
  集成开垦条件是大家用来编制程序的工具,他得以补助大家,将用C#尖端语言编写的次序,神速编写翻译成Computer识其他言语
  VS是微软的visual studio,称为VS,又称.net

图片 5

代码
using System;
using System.Diagnostics;
using Quick;

namespace _2._3._28
{
    /// <summary>
    /// 快速排序类。
    /// </summary>
    public class QuickSortInsertion : BaseSort
    {
        /// <summary>
        /// 切换到插入排序的阈值。
        /// </summary>
        public int M { get; set; }

        /// <summary>
        /// 上一次排序的最大递归深度。
        /// </summary>
        public int Depth { get; private set; }

        /// <summary>
        /// 默认构造函数。
        /// </summary>
        public QuickSortInsertion()
        {
            this.M = 10;
        }

        /// <summary>
        /// 用快速排序对数组 a 进行升序排序。
        /// </summary>
        /// <typeparam name="T">需要排序的类型。</typeparam>
        /// <param name="a">需要排序的数组。</param>
        /// <returns>递归深度。</returns>
        public override void Sort<T>(T[] a)
        {
            Shuffle(a);
            this.Depth = Sort(a, 0, a.Length - 1, 0);
            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>
        protected int Sort<T>(T[] a, int lo, int hi, int depth) where T: IComparable<T>
        {
            if (hi <= lo)                   // 别越界
                return depth;
            if (hi - lo <= this.M)
            {
                // 调用插入排序
                for (int i = lo; i <= hi; i++)
                    for (int k = i; k > lo && Less(a[k], a[k - 1]); k--)
                        Exch(a, k, k - 1);
                return depth;
            }
            int j = Partition(a, lo, hi);
            int left = Sort(a, lo, j - 1, depth + 1);
            int right = Sort(a, j + 1, hi, depth + 1);
            return Less(left, right) ? right : left;
        }

        /// <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;
            }
        }
    }
}

测量试验用例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _2._3._28
{
    /*
     * 2.3.28
     * 
     * 递归深度。
     * 用经验性的研究估计切换阈值为 M 的快速排序
     * 在将大小为 N 的不重复数组排序时的平均递归深度,
     * 其中 M=10、20 和 50,N=10^3、10^4、10^5 和 10^6。
     * 
     */
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("MtNtDepth");
            Trial(10);
            Trial(20);
            Trial(50);
        }

        /// <summary>
        /// 进行一次测试。
        /// </summary>
        /// <param name="m">要使用的阈值</param>
        static void Trial(int m)
        {
            QuickSortInsertion sort = new QuickSortInsertion();
            int trialTime = 5;

            // 由于排序前有 Shuffle,因此直接输入有序数组。
            // M=10
            sort.M = m;
            int totalDepth = 0;
            for (int N = 1000; N < 10000000; N *= 10)
            {
                for (int i = 0; i < trialTime; i++)
                {
                    int[] a = new int[N];
                    for (int j = 0; j < N; j++)
                    {
                        a[j] = j;
                    }
                    sort.Sort(a);
                    totalDepth += sort.Depth;
                }
                Console.WriteLine(sort.M + "t" + N + "t" + totalDepth / trialTime);
            }
        }
    }
}

图片 6

1、C#言语简要介绍

 

题目

抽样排序。(W.Frazer,A.McKellar)
落到实处八个快捷排序,取样大小为 2^k-1。
先是将取样获得的因素排序,然后在递归函数中使用样本的中位数切分。
分为两某个的别的样本成分无需另行排序并得以分别使用于原数组的七个子数组。
这种算法称为取样排序。

图片 7

 

 

2.3.6

 

  也能够采取基本的公文编辑器(比如 Notepad)编写 C# 源代码文件,并使用命令行编写翻译器(.NET 框架的一片段)编写翻译代码为组件。

 

题目

递归深度。
用经历性的研商测度切换阈值为 M 的全速排序在将大小为 N 的不重复数组排序时的平均递归深度,
其中 M=10、20 和 50,N=10^3、10^4、10^5 和 10^6。

三、源码

 

(1)运转 cmd,进命令行形式,cd到您IIS Express的目录,运转appcmd migrate config "Default Web Site/"。

2.3.10

  最终还大概有七个冲突难题,当手动拖动滑块也许当用上下文菜单改造滚动条地方时是不能够用动漫的,因为那个时候未有触发 OnMouseWheel ,没涉及,那多亏我们想要的,可是如果重新触发 OnMouseWheel 就不平常了,因为手动触发滚动的时候大家从不给 CurrentVerticalOffset 和 _totalVerticalOffset 赋值( CurrentVerticalOffset 和 _totalVerticalOffset 只在 OnMouseWheel 中赋值),所以在用动漫试行滚动操作前要先判别一下是不是需求先更新一下它们俩,怎么样剖断?大家得以用一个私有字段 _isRunning 来保卫安全状态,每当动画初阶就给它赋值true,甘休则赋值false。那样一来,当 _isRunning = false 时,表达在调用 OnMouseWheel 前,动漫已经结束,客户也许已经手动改正了滚动条地点(也许有可能没有,但那并不影响),所以将要给前边俩小伙子更新一下值了。

  是一门高等计算机语言
  他的支出情势更临近人类和社会的思维格局,有帮助增高支付效能

解决办法是到IIS express的目录下找到appcmd.xml,把<verb name="migrate" classId="DefaultConfigObject"  />那句的解说去掉,

2.3.17

 

1、错误如下:

代码

五取样快排

using System;
using System.Diagnostics;
using Quick;

namespace _2._3._19
{
    /// <summary>
    /// 五取样快速排序
    /// </summary>
    public class QuickSortMedian5 : BaseSort
    {
        /// <summary>
        /// 默认构造函数。
        /// </summary>
        public QuickSortMedian5() {}

        /// <summary>
        /// 用快速排序对数组 a 进行升序排序。
        /// </summary>
        /// <typeparam name="T">需要排序的类型。</typeparam>
        /// <param name="a">需要排序的数组。</param>
        public override void Sort<T>(T[] a)
        {
            Shuffle(a);
            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)                   // 别越界
                return;

            // 少于五个元素的数组直接进行插入排序
            if (hi - lo + 1 < 5)
            {
                int n = hi - lo + 1;
                for (int i = lo; i - lo < n; i++)
                {
                    for (int k = i; k > 0 && Less(a[k], a[k - 1]); --k)
                    {
                        Exch(a, k, k - 1);
                    }
                }

                return;
            }

            int j = Partition(a, lo, 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;

            // 假设为 a b c d e 五个数字
            // 首先对 b c 排序
            if (Less(a[lo + 2], a[lo + 1]))
                Exch(a, lo + 2, lo + 1);
            // 然后再排序 d e
            if (Less(a[lo + 4], a[lo + 3]))
                Exch(a, lo + 4, lo + 3);

            // 这时满足 b < c, d < e
            // 比较 b d,把较小的一组放到 b c 的位置上去
            if (Less(a[lo + 3], a[lo + 1]))
            {
                Exch(a, lo + 1, lo + 3);
                Exch(a, lo + 2, lo + 4);
            }

            // 这时满足 b < c, b < d < e,即 b 是 b c d e 中的最小值
            // 交换 a 和 b
            Exch(a, lo, lo + 1);

            // 重新排序 b c
            if (Less(a[lo + 2], a[lo + 1]))
                Exch(a, lo + 2, lo + 1);

            // 这时再次满足 b < c, d < e
            // 比较 b d,把最小的一组放到 b c 的位置上去
            if (Less(a[lo + 3], a[lo + 1]))
            {
                Exch(a, lo + 1, lo + 3);
                Exch(a, lo + 2, lo + 4);
            }

            // 这时 a 和 b 为五个数中的最小值和次小值(顺序不固定,a 也可以是次小值)
            // 最后比较 c 和 d,较小的那一个即为中位数(即第三小的数)
            if (Less(a[lo + 3], a[lo + 2]))
                Exch(a, lo + 3, lo + 2);

            // 此时 c 即为中位数
            Exch(a, lo, lo + 2);

            // d e 放到数组末尾充当哨兵
            Exch(a, lo + 3, hi);
            Exch(a, lo + 4, hi - 1);

            // 调整指针位置,前两位和后两位都已经在合适位置了
            j -= 2;
            i += 2;

            T v = a[lo];
            while (true)
            {
                while (Less(a[++i], v)) ;
                while (Less(v, a[--j])) ;
                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;
            }
        }
    }
}

三取样快排

using System;
using System.Diagnostics;
using Quick;

namespace _2._3._19
{
    /// <summary>
    /// 三取样快速排序
    /// </summary>
    public class QuickSortMedian3 : BaseSort
    {
        /// <summary>
        /// 默认构造函数。
        /// </summary>
        public QuickSortMedian3() {}

        /// <summary>
        /// 用快速排序对数组 a 进行升序排序。
        /// </summary>
        /// <typeparam name="T">需要排序的类型。</typeparam>
        /// <param name="a">需要排序的数组。</param>
        public override void Sort<T>(T[] a)
        {
            Shuffle(a);
            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)                   // 别越界
                return;

            // 少于五个元素的数组直接进行插入排序
            if (hi - lo + 1 < 5)
            {
                int n = hi - lo + 1;
                for (int i = lo; i - lo < n; i++)
                {
                    for (int k = i; k > 0 && Less(a[k], a[k - 1]); --k)
                    {
                        Exch(a, k, k - 1);
                    }
                }

                return;
            }

            int j = Partition(a, lo, 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;

            if (Less(a[lo + 1], a[lo]))
                Exch(a, lo + 1, lo);
            if (Less(a[lo + 2], a[lo]))
                Exch(a, lo + 2, lo);
            if (Less(a[lo + 2], a[lo + 1]))
                Exch(a, lo + 1, lo + 2);

            Exch(a, lo, lo + 1);        // 中位数放最左侧
            Exch(a, hi, lo + 2);        // 较大的值放最右侧作为哨兵

            T v = a[lo];
            while (true)
            {
                while (Less(a[++i], v)) ;
                while (Less(v, a[--j])) ;
                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;
            }
        }
    }
}

测量试验用例

using System;
using Quick;

namespace _2._3._19
{
    /*
     * 2.3.19
     * 
     * 五取样切分。
     * 实现一种基于随机抽取子数组中 5 个元素并取中位数进行切分的快速排序。
     * 将取样元素放在数组的一侧以保证只有中位数元素参与了切分。
     * 运行双倍测试来确定这项改动的效果,
     * 并和标准的快速排序以及三取样的快速排序(请见上一道练习)进行比较。
     * 附加题:找到一种对于任意输入都只需要少于 7 次比较的五取样算法。
     * 
     */
    class Program
    {
        static void Main(string[] args)
        {
            QuickSort quickNormal = new QuickSort();
            QuickSortMedian3 quickMedian3 = new QuickSortMedian3();
            QuickSortMedian5 quickMedian5 = new QuickSortMedian5();
            int arraySize = 200000;                         // 初始数组大小。
            const int trialTimes = 4;                       // 每次实验的重复次数。
            const int trialLevel = 6;                       // 双倍递增的次数。

            Console.WriteLine("ntmedian5tmedian3tnormaltmedian5/normalttmedian5/median3");
            for (int i = 0; i < trialLevel; i++)
            {
                double timeMedian3 = 0;
                double timeMedian5 = 0;
                double timeNormal = 0;
                for (int j = 0; j < trialTimes; j++)
                {
                    int[] a = SortCompare.GetRandomArrayInt(arraySize);
                    int[] b = new int[a.Length];
                    int[] c = new int[a.Length];
                    a.CopyTo(b, 0);
                    a.CopyTo(c, 0);
                    timeNormal += SortCompare.Time(quickNormal, a);
                    timeMedian3 += SortCompare.Time(quickMedian3, b);
                    timeMedian5 += SortCompare.Time(quickMedian5, c);
                }
                timeMedian5 /= trialTimes;
                timeMedian3 /= trialTimes;
                timeNormal /= trialTimes;
                Console.WriteLine(arraySize + "t" + timeMedian5 + "t" + timeMedian3 + "t" + timeNormal + "t" + timeMedian5 / timeNormal + "t" + timeMedian5/timeMedian3);
                arraySize *= 2;
            }
        }
    }
}
1 private static readonly DependencyPropertyKey VerticalOffsetPropertyKey = DependencyProperty.RegisterReadOnly(nameof (VerticalOffset), typeof (double), typeof (ScrollViewer), (PropertyMetadata) new FrameworkPropertyMetadata((object) 0.0));
2 
3 public static readonly DependencyProperty VerticalOffsetProperty = ScrollViewer.VerticalOffsetPropertyKey.DependencyProperty;

潜心:当地就算第一步无法做到手动矫正文件,间接实践里面包车型客车下令也能够,然后继续第二部,应该也得以解决。

题目

根据代码所示轨迹的格式给出消息量最棒的急速排序第二遍是怎么样切分
数组 B A B A B A B A C A D A B R A 的。

生机勃勃、先看看效果

那个时候,重国民党的新生活运动行品种难题早就解决了。

代码
using System;
using Quick;

namespace _2._3._30
{
    /*
     * 2.3.30
     * 
     * 极端情况。
     * 用初始随机化和非初始随机化的快速排序测试练习 2.1.35 和练习 2.1.36 中描述的大型非随机数组。
     * 在将这些大数组排序时,乱序对快速排序的性能有何影响?
     * 
     */
    class Program
    {
        static void Main(string[] args)
        {
            QuickSortInsertion insertionSort = new QuickSortInsertion();
            QuickSortRandomPivot randomSort = new QuickSortRandomPivot();
            int n = 5000000;

            // 高斯分布(正态分布)
            double[] arrayInsertion = SortCompare.GetNormalDistributionArray(n);
            double[] arraySelection = new double[n];

            arrayInsertion.CopyTo(arraySelection, 0);

            Console.WriteLine("Normal Distribution:");
            Console.WriteLine("Insertion: " + SortCompare.Time(insertionSort, arrayInsertion));
            Console.WriteLine("Random Pivot: " + SortCompare.Time(randomSort, arraySelection));
            Console.WriteLine();

            // 泊松分布
            arrayInsertion = SortCompare.GetPossionDistributionArray(n);
            arrayInsertion.CopyTo(arraySelection, 0);

            Console.WriteLine("Poission Distribution:");
            Console.WriteLine("Insertion: " + SortCompare.Time(insertionSort, arrayInsertion));
            Console.WriteLine("Random Pivot: " + SortCompare.Time(randomSort, arraySelection));
            Console.WriteLine();

            // 几何分布
            arrayInsertion = SortCompare.GetGeometricDistributionArray(n, 0.3);
            arrayInsertion.CopyTo(arraySelection, 0);

            Console.WriteLine("Geometric Distribution:");
            Console.WriteLine("Insertion: " + SortCompare.Time(insertionSort, arrayInsertion));
            Console.WriteLine("Random Pivot: " + SortCompare.Time(randomSort, arraySelection));
            Console.WriteLine();

            // 离散分布
            arrayInsertion = SortCompare.GetDiscretDistributionArray(n, new double[] { 0.1, 0.2, 0.3, 0.1, 0.1, 0.1, 0.1 });
            arrayInsertion.CopyTo(arraySelection, 0);

            Console.WriteLine("Discret Distribution:");
            Console.WriteLine("Insertion: " + SortCompare.Time(insertionSort, arrayInsertion));
            Console.WriteLine("Random Pivot: " + SortCompare.Time(randomSort, arraySelection));
            Console.WriteLine();

            // 一半是 0 一半是 1
            int[] arrayNormalInsertion = HalfZeroHalfOne(n);
            int[] arrayRandomPivot = new int[n];
            arrayNormalInsertion.CopyTo(arrayRandomPivot, 0);

            Console.WriteLine("half 0 and half 1");
            Console.WriteLine("Insertion:" + SortCompare.Time(insertionSort, arrayNormalInsertion));
            Console.WriteLine("Random Pivot:" + SortCompare.Time(randomSort, arrayRandomPivot));
            Console.WriteLine();

            // 一半是 0, 1/4 是 1, 1/8 是 2……
            arrayNormalInsertion = HalfAndHalf(n);
            arrayNormalInsertion.CopyTo(arrayRandomPivot, 0);

            Console.WriteLine("half and half and half ...");
            Console.WriteLine("Insertion Sort:" + SortCompare.Time(insertionSort, arrayNormalInsertion));
            Console.WriteLine("Random Pivot:" + SortCompare.Time(randomSort, arrayRandomPivot));
            Console.WriteLine();

            // 一半是 0,一半是随机 int 值
            arrayNormalInsertion = HalfZeroHalfRandom(n);
            arrayNormalInsertion.CopyTo(arrayRandomPivot, 0);

            Console.WriteLine("half 0 half random");
            Console.WriteLine("Insertion Sort:" + SortCompare.Time(insertionSort, arrayNormalInsertion));
            Console.WriteLine("Random Pivot:" + SortCompare.Time(randomSort, arrayRandomPivot));
        }

        /// <summary>
        /// 获取一半是 0 一半是 1 的随机 <see cref="int"/> 数组。
        /// </summary>
        /// <param name="n">数组大小。</param>
        /// <returns>一半是 0 一半是 1 的 <see cref="int"/>数组。</returns>
        static int[] HalfZeroHalfOne(int n)
        {
            int[] result = new int[n];
            Random random = new Random();
            for (int i = 0; i < n; i++)
            {
                if (random.NextDouble() >= 0.5)
                {
                    result[i] = 0;
                }
                else
                {
                    result[i] = 1;
                }
            }
            return result;
        }

        /// <summary>
        /// 生成 1/2 为 0, 1/4 为 1, 1/8 为 2 …… 的 <see cref="int"/> 数组。
        /// </summary>
        /// <param name="n">数组长度。</param>
        /// <returns>1/2 为 0, 1/4 为 1, 1/8 为 2 …… 的 <see cref="int"/> 数组。</returns>
        static int[] HalfAndHalf(int n)
        {
            int[] array = new int[n];
            HalfIt(0, 0, n / 2, array);
            Shuffle(array);
            return array;
        }

        /// <summary>
        /// 递归生成 1/2 为 0, 1/4 为 1, 1/8 为 2 …… 的 <see cref="int"/> 数组。
        /// </summary>
        /// <param name="start">填充起点。</param>
        /// <param name="number">起始编号。</param>
        /// <param name="length">填充长度</param>
        /// <param name="array">用于填充的数组。</param>
        /// <returns>一个 <see cref="int"/> 数组。</returns>
        static int[] HalfIt(int start, int number, int length, int[] array)
        {
            if (length == 0)
                return array;

            for (int i = 0; i < length; i++)
            {
                array[start + i] = number;
            }

            return HalfIt(start + length, number + 1, length / 2, array);
        }

        /// <summary>
        /// 生成一半是 0 一半是随机整数的 <see cref="int"/> 数组。
        /// </summary>
        /// <param name="n">数组大小。</param>
        /// <returns>生成一半是 0 一半是随机整数的 <see cref="int"/> 数组。</returns>
        static int[] HalfZeroHalfRandom(int n)
        {
            int[] array = new int[n];
            Random random = new Random();
            for (int i = 0; i < n / 2; i++)
            {
                array[i] = 0;
            }

            for (int i = n / 2; i < n; i++)
            {
                array[i] = random.Next();
            }

            Shuffle(array);

            return array;
        }

        /// <summary>
        /// 打乱数组。
        /// </summary>
        /// <param name="a">需要打乱的数组。</param>
        static void Shuffle(int[] a)
        {
            int N = a.Length;
            Random random = new Random();
            for (int i = 0; i < N; i++)
            {
                int r = i + random.Next(N - i);// 等于StdRandom.uniform(N-i)
                int temp = a[i];
                a[i] = a[r];
                a[r] = temp;
            }
        }
    }
}

包涵惯性的ScrollViewer。 

HTTP 错误 500.22 - Internal Server Error

解答

每一次只让枢轴变为已排序,那正是最坏景况。
这种时候枢轴是现阶段子数组的最大值 / 最小值。
是因为在大家的达成中年老年是取子数组的第三个因素作为枢轴。
由此八个已排序的数组能够高达最坏处境,比较次数高达 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
1 protected override void OnMouseWheel(MouseWheelEventArgs e)
2 {
3     if (!IsEnableInertia)
4     {
5         base.OnMouseWheel(e);
6         return;
7     }
8     e.Handled = true;
9 }    

接下来在运维方面那句施命发号,成功的话出现

题目

非递归的飞速排序。
完毕叁个非递归的飞快排序,使用八个循环来将弹出栈的子数组切分并将结果子数组重新压入栈。
只顾:先将相当大的子数组压入栈,那样就能够保险栈最七只会有 lgN 个成分。

  那样一来,ScrollViewer就不会响应滚轮事件了,我们就在那地做小说。首先我们给这几个ScrollViewer增多多个性质 IsEnableInertia ,用来支配是还是不是使用惯性,因为萝卜麻油菜籽各有所好,不要想着压迫全部人使用惯性,所以滚轮响应措施成为:

(2)注意这里Default Web Site是您在上边那篇作品里site节点里陈设的name,例如<site name="SampleWeb" id="1" serverAutoStart="true">里的萨姆pleWeb,这里可能会报错,说:命令“MIGRATE”在目的“CONFIG”上不受扶助。请运转“appcmd.exe CONFIG /?” 突显协助的命令。"

代码
using System;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using Quick;

namespace _2._3._31
{
    public partial class Form2 : Form
    {
        private int N;
        private int T;

        public Form2(int n, int t)
        {
            InitializeComponent();
            this.N = n;
            this.T = t;
        }

        /// <summary>
        /// 启动页面时启动后台测试。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form2_Shown(object sender, EventArgs e)
        {
            this.Text = "正在绘图";
            this.backgroundWorker1.RunWorkerAsync();
        }

        /// <summary>
        /// 后台测试方法。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;
            QuickSort quick = new QuickSort();

            double percentPerTrial = 100.0 / this.T;
            double[] totalTime = new double[this.T];
            for (int i = 0; i < this.T; i++)
            {
                double[] data = SortCompare.GetRandomArrayDouble(this.N);
                totalTime[i] = SortCompare.Time(quick, data);
                worker.ReportProgress((int)(percentPerTrial * i));
            }

            e.Result = totalTime;
        }

        /// <summary>
        /// 更新后台进度方法。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            this.Text = "正在测试,已完成 " + e.ProgressPercentage + " %";
        }

        /// <summary>
        /// 测试完毕,进行绘图的方法。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                MessageBox.Show(e.Error.Message);
            }
            //新建画布
            Graphics graphics = this.CreateGraphics();

            //翻转默认坐标系
            graphics.TranslateTransform(0, this.Height);
            graphics.ScaleTransform(1, -1);

            double[] counts = e.Result as double[];

            //获取最大值
            double max = counts.Max();
            //计算间距
            double unit = this.Width / (3.0 * counts.Length + 1);
            double marginTop = 100;
            //计算直方图的矩形
            Rectangle[] rects = new Rectangle[counts.Length];
            rects[0].X = (int)unit;
            rects[0].Y = 0;
            rects[0].Width = (int)(2 * unit);
            rects[0].Height = (int)((counts[0] / max) * (this.Height - marginTop));
            for (int i = 1; i < counts.Length; ++i)
            {
                rects[i].X = (int)(rects[i - 1].X + 3 * unit);
                rects[i].Y = 0;
                rects[i].Width = (int)(2 * unit);
                rects[i].Height = (int)((counts[i] / (max + 1)) * (this.Height - marginTop));
            }

            //绘图
            graphics.FillRectangles(Brushes.Black, rects);

            //释放资源
            graphics.Dispose();

            this.Text = "绘图结果,最高耗时:" + counts.Max() + " 最低耗时:" + counts.Min();
        }
    }
}

  调整ScrollViewer的垂直滚动能够运用 ScrollViewer.ScrollToVerticalOffset ,横向也相符。为啥无法用 VerticalOffset ?因为 VerticalOffset 在注册的时候就证实了是只读的:

2.3.30

  因为相近的惯性滚动以垂直方向居多,所以笔者从未写水平方向的逻辑,但也超轻便扩大,有意思味的博友能够下载源代码本身研商。

题目

Infiniti气象。
用起来随机化和非初叶随机化的高速排序测量检验演练 2.1.35 和演练 2.1.36 中描述的巨型非随机数组。
在将那一个大数组排序时,乱序对连忙排序的性质有啥影响?

题目

借使跳过最早打乱数组的操作,
交由两个包蕴 10 个成分的数组,
使得 Quick.sort(卡塔尔 所需的可比次数高达最坏情状。

另请参阅

Quick 库

2.3.20

2.3.16

2.3.12

解答

运维结果如下:
图片 8

本文由皇家国际app发布,转载请注明来源:包涵惯性的ScrollViewer