插入排序

/*--> */ /*--> */ 算法思想 将数据分为两部分:有序表,无序表;开始时有序表为空,无序表中全部是待排序数据,依次从无序表中取出待 排序元素插入到有序表中的合适位置,使有序表中的元素保持有序,直到无序表为空,表示排序完成。 例如:对数组使用插入排序 红色部分表示无序表,绿色部分表示有序表,直线箭头表示挪动元素以留出空间,以便元素的插入, 弧形箭头表示当前待排序元素的插入位置; 代码实现 使用C语言实现插入排序: bool InsertSort(int * pUnSortAry, int nArySize) { if (pUnSortAry == nullptr || nArySize <= 0) { return false; } for (int iIndex = 1; iIndex < nArySize; iIndex++) { int nCurrentValue = pUnSortAry[iIndex]; int jIndex = iIndex - 1; for (; jIndex >= 0 && nCurrentValue < pUnSortAry[jIndex]; jIndex--) { pUnSortAry[jIndex + 1] = pUnSortAry[jIndex]; } pUnSortAry[jIndex + 1] = nCurrentValue;

def insert_sort(alist): '''插入排序''' n = len(alist) for j in range(1,n): i = j while i > 0: if alist[i] < alist[i-1]: alist[i], alist[i-1] = alist[i-1],alist[i] i -= 1 else: break if __name__ == '__main__': li = [1, 30, -6, 0, 98, 99, 4] print(li) insert_sort(li) print(li) C:\Users\user\AppData\Local\Programs\Python\Python36\python.exe “C:/Users/user/PycharmProjects/hellow python/test.py” [1, 30, -6, 0, 98, 99, 4] [-6, 0, 1, 4, 30, 98, 99] Process finished with exit code 0 来源： https://blog.csdn.net/weixin_43095456/article/details/99097420

希尔排序是插入排序的一种，也叫做缩减增量排序，是对插入排序的一种优化，但是不稳定。 public class ShellSort { /** *希尔排序，也可以叫做缩减增量排序，不稳定，为了减少比较次数，如插入排序 需要n X n * 原理：通过比较相距一定间隔的元素来工作； * 各躺所用的距离随着算法的进行而减少，知道只比较相邻元素的最后一个排序位置 * * 所间隔的k元素都被排序，相比于插入排序，时间会减少 */ public static void main(String[] args) { int[] a = {77, 12, 88, 42, 7, 22, 78}; sort(a); System.out.println(Arrays.toString(a)); } public static void sort(int[] a) { int j; for(int gap = a.length/2; gap > 0; gap /= 2) { for(int i = gap; i < a.length; i++) { int tmp = a[i]; for(j = i; j >= gap && tmp < a[j-gap]; j -= gap) { a[j] = a[j-gap]; } a[j] = tmp; } } }} 来源： https://www.cnblogs

插入排序是非常简单的一种排序，思想是保证0到n-1躺是排序的，比如说首先拿第二个元素和第一个元素进行比较，进行位置转换，然后拿第三个位置的元素依次和第二个，第一个进行比较，转换位置。大致就那么简单，如下代码： public class Sort { /** * 插入排序 保证从0到位置n上已经排序过了，即从第二个元素开始和前面的进行比较，然后换位置 * 思路 由两层遍历， 外层遍历 n-1 ，内层遍历转换 如下代码 * */ public static void main(String[] args) { int[] a = {12, 42, 7, 22, 78}; insertSort(a); System.out.println(Arrays.toString(a)); } public static void insertSort(int[] a) { for(int i = 1; i < a.length; i++) { int j; int tmp = a[i]; for(j = i; j > 0 && tmp < a[j-1]; j--) { a[j] = a[j-1]; } a[j] = tmp; } }} 来源： https://www.cnblogs.com/l-x-x-y-d-j/p/11331942.html

简单的理解，插入排序，就是原队列中不断的出列一个值，与已经出列的所有值进行一一比较，找到自己的位置进行插队。 下面是学习的来的插入排序以及自己对一些代码的注释；另外，在此基础上将其中的插队代码，单独做成了一个函数。 下面是插入排序的c++代码： 1 #include <iostream> 2 3 using namespace std; 4 5 template<class T> 6 void InsertionSort(T *p, int len); 7 8 int main() 9 { 10 int q[] = {8,5,7,4,0,9,6,2,3,1}; 11 InsertionSort(q, 10); 12 for(int i=0; i<10; i++) 13 { 14 cout << q[i] << ' '; 15 } 16 cout << endl; 17 return 0; 18 } 19 20 template<class T> 21 void InsertionSort(T *p, int len) 22 { 23 int line_up, wait;//line_up表示出列排队的总个数 24 //wait表示等待出列的索引位置 25 for(wait=1; wait<len; wait++) 26 { 27 T tem = p[wait]; 28 line

前言 为了巩固自己的算法能力，重学算法，一个一个自己写，敲。本文主要介绍Java八大排序经典算法。 1. 冒泡排序(BubbleSort) 1.1 基本思想 两个数比较大小，较大的数下沉，较小的数冒起来。 1.2 过程 1.3 算法实现 /** * @Description: 冒泡排序，优化版 平均时间复杂度：O(n^2) * @Date: 21:11 2019/8/7 * @Param: [arr] * @return: int[] */ static int [ ] BubbleSort ( int [ ] arr ) { boolean flag = false ; for ( int j = 1 ; j < arr . length ; j ++ ) { for ( int i = 0 ; i < arr . length - j ; i ++ ) { if ( arr [ i ] > arr [ i + 1 ] ) { int temp = arr [ i ] ; arr [ i ] = arr [ i + 1 ] ; arr [ i + 1 ] = temp ; flag = true ; } } if ( ! flag ) { break ; } } return arr ; } 2. 选择排序(SelctionSort) 2.1 基本思想

插入排序: 1).直接插入排序: 　　假设当前排序到了第i个元素arr[i],则此时i左侧[0,i-1]已经有序，对于arr[i]来说，如果arr[i]>=arr[i-1]，则不用排序，直接进入[i+1];否则要在左侧有序表中找到一个合适的位置j令arr[j]<=arr[i]<arr[j+1]。 每一趟插入排序，令当前有序表的长度增加1，直至有序长度等于数组长度。 class Solution { public: void InsertSort(vector<int>& arr){ if(arr.empty()) return; for(int i=1;i<arr.size();i++) { if(arr[i]<arr[i-1]) { int tmp=arr[i]; arr[i]=arr[i-1]; int j=i-2; for(;j>=0&&arr[j]>tmp;j--) arr[j+1]=arr[j]; arr[j+1]=tmp; } } return; } }; 2).折半插入排序: 　　和普通的直接插入排序相比，折半插入排序利用了左侧有序表的特性，利用折半查找减少了查询次数，但移动次数仍然未改变。 class Solution { public: void BInsertSort(vector<int>& arr){ if(arr.empty()) return; for

希尔排序 不断缩小增量的插入排序 原理 以某个增量h为步长跳跃分组进行插入排序，增量是一个从h逐渐缩小至1的过程，所以又称缩小增量排序。 其核心在于间隔序列设定，是与插入排序的本质区别。插入排序始终增量为1。 最佳增量: k趟排序增量步长为(2^k)-1,即增量序列(2^k)-1,…15,7,3,1 分析 时间复杂度：nlogn 代码 void shellsort(int a[],int len){ int gap = len; while(gap = gap/2){//增量 for(int i=gap;i<len;i++){//下面的就是插入排序，间距为gap int key=a[i]; int j=i-gap; while(j>=0 && a[j]>key){ a[j+gap] = a[j]; j-=gap; } a[j+gap] = key; } } } 来源： https://www.cnblogs.com/pacino12134/p/11325068.html

接下来的几篇博客都是关于排序的；主要有插入类排序；交换类排序；选择类排序； 插入类排序主要有直接插入如排序（straight insertion sort）；折半插入排序（bianry insertion sort）; Shell sort; 交换类排序主要有冒泡排序（bubble sort）; 快速排序（quick sort）; 选择类排序主要有；简单选择排序（simple selection sort）; 堆排序（heap sort）; 除此之外还有归并排序（merge sort）; 基数排序等； 本篇博客是关于折半插入排序的； 排序直接的数据结构介绍； 所有的排序均以线性表存储；所有的排序算法避免不了交换；交换就要用到临时变量；故将线性表中编号为0的元素不存储任何有效元素；仅仅当做临时变量或者记录的作用来使用； 对于有些算法我会给出局部变量做临时变量的算法 ；若对线性表不是很了解；参见前面关于线性表的博客； 算法大致介绍； 将待排序的序列分成两个序列；将后一个序列中的元素通过比较、移动、插入的上一个序列；当所有元素都插入完成时；排序完成； 头文件（sort.h）； # ifndef _SORT_ typedef int KeyType; typedef struct { KeyType key; }DataType; # endif 头文件（SeqList.h）；

1.插入排序 插入排序是比较简单粗暴的排序算法之一，它的思路大致如下： 把待排序数组分成两部分，长度为1和长度为n-1的子数组，（长度为1的子数组此时已经是排序好的） 从第二个数组中按序拿出一个元素，并插入到第一个子数组的合适位置，使得第一个子数组依然是排好序的 重复步骤2，直至排序完成。 它的代码相对也比较简单，如下： /** * 插入排序 * @param nums: 待排序数组 * @param len: 数组的长度 */ template<class Type> void insert_sort(Type nums[], int len) { for (int j = 1; j < len; j++) { Type key = nums[j]; int i = j - 1; //为该元素找到一个合适的位置，并插入 while (i >= 0 && nums[i] > key) { nums[i + 1] = nums[i]; i = i - 1; } nums[i + 1] = key; } } 接下来举个简单的例子： 假设待排序数组为{8, 2, 4, 9, 3, 6} 初始分成了{8} {2, 4, 9, 3, 6} 第一次 => {2, 8} {4, 9, 3, 6} 第二次 => {2, 4, 8} {9, 3, 6} 第三次 => {2, 4, 8, 9} {3,