基础排序算法(三)——对半插入排序

最新推荐文章于 2024-08-02 19:42:34 发布
最新推荐文章于 2024-08-02 19:42:34 发布
阅读量4.1k 收藏 8
点赞数 1
分类专栏： C# 数据结构与算法 文章标签： C# 排序算法 插入排序 算法 对半插入排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxzh12345/article/details/24101667
版权

之前的文章介绍了冒泡排序和插入排序，这里再补充一个对半插入排序算法，它与对半查找算法（二分查找算法）有点相似之处。

还是先上代码：

        public void HalfInsertSort(int[] array)
        {
            int j = 0, temp, low, high, mid;
            int count = array.Length;
            for (int i = 1; i < count; i++)
            {
                temp = array[i];
                low = 0;
                high = i - 1;
                while (low <= high)
                {
                    mid = (low + high) / 2;
                    if (temp < array[mid]) high = mid - 1;
                    else low = mid + 1;
                }
                for (j = i - 1; j >= low; j--) array[j + 1] = array[j];
                array[low] = temp;
            }
        }
在Program的Main函数里New一个（一）中写的那个CSharpArray类，调用其中的方法测试： 

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

namespace BasicStructure
{
    class Program
    {
        static void Main(string[] args)
        {
            CSharpArray csharArray = new CSharpArray(8);
            int[] array = csharArray.getArray();
            Console.WriteLine("排序前:");
            Console.WriteLine();
            csharArray.PrintArray(array);
            Console.WriteLine();
            Console.WriteLine("排序后:");
            csharArray.HalfInsertSort(array);
            csharArray.PrintArray(array);

            Console.ReadKey();
        }
    }
}
输出结果：

排序前:
        1       0       2       5       4       1       3       4
排序后:
        0       1       1       2       3       4       4       5
为了显示for循环中的每次执行结果，在HalfInsertSort方法里加一句输出：

        public void HalfInsertSort(int[] array)
        {
            int j = 0, temp, low, high, mid;
            int count = array.Length;
            for (int i = 1; i < count; i++)
            {
                temp = array[i];
                low = 0;
                high = i - 1;
                while (low <= high)
                {
                    mid = (low + high) / 2;
                    if (temp < array[mid]) high = mid - 1;
                    else low = mid + 1;
                }
                for (j = i - 1; j >= low; j--) array[j + 1] = array[j];
                array[low] = temp;
                PrintArray(array);
            }
        }
再次编译运行即得以下结果：

排序前:
        1       0       2       5       4       1       3       4
排序后:
        0       1       2       5       4       1       3       4
        0       1       2       5       4       1       3       4
        0       1       2       5       4       1       3       4
        0       1       2       4       5       1       3       4
        0       1       1       2       4       5       3       4
        0       1       1       2       3       4       5       4
        0       1       1       2       3       4       4       5
        0       1       1       2       3       4       4       5
从输出结果可以看出，遍历数组元素，利用对半查找原理找到其位置，插入，将受影响的元素一次前移。


同样，为了将以上的升序排序算法改为降序，也只需将while括号里的大于号改为小于号即可。


这里，既然将其封装在一个类里，自然要提高其通用性，因此，我可以再给改排序算法添加一个参数，用来标记是升序排序还是降序排序。如：用“0”表示升序，用“1”表示降序，在不降低代码运行效率时以牺牲代码简洁性来修改一下代码：

        public void HalfInsertSort(int[] array, int orderType)
        {
            int j = 0, temp,low,high,mid;
            int count = array.Length;
            if (orderType == 0)
            {
                for (int i = 1; i < count; i++)
                {
                    temp = array[i];
                    low = 0;
                    high = i - 1;
                    while (low <= high)
                    {
                        mid = (low + high) / 2;
                        if (temp < array[mid]) high = mid - 1;
                        else low = mid + 1;
                    }
                    for (j = i - 1; j >= low; j--) array[j + 1] = array[j];
                    array[low] = temp;
                    PrintArray(array);
                }
            }
            else if (orderType == 1)
            {
                for (int i = 1; i < count; i++)
                {
                    temp = array[i];
                    low = 0;
                    high = i - 1;
                    while (low < high)
                    {
                        mid = (low + high) / 2;
                        if (temp > array[mid]) high = mid - 1;
                        else low = mid + 1;
                    }
                    for (j = i - 1; j >= low; j--) array[j + 1] = array[j];
                    array[low] = temp;
                    PrintArray(array);
                }
            }
        }
再修改Main函数里代码： 

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

namespace BasicStructure
{
    class Program
    {
        static void Main(string[] args)
        {
            CSharpArray csharArray = new CSharpArray(8);
            int[] array = csharArray.getArray();
            Console.WriteLine("排序前:");
            Console.WriteLine();
            csharArray.PrintArray(array);
            Console.WriteLine();
            Console.WriteLine("升序排序后:");
            csharArray.HalfInsertSort(array, 0);
            csharArray.PrintArray(array);
            Console.WriteLine("降序排序后:");
            csharArray.HalfInsertSort(array, 1);
            csharArray.PrintArray(array);

            Console.ReadKey();
        }
    }
}
编译运行结果如下所示：

排序前:
        2       4       0       3       5       6       1       1
升序排序后:
        2       4       0       3       5       6       1       1
        0       2       4       3       5       6       1       1
        0       2       3       4       5       6       1       1
        0       2       3       4       5       6       1       1
        0       2       3       4       5       6       1       1
        0       1       2       3       4       5       6       1
        0       1       1       2       3       4       5       6
        0       1       1       2       3       4       5       6
降序排序后:
        1       0       1       2       3       4       5       6
        1       1       0       2       3       4       5       6
        2       1       1       0       3       4       5       6
        3       2       1       1       0       4       5       6
        4       3       2       1       1       0       5       6
        5       4       3       2       1       1       0       6
        6       5       4       3       2       1       1       0
        6       5       4       3       2       1       1       0

最后，再次贴一下CSharpArray类的代码：

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

namespace BasicStructure
{
    class CSharpArray
    {
        private int[] array;
        public CSharpArray(int count)
        {
            array = new int[count];
            Random random = new Random();
            for (int i = 0; i < count; i++)
            {
                array[i] = random.Next(count);
            }
        }
        public int[] getArray()
        {
            return array;
        }
        public void PrintArray(int []array)
        {
            int count=array.Length;
            for (int i = 0; i < count; i++)
            {
                Console.Write("\t{0}", array[i]);
                if ((i + 1) % 8 == 0)
                    Console.WriteLine();
            }
        }
        /// <summary>
        /// 冒泡排序算法
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="orderType">排序类型 0：升序；1：降序</param>
        public void BubbleSort(int []array,int orderType)
        {
            int temp;
            int count = array.Length;
            if(orderType==0)
            {
                for (int i = count; i >= 1; i--)
                {
                    for (int j = 0; j < i - 1; j++)
                    {
                        if (array[j] > array[j + 1])
                        {
                            temp = array[j];
                            array[j] = array[j + 1];
                            array[j + 1] = temp;
                        }
                    }
                    PrintArray(array);
                }
            }else if(orderType==1)
            {
                for (int i = count; i >= 1; i--)
                {
                    for (int j = 0; j < i - 1; j++)
                    {
                        if (array[j] < array[j + 1])
                        {
                            temp = array[j];
                            array[j] = array[j + 1];
                            array[j + 1] = temp;
                        }
                    }
                    PrintArray(array);
                }
            }
        }

        /// <summary>
        /// 插入排序算法
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="orderType">排序类型 0：升序；1：降序</param>
        public void InsertSort(int[] array,int orderType)
        {
            int j = 0,temp;
            int count = array.Length;
            if (orderType == 0)
            {
                for (int i = 1; i < count; i++)
                {
                    temp = array[i];
                    j = i;
                    while (j > 0 && array[j - 1] >= temp)
                    {
                        array[j] = array[j - 1];
                        j -= 1;
                    }
                    array[j] = temp;
                    PrintArray(array);
                }
            }
            else if (orderType == 1)
            {
                for (int i = 1; i < count; i++)
                {
                    temp = array[i];
                    j = i;
                    while (j > 0 && array[j - 1] <= temp)
                    {
                        array[j] = array[j - 1];
                        j -= 1;
                    }
                    array[j] = temp;
                    PrintArray(array);
                }
            }
        }

        /// <summary>
        /// 对半插入排序算法
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="orderType">排序类型 0：升序；1：降序</param>
        public void HalfInsertSort(int[] array, int orderType)
        {
            int j = 0, temp,low,high,mid;
            int count = array.Length;
            if (orderType == 0)
            {
                for (int i = 1; i < count; i++)
                {
                    temp = array[i];
                    low = 0;
                    high = i - 1;
                    while (low <= high)
                    {
                        mid = (low + high) / 2;
                        if (temp < array[mid]) high = mid - 1;
                        else low = mid + 1;
                    }
                    for (j = i - 1; j >= low; j--) array[j + 1] = array[j];
                    array[low] = temp;
                    PrintArray(array);
                }
            }
            else if (orderType == 1)
            {
                for (int i = 1; i < count; i++)
                {
                    temp = array[i];
                    low = 0;
                    high = i - 1;
                    while (low < high)
                    {
                        mid = (low + high) / 2;
                        if (temp > array[mid]) high = mid - 1;
                        else low = mid + 1;
                    }
                    for (j = i - 1; j >= low; j--) array[j + 1] = array[j];
                    array[low] = temp;
                    PrintArray(array);
                }
            }
        }
    }
}
OK，对半插入排序算法的基本演示就到此结束！


注：由于数组时代码里生成的随机数组，因此每次运行的结果基本不一样，可能与以上演示结果不同。


原创博客 反馈请猛戳:

龙心之火
关注
专栏目录
7、Java——数组常用排序方法
不迁怒，不贰过。小知识，大智慧。
09-09 445
冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序
C++实现对半插入排序
08-25
对半插入排序的思想是：在插入 Ri时（这时R1，R2，…，Ri–1已经排序),取Ki/2 与Ki 进行比较，如果Ki<Ki/2，则Ri只能插在R1与Ri/2之间，故可以在R1与Ri/2–1 之间递归上述过程，否则可以在Ri/2+1与Ri–1之间递归上述过程。 如此进行直到最后确定插入位置为止。设计对半插入排序算法；编制程序实现该算法，制定测试方案，并调试通过。 1、 设计并实现对半插入排序算法。 2、 理论分析并实验验证算法的时间复杂度，即关键词的比较次数和记录的移动次数。
#数据结构 对半插入排序算法
qq_42368203的博客
07-11 625
C# Array
最新发布
m0_74918341的博客
08-02 999
/获取多维数组中第一个维度的长度。//1.数组的声明,声明数组类似声明变量,需要指定数组中存储的数据类型,一般数组变量的名称以复数的形式命名(加s)//数组中数据的操作都是基于索引的,索引从0开始,到数组的长度(Length)-1结束,用于访问数组中存储的数据。交错数组其实就是元素为数组的数组，换句话说就是交错数组中的每个元素都可以是维度和大小不同的数组，所以有时交错数组也被称为“数组的数组”。//如果初始化的时候指定了数组的初始值,那么就可以省略指定数组的长度,会自动根据数组的初始值判定数组的长度。
直接擦插入排序-希尔排序
家里蹲大学摸鱼学专业优秀毕业生的博客
01-15 155
#include<stdio.h> #include<stdlib.h> #include <string.h> #define MAXSIZE 100 typedef int T; typedef struct list { int size; T elements[MAXSIZE]; }List; void InsSort(List* lst, int h, int offset) { int i, j; T x; for ( i = offset+h ; i
5分钟了解折半插入排序
weixin_30256901的博客
07-04 149
5分钟了解折半插入排序 前言 折半插入排序（Binary Insertion Sort）是对直接插入排序算法的一种改进。 插入排序思想介绍 折半插入排序与直接插入排序算法原理相同。只是，在向已排序的数据中插入数据时，采用来折半查找（二分查找）。先取已经排序的序列的中间元素，与待插入的数据进行比较，如果中间元素的值大于待插入的数据，那么待插入的数据属于数组的前半部分，否则属于后半部分。依次类...
java选择排序冒泡排序_Java选择排序、冒泡排序、直接插入排序与二分查找
weixin_39768917的博客
02-21 323
介绍一下四种Java的经典算法，这四种算法是非常基础的算法，学算法对我们深入理解程序有很大帮助。选择排序冒泡排序插入排序二分查找选择排序初始时第一个元素依次和后面的元素比较，在序列中找到最小元素并记录其下标，第一轮比较完毕后把最小元素交换到序列的起始位置作为已排序序列，然后再从剩下的未排序元素中找到最小元素，放到已排序序列末尾，直到所有元素排列完毕。选择排序.gif示例代码：public void...
【Algorithms公开课学习笔记5】排序算法part2——归并排序
Kevin的博客
09-11 379
Merge Sort 归并排序 0.前言 前面的文章已经分析了选择排序、插入排序、希尔排序等基础排序算法，本文将分析一个性能极高的排序算法——归并排序。在Java编程的时候，我们经常会使用到一个API：Arrays.sort(o),如果括号中的o是对象的话，那么该API就是调用归并排序算法（结合了插入排序）来完成排序的。顺带一提，如果括号里的o是java基本类型，那么该API就会调用快速排...
手撕面试题算法＜排序＞（4）—— 归并排序
Yuc0114的博客
11-02 643
前言 归并排序是一个相当快速的算法，其时间复杂度稳定在O(n*logn)，在面试中被问到的频率也挺高的，今天就来介绍一下这个排序算法 手撕算法 - 排序系列 手撕面试题算法＜排序＞（1）—— 冒泡排序及其优化实现 手撕面试题算法＜排序＞（2）—— 选择排序 手撕面试题算法＜排序＞（3）—— 插入排序及其优化实现 手撕面试题算法＜排序＞（3.5）—— 希尔排序 源码 看完有收获别忘了点个star哦~ 导航前言手撕算法 - 排序系列源码归并排序思想时间复杂度实现1. 核心 - 数组的拆分2. 核心 - 数组的归
经典排序算法分析与实现
slow_sparrow的博客
03-09 699
经典排序算法分析与实现算法一、常见排序算法1.comparable和comparator2.约定3.选择排序算法4.冒泡排序算法5.插入排序算法6.希尔排序算法7.归并排序算法7.1 自顶向上归并排序7.2 自底向上归并排序8.快速排序算法8.1 基本算法8.2 性能分析8.3 算法改进8.3.1 切换到插入排序8.3.2 三数取中算法8.3.3 三向切分算法8.4 基于切分的快速选择算法9.堆排序10.上述排序算法的比较二、JDK自带的DualPivotQuickSort三、学习参考： 算法 一、常见排序
重要题型整理：数据结构与算法——内排序
weixin_44548848的博客
01-04 1141
重要题型整理：数据结构与算法——内排序 期末复习补档，极限操作 （数据结构与算法mooc）需要对1000个大型的记录进行排序，记录本身存储在外存中，在内存中只保存了所有记录的排序码。排序码之间的比较非常快，但是移动代价很大，因为一旦移动一个排序码，相应的外存中的记录也要移动，将涉及上百个磁盘块的移动，应该使用何种排序方法( ) A.堆排序 B.直接选择排序 C.插入排序 D.快速排序 解析：...
对半查找，选择排序，冒泡排序和快速排序的Objective-C实现
03-13
对应博客 http://blog.csdn.net/liuyinghui523/article/details/79547852
排序----折半插入排序
热门推荐
太阳爱编程
05-26 5万+
折半插入排序（Binary Insertion Sort）是对插入排序算法的一种改进，所谓排序算法过程，就是不断的依次将元素插入前面已排好序的序列中。 排序思想：有一组数据待排序，排序区间为Array[0]~Array[n-1]。将数据分为有序数据和无序数据，第一次排序时默认Array[0]为有序数据，Array[1]~Array[n-1]为无序数据。有序数据分区的第一个元素位置为low，最后一...
C语言实现插入排序——折半插入排序（根据输入实时排序、不带哨兵排序、带哨兵排序）
酒醉浮生的博客
09-13 984
C语言实现折半插入排序 文章目录C语言实现折半插入排序一、动态数组实现即输即排1.定义动态数组2.初始化动态数组3.增加动态数组长度4.排序算法5.实时输入数值并排序二、不带哨兵的数组折半插入排序三、带哨兵的数组折半插入排序项目完整代码运行效果图 一、动态数组实现即输即排 1.定义动态数组 #define InitSize 25 //定义动态顺序表 typedef struct { int *data; int MaxSize; int length; } DSqList; 2.
折半插入排序
常胜将军的博客
12-15 284
折半插入排序是对直接插入排序的改进，可以这么说，折半插入排序=直接插入排序+二分查找，代码如下。 #include using namespace std; void insetSort(int a[],int n){ int l,r,m; for(int i=2;i<=n;i++){ a[0]=a[i]; l=1; r=i-1;
排序算法之二 折半插入排序
09-03 1万+
折半插入排序，折半插入排序在直接插入的基础上进行改进，考虑到直接插入排序将很多开销放在比较和数据移动上。比较是不可避免的，有没有什么办法可以减少比较的次数呢？至少不要像现在这样挨个去比吧？于是想到在前面查找算法中的折半查找法，迅速翻书回去看看。考虑到这样一种情况，当第i个元素要进
插入排序之折半插入排序-binaryinsertsort
Joyem123的博客
02-29 950
折半插入排序的方法是：对每一个待排序数据元素，在有序子集中实施折半查找，确定插入位置，所谓折半查找， 就是利用有序子集的居中元素，将有序子集分为左右两个半区。如果待排数据元素比居中的数据元素小，就在左 区继续折半查找，否则在右半区继续折半查找，当中间数据元素与待排数据元素相等时，要取右半区空间继续折 半查找，直到插入位置确定。#include #include using namespace
直接插入排序与折半插入排序——Java实现
My Blog
06-26 2879
直接插入排序与折半插入排序Java实现
折半插入
weixin_43573534的博客
03-30 1086
折半插入：将数组分为待排序区域和未排序区域 排序方法：1.已排序区域的第一个元素位置为low，最后一个元素位置为high，中间元素 位置为mid 2.取待排序区间的第一个元素，与已排序区间中间位置的元素相比较，若大于，则新的已排序区间左边元素的位置为mid+1；若小于，则新的已排序区间右边元素的位置为mid-1； 3.重复确定新的已排序区域的中间...
C语言详解：基础排序算法——插入排序实现与理解
本文将深入探讨C语言中的排序方法，特别是介绍了一种基础的排序算法——插入排序（Insertion Sort）。 插入排序通过将一个待排序的元素逐个插入到已排序序列的正确位置来达到排序的目的。这个算法在C语言中的实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值