插入排序

package com.rao.linkList;import java.util.Arrays;/** * @author Srao * @className InsertSort * @date 2019/12/4 12:02 * @package com.rao.linkList * @Description 插入排序 */public class InsertSort { /** * 插入排序 * @param arr */ public static void insertSort(int[] arr){ for (int i = 1; i < arr.length; i++){ //先把要插入的数保存下来 int temp = arr[i]; int k = i-1; //找到第一个比它小的数的下标 while (k >=0 && arr[k] > temp){ k--; } //把较小的元素之前的元素全部后移一位，为要插入的元素空出一个位置 for (int j = i; j > k+1; j--){ arr[j] = arr[j-1]; } //插入这个元素到第一个比它小的元素的前面 arr[k+1] = temp; } } public static void main(String[] args) { int[] arr = new int[]{3,6,2,5

例22 插入排序 问题描述 排序是计算机程序设计中的一种重要操作，它的功能是将一个数据元素或记录的任意序列，重新排列成一个以关键字递增（或递减）排列的有序序列。 排序的方法有很多，简单插入排序就是一种简单的排序算法。 插入排序的基本思想是顺序将一个待排序的记录按其关键字值的大小插入到一个有序的序列中，插入后该序列仍然是有序的。 简单插入排序是一种最简单的排序方法。它的排序过程为：先将待排序序列中第1个记录看成是一个有序的子序列，然后从第2个记录起依次逐个地插入到这个有序的子序列中去。这很像玩扑克牌时一边抓牌一边理牌的过程，抓一张牌就插入到其应有的位置上去。 简单插入排序的排序过程如下图1所示。图1中方括号[ ]中为已排好序的记录关键字的子序列，下划线的关键字表示当前插入到有序子序列中的记录。 图1 简单插入排序的排序过程示例 编写一个程序，用简单插入排序方法将输入的N个整数按从小到大的顺序排列输出。 输入格式 第一行是一个正整数N (1 ≤ N ≤ 100000)，代表数组中元素的个数。 第二行有N个整数，表示待排序的N个数组元素。 输出格式 一行，有N个整数，这N个整数按从小到大的顺序排列输出。 输入样例 10 7 2 5 4 9 6 3 10 1 8 输出样例 1 2 3 4 5 6 7 8 9 10 （1）编程思路。 将整个数组（n个元素）看成是由有序的（a[0]，…，a[i

一、内排序 排序类别 排序方法 最好时间复杂度 平均时间复杂度 最坏时间复杂度 辅助空间 稳定性 备注 插入类 插入 O(n) O(n 2 ) O(n 2 ) O(1) 稳定 大部分已排序时较好 希尔排序 - O(n s )，1<s<2 - O(1) 不稳定 s是所选分组 交换类 冒泡排序 O(n) O(n 2 ) O(n 2 ) O(1) 稳定 n小时较好 快速排序 O(nlogn) O(nlogn) O(n 2 ) O(logn) 不稳定 n大时较好 选择类 选择 O(n 2 ) O(n 2 ) O(n 2 ) O(1) 不稳定 n小时较好 堆排序 O(nlogn) O(nlogn) O(nlogn) O(1) 不稳定 n大时较好 归并排序 O(nlogn) O(nlogn) O(nlogn) O(n) 稳定 n大时较好 基数排序 O(d(n+rd)) O(d(n+rd)) O(d(n+rd)) O(rd) 稳定 见下文 1．插入排序（InsertSort） 插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的

什么是插入排序 插入排序（Insertion Sort）是一种简单直观的排序算法。 通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 插入排序在实现上，在从后向前的扫描过程中，需要把已排序元素逐步向后挪位，为最新元素提供插入空间。 即 ： 先将前两个排序 再将前三个排序 前四个 … 一直到最末尾 算法1： def insertion_sort(list): n = len(list) for i in range(1,n): for j in range(i,0,-1): if list[j] < list[j-1]: list[j],list[j-1] = list[j-1],list[j] else: break return list 算法2： def insertion_sort(arr): """插入排序""" # 第一层for表示循环插入的遍数 for i in range(1, len(arr)): # 设置当前需要插入的元素 current = arr[i] # 与当前元素比较的比较元素 pre_index = i - 1 while pre_index >= 0 and arr[pre_index] > current: # 当比较元素大于当前元素则把比较元素后移 arr[pre_index + 1] = arr[pre

插入排序 存在序列A(a1,a2,a3,a4,.....,an)，n为有限值，经过插入排序后A序列： A(b1,b2,b3,......,bn) 中任意俩个元素满足: bi <= bj 有且只有0 < i <= j <=n，反之也成立。 插入排序的伪代码实现： for（i = 2； i < =n ; i++）{ // 每次需要插入的元素 key = ai; // 已经排序好元素的项数 j = i-1； while j > 0 and key < aj // 插入元素与排序好元素的每一项进行比较，若插入元素 < 排序好元素，将排序号元素的下标加1 即a(j+1) = aj a(j+1) = aj; j++ } 插入排序算法的时间 影响因素：项数 和 序列已经排序好程度 最好情况：序列已经排序好 ，时间复杂度 Θ(n)(n为项数) 最坏情况：序列按照反向排序好，时间复杂度 Θ(n 2 )(a和b、c为常数、n为项数) 来源： https://www.cnblogs.com/zhang-feng/p/11949120.html

a = [5,4,3,2,1] 1. 从第一个元素开始，该元素可以认为已经被排序 2. 取出下一个元素，在已经排序的元素序列中从后向前扫描 3. 如果该元素（已排序）大于新元素，将该元素移到下一位置 4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 5. 将新元素插入到该位置后 6. 重复步骤2~5 1：1位置开始比较，和他前面所有的数字进行比较，4和5比较，4<5所以4,5交换位置 [4,5,3,2,1] 2：2位置开始比较，和他前面所有的数字进行比较 4 3 5 2 3 4 5 2 3：3位置开始比较，和他前面所有的数字进行比较 3 4 5 2 3 4 2 5 3 2 4 5 2 3 4 5 排好序了。 依次把1坐标以后的所有元素，分别与它前面的元素进行比较 如果发生了小于的情况就插入。 原理：每次有一个数，它的前面都是排好序的，然后它要插入到 排好的序列中，插入排序 a=[3,6,1,8,4] ''' 1 [3][6] [3,6,1,8,4] 2 [3][6,1] [1,6,3] 3 [1][6,3,8] [1,6,3,8,4] 4 [1][6,3,8,4] [1,6,3,8,4]------>最小值排到了第一位，以此类推 [1,6,3,8,4] 1 [6][3] [3,6,8,4] 2 [3][6,8] [3,6,8,4] 3 [3][6,8,4] [3,6

来源： https://www.cnblogs.com/CPU-Easy/p/11918319.html

　　排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度： 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序。 O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序。 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。 关于稳定性： 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。 名词解释： n：数据规模 k：“桶”的个数 In-place：占用常数内存，不占用额外内存 Out-place：占用额外内存 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同 冒泡排序 　　冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

文件源于 : https://www.cnblogs.com/Jason-Xiang/p/8567751.html 排序算法 平均时间复杂度 冒泡排序 O(n2) 选择排序 O(n2) 插入排序 O(n2) 希尔排序 O(n1.5) 快速排序 O(N*logN) 归并排序 O(N*logN) 堆排序 O(N*logN) 基数排序 O(d(n+r)) 一. 冒泡排序(BubbleSort) 基本思想： 两个数比较大小，较大的数下沉，较小的数冒起来。 过程： 比较相邻的两个数据，如果第二个数小，就交换位置。 从后向前两两比较，一直到比较最前两个数据。最终最小数被交换到起始的位置，这样第一个最小数的位置就排好了。 继续重复上述过程，依次将第2.3...n-1个最小数排好位置。 平均时间复杂度： O(n2) java代码实现： public static void BubbleSort(int [] arr){ int temp;//临时变量 for(int i=0; i<arr.length-1; i++){ //表示趟数，一共arr.length-1次。 for(int j=arr.length-1; j>i; j--){ if(arr[j] < arr[j-1]){ temp = arr[j]; arr[j] = arr[j-1]; arr[j-1] = temp; } } } }

直接插入排序 ，是一种最简单也是最直观的插入排序算法。直接插入排序算法适用于 基本有序 的排序表和 数据量不大 的排序表 其 思想 是： 假设数组由 有序 部分和 无序 部分组成，前半部分为有序，后半部分为无序，假设有表 L [ N ]，在某一状态存在如图所示： 则此时，需要将 L [ i ] 插入到数组的有序部分，算法为：将 L [ 0 ] 设为哨兵，从 i - 1 开始向前逐个查询，并同时交换数组元素，最终找到插入位置时，将元素插入。 算法存储结构适用性 ：直接插入排序适用于 顺序存储结构 和 链式存储结构 ，顺序存储结构，是随机访问，使得倒着访问成为可能，而链式存储结构，如果是单链表的话，则需要从前向后查找，如果为双向链表的话，则与顺序存储结构无异，唯一的不同，是注意指针 算法实现 /* 直接插入排序： 时间复杂度->最好情况:O(n)、平均情况:O(n^2)、最坏情况:O(n^2) 空间复杂度->O(1) 是否稳定：是 复杂性：简单 */ #include<bits/stdc++.h> using namespace std; typedef struct{ int key; }ElemType;//定义类型 void InsertSort(ElemType A[],int n){//升序排列 int i,j; for(int i=2;i<=n;i++){/