将无序部分的首个与平稳部分开展相比较365体育官网.,从静止部分的末尾向前方比较

一、直接插入排序

一、直接插入排序

  1. 思想
  1. 思想

平昔排序法, 可以分为七个部分, 一部分是不变的, 一部分是无序的.

直白排序法, 可以分成四个部分, 一部分是逐步的, 一部分是无序的.

365体育官网 1

365体育官网 2

从这几个图上, 应该是能看了然间接插入排序的研究了.

从那一个图上, 应该是能看了然直接插入排序的想想了.

将无序部分的率先个与平稳部分开展相比较.

将无序部分的率先个与平稳部分开展相比.

从静止部分的背后向前方相比, 然后不停地活动有序部分的多少的岗位

从静止部分的背后向前边比较, 然后连连地活动有序部分的数码的职位

static void InsertSort(List<int> list)
{
   //从第二个数开始循环, 循环n-1次
    for (int i = 1; i < list.Count; i++)
    {
     //将待排序的数拿出来, 以便后面挪位子
        int temp = list[i];
     //j就是最后确定的那个最大/最小数的下标
        int j = i; 
        while (j >= 1 && temp < list[j - 1])
        {
       //将满足条件的数据向后移动一位, 腾空位, 为插入挪位子
            list[j] = list[j - 1];
            j--;
        }
        list[j] = temp;
    }
}
static void InsertSort(List<int> list)
{
   //从第二个数开始循环, 循环n-1次
    for (int i = 1; i < list.Count; i++)
    {
     //将待排序的数拿出来, 以便后面挪位子
        int temp = list[i];
     //j就是最后确定的那个最大/最小数的下标
        int j = i; 
        while (j >= 1 && temp < list[j - 1])
        {
       //将满足条件的数据向后移动一位, 腾空位, 为插入挪位子
            list[j] = list[j - 1];
            j--;
        }
        list[j] = temp;
    }
}

 

 

  1. 复杂度
  1. 复杂度

直接插入排序的最好状态下, 时间复杂度为O(n), 最坏意况下,
复杂度为O(n2);

直接插入排序的最好状态下, 时间复杂度为O(n), 最坏情形下,
复杂度为O(n2);

证明见:

证明见:

插入排序及其复杂度分析

插入排序及其复杂度分析

 

 

  1. 间接插入排序vs快捷排序
  1. 直接插入排序vs快速排序

365体育官网 3

365体育官网 4

 从地点的代码来看, 直接插入排序必要持续地挪数据. 倘诺遇到一连整数,
那么挪动的数额就多了. 针对那种题材, 是还是不是能够改进一下直接插入排序?

 从地点的代码来看, 直接插入排序要求不停地挪数据. 借使碰着一连整数,
那么挪动的多少就多了. 针对那种题材, 是还是不是可以改革一下间接插入排序?

在比较的时候, 我是不是足以跳着相比较?

在可比的时候, 我是或不是可以跳着相比较?

 

 

二、希尔排序

二、希尔(希尔)排序

  1. 思想
  1. 思想

在可比的时候, 引入减弱增量相比较的形式.

在相比的时候, 引入缩短增量比较的格局.

第一步. 使增量d=count/2, 将每隔d个数看成是一组无序的数,
然后对那组无序的数举办插入排序

先是步. 使增量d=count/2, 将每隔d个数看成是一组无序的数,
然后对那组无序的数举行插入排序

第二步. 使增量d=d/2, 和第一步执行同样的操作, 平素到d=1的时候

其次步. 使增量d=d/2, 和率先步执行同样的操作, 一向到d=1的时候

365体育官网 5

365体育官网 6

代码:

代码:

static void ShellSort(List<int> list)
{
    int step = list.Count / 2;
    while (step >= 1)
    {
        for (int i = step; i < list.Count; i++)
        {
            var temp = list[i];
            int j = i;
            while (j >= step && temp < list[j - step])
            {
                list[j] = list[j - step];
                j -= step;
            }
            list[j] = temp;
        }
        step = step / 2;
    }
}
static void ShellSort(List<int> list)
{
    int step = list.Count / 2;
    while (step >= 1)
    {
        for (int i = step; i < list.Count; i++)
        {
            var temp = list[i];
            int j = i;
            while (j >= step && temp < list[j - step])
            {
                list[j] = list[j - step];
                j -= step;
            }
            list[j] = temp;
        }
        step = step / 2;
    }
}

希尔排序与直接插入排序, 中间有些的代码基本一直, 差其余只是维度,
直接插入排序的维度是原则性的1,

希尔(希尔)排序与直接插入排序, 中间有些的代码基本一贯, 不相同的只是维度,
直接插入排序的维度是稳定的1,

而希尔(Hill)排序的维度是生成的. 从代码上看, 其实依旧蛮简单的,
就拿着直接插入排序改呢改呢就成了.

而希尔排序的维度是转变的. 从代码上看, 其实依然蛮简单的,
就拿着直接插入排序改呢改呢就成了.

 

 

  1. 复杂度
  1. 复杂度

希尔(希尔(Hill))排序的光阴复杂度, 和直接插入排序的最好&最坏时间复杂度居然是同样的,
同志们, 能相信么.

希尔(Hill)排序的小时复杂度, 和间接插入排序的最好&最坏时间复杂度居然是同等的,
同志们, 能相信么.

 

 

三、间接插入排序 vs 希尔排序

三、直接插入排序 vs 希尔(希尔)排序

既然如此说希尔(希尔)排序是直接插入排序的立异版, 那么她们到底何人更决定些呢?
会不会越改越差了?

既然如此说希尔(希尔(Hill))排序是直接插入排序的立异版, 那么她们到底哪个人更决心些呢?
会不会越改越差了?

static void Test()
{
    //五次比较
    for (int i = 1; i <= 5; i++)
    {
        List<int> list = new List<int>();
        List<int> listA = new List<int>();
        //插入2k个随机数到数组中
        for (int j = 0; j < 10000; j++)
        {
            Thread.Sleep(1);
            list.Add(new Random((int)DateTime.Now.Ticks).Next(0, 100000));
        }

        listA.AddRange(list);
        Console.WriteLine("\n第" + i + "次比较:{0}...", string.Join(",", list.Take(10)));

        Stopwatch watch = new Stopwatch();
        watch.Start();
        InsertSort(list);
        watch.Stop();
        Console.WriteLine("\n直接插入排序耗费时间:" + watch.ElapsedMilliseconds);
        Console.WriteLine("输出前是十个数:" + string.Join(",", list.Take(10).ToList()));

        watch.Restart();
        ShellSort(listA);
        watch.Stop();
        Console.WriteLine("\n希尔排序耗费时间:" + watch.ElapsedMilliseconds);
        Console.WriteLine("输出前是十个数:" + string.Join(",", listA.Take(10).ToList()));
    }
}
static void Test()
{
    //五次比较
    for (int i = 1; i <= 5; i++)
    {
        List<int> list = new List<int>();
        List<int> listA = new List<int>();
        //插入2k个随机数到数组中
        for (int j = 0; j < 10000; j++)
        {
            Thread.Sleep(1);
            list.Add(new Random((int)DateTime.Now.Ticks).Next(0, 100000));
        }

        listA.AddRange(list);
        Console.WriteLine("\n第" + i + "次比较:{0}...", string.Join(",", list.Take(10)));

        Stopwatch watch = new Stopwatch();
        watch.Start();
        InsertSort(list);
        watch.Stop();
        Console.WriteLine("\n直接插入排序耗费时间:" + watch.ElapsedMilliseconds);
        Console.WriteLine("输出前是十个数:" + string.Join(",", list.Take(10).ToList()));

        watch.Restart();
        ShellSort(listA);
        watch.Stop();
        Console.WriteLine("\n希尔排序耗费时间:" + watch.ElapsedMilliseconds);
        Console.WriteLine("输出前是十个数:" + string.Join(",", listA.Take(10).ToList()));
    }
}

365体育官网 7

365体育官网 8

从结果上看, 希尔(希尔)排序的校订效果仍然蛮明确的.
不过希尔排序并不是一个稳定性的排序格局. 也就是说,
仍旧可能出现比神速排序慢的时候.

从结果上看, 希尔排序的更正效果仍然蛮明确的.
不过希尔(Hill)排序并不是一个稳定的排序形式. 也就是说,
照旧可能出现比火速排序慢的时候.

 

 

相关文章