2. 程式人生 > >基礎排序演算法(三)——對半插入排序

基礎排序演算法(三)——對半插入排序

阿新 • • 發佈：2019-01-06

之前的文章介紹了氣泡排序和插入排序，這裡再補充一個對半插入排序演算法，它與對半查詢演算法（二分查詢演算法）有點相似之處。

還是先上程式碼：

        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，對半插入排序演算法的基本演示就到此結束！


注：由於陣列時程式碼裡生成的隨機陣列，因此每次執行的結果基本不一樣，可能與以上演示結果不同。


原創部落格 反饋請猛戳:

相關推薦

基礎排序演算法(三)——對半插入排序

之前的文章介紹了氣泡排序和插入排序，這裡再補充一個對半插入排序演算法，它與對半查詢演算法（二分查詢演算法）有點相似之處。 還是先上程式碼： public void HalfInsertSort(int[] array) {

排序演算法三：直接插入排序

要點 直接插入排序是一種最簡單的插入排序。 插入排序：每一趟將一個待排序的記錄，按照其關鍵字的大小插入到有序佇列的合適位置裡，知道全部插入完成。  在講解直接插入排序之前，先讓我們腦補一下我們打牌的過程。 先拿一張5在手裡， 再摸到一張4，比5小，插到5前面， 摸

排序演算法(三)：簡單選擇排序（Simple Selection Sort）

基本思想： 在要排序的一組數中，選出最小（或者最大）的一個數與第1個位置的數交換；然後在剩下的數當中再找最小（或者最大）的與第2個位置的數交換，依次類推，直到第n-1個元素（倒數第二個數）和第n個元素（最後一個數）比較為止。 簡單選擇排序的示例： 操作方法： 第一趟，從n

排序演算法(一)：直接插入排序

1.插入排序—直接插入排序(Straight Insertion Sort) 基本思想: 將一個記錄插入到已排序好的有序表中，從而得到一個新，記錄數增1的有序表。即：先將序列的第1個記錄看成是一個有序的子序列，然後從第2個記錄逐個進行插入，直至整個序列有序為止。 要點：設立哨兵，作

【Java】 大話資料結構(18) 排序演算法(5) （直接插入排序） 資料結構與演算法合集 資料結構與演算法合集

本文根據《大話資料結構》一書，實現了Java版的直接插入排序。 更多：資料結構與演算法合集 基本概念 　　直接插入排序思路：類似撲克牌的排序過程，從左到右依次遍歷，如果遇到一個數小於前一個數，則將該數插入到左邊所有比自己大的數之前，也就是說，將該數前面的所有更大的數字都後移一位，空出來的位置放入該數。

java排序演算法（二）------插入排序

插入排序 直接插入排序基本思想: 每一步將一個待排序的記錄，插入到前面已經排好序的有序序列中去，直到插完所有元素為止。 public static void sort(int[] arr) { int i; int t; for (int j

排序演算法3——圖解直接插入排序以及折半（二分）插入排序及其實現

排序演算法1——圖解氣泡排序及其實現（三種方法，基於模板及函式指標） 排序演算法2——圖解簡單選擇排序及其實現 排序演算法3——圖解直接插入排序以及折半（二分）插入排序及其實現 排序演算法4——圖解希爾排序及其實現 排序演算法5——圖解堆排序及其實現 排序演算法6——圖解歸併排序及其遞迴與非

排序演算法(3/4) 之 插入排序_md

插入排序 1、 直接插入排序 （穩定排序） 在已經排好的佇列中插入新的元素 流程： 複雜度： 時間複雜度：O(n^2) 空間複雜度：O(1) 程式碼實現（JAVA） public static void main(String[] args) {

java 實現 常見排序演算法（二） 插入排序

大家好，我是烤鴨：        今天分享一下基礎排序演算法之直接插入排序。   1.     直接插入排序： 原理：假設前面的數為有序數列，然後有序數列與無序數列的每個數比較，我們可

Java排序演算法之二分法插入排序

二、二分插入排序 package demosort; /* * * 基本思想：二分法插入排序的思想和直接插入一樣，只是找合適的插入位置的方式不同， * 這裡是按二分法找到合適的位置，可以減少比較的次數。 */ public class hal

排序演算法（四）——插入排序

插入排序（英語：Insertion Sort）是一種簡單直觀的排序演算法。通過對未排序的資料執行逐個插入至合適的位置而完成排序工作。 插入排序演算法的運作如下： 1.首先對陣列的前兩個資料進行從小到大的排序； 2.接著將第3個數據與排好序的兩個資料進行比較，將第三個資料插入合適的位置；

排序演算法（1）插入排序的演算法分析

導語 今天，我們介紹的是排序演算法經典的一種排序演算法，這個演算法是插入排序。 相信大家都玩過紙牌。插入排序的工作方式就像許多人排序一手撲克牌。 開始時，我們的左手為空並且桌子上的牌面朝下（意味著我們不在翻開之前並不知道下一張牌是多大的）

排序演算法一：直接插入排序

排序演算法 引言 在我的博文《“主宰世界”的10種演算法短評》中給出的首個演算法就是高效的排序演算法。本文將對排序演算法做一個全面的梳理，從最簡單的“冒泡”到高效的堆排序等。 排序相關的的基本概念 排序：將一組雜亂無章的資料按一

排序演算法總結之折半插入排序

基本思想折半插入排序是對直接插入排序的簡單改進，對於直接插入排序而言，當第i-1趟需要將第i個元素插入前面的0~i-1個元素序列中時，總是需要從i-1個元素開始，逐個比較每個元素，直到找到它的位置。這顯然沒有利用前面0~i-1個元素已經有序這個特點，而折半插入排序則改進了這一

【排序演算法】：直接插入排序

介紹 思想：每次從無序表中取出第一個元素，把它插入到有序表的合適位置，使有序表仍然有序。 實現原理：第一趟比較前兩個數，然後把第二個數按大小插入到有序表中； 第二趟把第三個資料與前兩個數從後向前掃描

基本排序（三）：插入排序 和 希爾排序- 從後向前掃描，比正操作元素大的逐步移位

1. 插入排序 插入排序（Insertion Sort）工作原理（維基百科） 通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置插入。插入排序實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向

排序演算法入門之「插入排序」

插入排序 借用《演算法導論》裡的例子，就是我們打牌的時候，每新拿一張牌都會把它按順序插入，這，其實就是插入排序。 齊姐宣告：雖然我們用打牌的例子，但是可不能學胡適先生啊。 對於陣列來說怎麼做呢？ 有一個重要的思想，叫做擋板法，就是用擋板把陣列分成兩個區間： 擋板左邊：已排序擋板右邊：

三、直接插入排序

ons length meta tostring over sort str name for 1、Java語言實現 抽象類 public abstract class Sorter { public abstract void sort(int [] array

排序演算法三--選擇排序

選擇排序(SelctionSort) 基本思想： 在長度為N的無序陣列中，第一次遍歷n-1個數，找到最小的數值與第一個元素交換； 第二次遍歷n-2個數，找到最小的數值與第二個元素交換； 。。。 第n-1次遍歷，找到最小的數值與第n-1個元素交換，排序完成。 過程：

演算法導論 第二章：演算法入門 筆記 （插入排序、迴圈不變式、演算法分析、最好和最壞時間複雜度、選擇排序、分治法、合併排序）

插入排序： 排序問題的定義如下： 輸入：N個數{a1, a2,..., an }。 輸出：輸入序列的一個排列{a'1 ,a'1 ,...,a'n }，使得a'n <=a' n<=...<