插入排序（解析及代码实现 二分优化）

最新推荐文章于 2023-03-06 15:54:28 发布
最新推荐文章于 2023-03-06 15:54:28 发布
阅读量482 收藏
点赞数 1
分类专栏： 常用的几种排序方法 文章标签： 插入排序 排序算法 Tag
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jrdgogo/article/details/50801817
版权 

public void eliminateinsertSort2(int[] a,int type){
		for (int i = 0; i < a.length-1; i++) {
			int temp=a[i+1];
			int j=i;
			if (type==0) {//从小到大
				while (a[j] > temp) {//循环，找到位置
					a[j+1]=a[j];//大数后移
					j--;
					if(j<0)
						break;
				}
				a[j+1]=temp;//插入
			}else{//从大到小
				while (a[j] < temp) {
					a[j+1]=a[j];//小数后移
					j--;
					if(j<0)
						break;
				}
				a[j+1]=temp;
			}
		}
	}

//利用二分搜索优化插排
	
	//插排 前面是有序序列，从后往前一个个比较太慢
	//对于大量数据来说，慢，采用二分，快速定位位置
	public void insertSort(double[] a,int type){
<span style="white-space:pre">		</span>for (int i = 0; i < a.length-1; i++) {
<span style="white-space:pre">			</span>double temp=a[i+1];
<span style="white-space:pre">			</span>int left=0;
<span style="white-space:pre">			</span>int right=i;
<span style="white-space:pre">			</span>while(left<=right){//定位
<span style="white-space:pre">				</span>int mid=(left+right)/2;
<span style="white-space:pre">				</span>if(temp>a[mid]){
<span style="white-space:pre">					</span>if(type==0){
<span style="white-space:pre">						</span>left=mid+1;
<span style="white-space:pre">					</span>}else{
<span style="white-space:pre">						</span>right=mid-1;
<span style="white-space:pre">					</span>}
<span style="white-space:pre">				</span>}else{
<span style="white-space:pre">					</span>if(type==0){
<span style="white-space:pre">						</span>right=mid-1;
<span style="white-space:pre">					</span>}else{
<span style="white-space:pre">						</span>left=mid+1;
<span style="white-space:pre">					</span>}
<span style="white-space:pre">				</span>}
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>//移动
<span style="white-space:pre">			</span>for (int j = i; j >= right+1; j--) {
<span style="white-space:pre">				</span>a[j+1]=a[j];
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>//插入
<span style="white-space:pre">			</span>a[right+1]=temp;
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>
<span style="white-space:pre">	</span>}

以下是完整代码，实现重载：

package cn.hncu.sort;

public class InsertSort {
	
	//整个排序数列分为有序前列和无序后列
	//将每一个无序后列中的数与前面有序数列倒序一一对比，插入相应位置
	
	//第一种
	public void eliminateinsertSort(int[] a,int type){
		
		//每次循环前0 - i+1 位数据有序
		for (int i = 0; i < a.length-1; i++) {
			int temp=a[i+1];//对a[i+1]排序位子
			boolean isInsertSort=false;
			for (int j = i; j >= 0; j--) {
				if(type==0){//从小到大排
					if(temp<a[j])//大数向后移动
						a[j+1]=a[j];
					else{
						a[j+1]=temp;//插入
						isInsertSort=true;
					}
				}else{//从大到小排
					if(temp>a[j])//小数向后移动
						a[j+1]=a[j];
					else{
						a[j+1]=temp;//插入
						isInsertSort=true;
					}
				}
				if(isInsertSort)//插入时break
					break;
			}
			if(!isInsertSort)//当前面皆为小数/大数时 未发生插入，则放第一个
				a[0]=temp;
		}
	}

	//优化
	public void eliminateinsertSort2(int[] a,int type){
		for (int i = 0; i < a.length-1; i++) {
			int temp=a[i+1];
			int j=i;
			if (type==0) {//从小到大
				while (a[j] > temp) {//循环，找到位置
					a[j+1]=a[j];//大数后移
					j--;
					if(j<0)
						break;
				}
				a[j+1]=temp;//插入
			}else{//从大到小
				while (a[j] < temp) {
					a[j+1]=a[j];//小数后移
					j--;
					if(j<0)
						break;
				}
				a[j+1]=temp;
			}
		}
	}
	//利用二分搜索优化插排
<span style="white-space:pre">	</span>//插排 前面是有序序列，从后往前一个个比较太慢
<span style="white-space:pre">	</span>//对于大量数据来说，慢，采用二分，快速定位位置
<span style="white-space:pre">	</span>public void insertSort(double[] a,int type){
<span style="white-space:pre">		</span>for (int i = 0; i < a.length-1; i++) {
<span style="white-space:pre">			</span>double temp=a[i+1];
<span style="white-space:pre">			</span>int left=0;
<span style="white-space:pre">			</span>int right=i;
<span style="white-space:pre">			</span>while(left<=right){//定位
<span style="white-space:pre">				</span>int mid=(left+right)/2;
<span style="white-space:pre">				</span>if(temp>a[mid]){
<span style="white-space:pre">					</span>if(type==0){
<span style="white-space:pre">						</span>left=mid+1;
<span style="white-space:pre">					</span>}else{
<span style="white-space:pre">						</span>right=mid-1;
<span style="white-space:pre">					</span>}
<span style="white-space:pre">				</span>}else{
<span style="white-space:pre">					</span>if(type==0){
<span style="white-space:pre">						</span>right=mid-1;
<span style="white-space:pre">					</span>}else{
<span style="white-space:pre">						</span>left=mid+1;
<span style="white-space:pre">					</span>}
<span style="white-space:pre">				</span>}
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>//移动
<span style="white-space:pre">			</span>for (int j = i; j >= right+1; j--) {
<span style="white-space:pre">				</span>a[j+1]=a[j];
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>//插入
<span style="white-space:pre">			</span>a[right+1]=temp;
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>public void insertSort2(double[] a,int type){
<span style="white-space:pre">		</span>//一样,第0位有序，对1~a.length-1进行插排
<span style="white-space:pre">		</span>for (int i = 0; i < a.length-1; i++) {
<span style="white-space:pre">			</span>double temp=a[i+1];
<span style="white-space:pre">			</span>//开始二分定位
<span style="white-space:pre">			</span>int k=pitch(a,0,i,temp,type);
<span style="white-space:pre">			</span>for (int j = i+1; j >k; j--) {
<span style="white-space:pre">				</span>a[j]=a[j-1];
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>a[k]=temp;
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}
	//a[first]<...<a[k]<...<a[end]
	//first~end有序，a[k]定位
	private int pitch(double[] a, int first, int end, double temp,int type) {
		
		int min=(first+end)/2;
		if(type==0){//从小到大排
			//二分的最终结果只有二种
			//所在一侧有俩个数或一个数
			
			//当有俩个数时，
			//要么比first小，则确定位置
			if(first==end-1){
				if(a[first]>temp)
					return first;
				//否则递归至下一次 first==end处理
			}
			//当有一个数时first==end
			//此时要么比first大，返回+1，否则first
			else if(first==end){
				if(a[first]>temp)
					return first;
				else
					return first+1;
			}
			if(a[min]>temp)//temp在a数组a[min]之前
				return pitch(a,first,min-1,temp,type);
			else//temp在a数组a[min]之后
				return pitch(a,min+1,end,temp,type);
		}else{//从大到小排
			if(first==end-1){
				if(a[first]<temp)
					return first;
			}
			else if(first==end){
				if(a[first]<temp)
					return first;
				else
					return first+1;
			}
			if(a[min]<temp)
				return pitch(a,first,min-1,temp,type);
			else
				return pitch(a,min+1,end,temp,type);
		}
	}

	//默认从小到大排
	public void insertSort(double[] a){
		insertSort(a,0);
	}

	//对某一段排序
	public boolean insertSort(double[] a,int first,int end,int type){
		if(first<=0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		double[] b=new double[end-first+1];
		System.arraycopy(a, first, b, 0, b.length);
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[first+i]=b[i];
		}
		return true;
	}
	public boolean insertSort(double[] a,int first,int end){
		return insertSort(a, first, end, 0);
	}
	
	//float[]数组
	public void insertSort(float[] a,int type){
		double[] b=new double[a.length];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i];
		}
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[i]=(float)b[i];
		}
	}
	public void insertSort(float[] a){
		insertSort(a, 0);
	}
	public boolean insertSort(float[] a,int first,int end,int type){
		if(first<=0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		float[] b=new float[end-first+1];
		System.arraycopy(a, first, b, 0, b.length);//截取
		insertSort(b, type);//排序
		for (int i = 0; i < b.length; i++) {//放回
			a[first+i]=b[i];
		}
		return true;
	}
	public boolean insertSort(float[] a,int first,int end) {
		return insertSort(a, first, end, 0);
	}
	//long[]数组
	public void insertSort(long[] a,int type){
		double[] b=new double[a.length];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i];
		}
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[i]=(long)b[i];
		}
	}
	public void insertSort(long[] a){
		insertSort(a, 0);
	}
	public boolean insertSort(long[] a,int first,int end,int type){
		if(first<=0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		long[] b=new long[end-first+1];
		System.arraycopy(a, first, b, 0, b.length);
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[first+i]=b[i];
		}
		return true;
	}
	public boolean insertSort(long[] a,int first,int end) {
		return insertSort(a, first, end, 0);
	}
	//int[]数组
	public void insertSort(int[] a,int type){
		double[] b=new double[a.length];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i];
		}
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[i]=(int)b[i];
		}
	}
	public void insertSort(int[] a){
		insertSort(a, 0);
	}
	public boolean insertSort(int[] a,int first,int end,int type){
		if(first<=0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		int[] b=new int[end-first+1];
		System.arraycopy(a, first, b, 0, b.length);
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[first+i]=b[i];
		}
		return true;
	}
	public boolean insertSort(int[] a,int first,int end) {
		return insertSort(a, first, end, 0);
	}
	//short[]数组
	public void insertSort(short[] a,int type){
		double[] b=new double[a.length];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i];
		}
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[i]=(short)b[i];
		}
	}
	public void insertSort(short[] a){
		insertSort(a, 0);
	}
	public boolean insertSort(short[] a,int first,int end,int type){
		if(first<=0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		short[] b=new short[end-first+1];
		System.arraycopy(a, first, b, 0, b.length);
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[first+i]=b[i];
		}
		return true;
	}
	public boolean insertSort(short[] a,int first,int end) {
		return insertSort(a, first, end, 0);
	}
	//byte[]数组
	public void insertSort(byte[] a,int type){
		double[] b=new double[a.length];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i];
		}
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[i]=(byte)b[i];
		}
	}
	public void insertSort(byte[] a){
		insertSort(a, 0);
	}
	public boolean insertSort(byte[] a,int first,int end,int type){
		if(first<=0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		byte[] b=new byte[end-first+1];
		System.arraycopy(a, first, b, 0, b.length);
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[first+i]=b[i];
		}
		return true;
	}
	public boolean insertSort(byte[] a,int first,int end) {
		return insertSort(a, first, end, 0);
	}
	//char[]数组
	public void insertSort(char[] a,int type){
		double[] b=new double[a.length];
		for (int i = 0; i < b.length; i++) {
			b[i]=a[i];
		}
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[i]=(char)b[i];
		}
	}
	public void insertSort(char[] a){
		insertSort(a, 0);
	}
	public boolean insertSort(char[] a,int first,int end,int type){
		if(first<=0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		char[] b=new char[end-first+1];
		System.arraycopy(a, first, b, 0, b.length);
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[first+i]=b[i];
		}
		return true;
	}
	public boolean insertSort(char[] a,int first,int end) {
		return insertSort(a, first, end, 0);
	}
	//String[]数组
	public void insertSort(String[] a,int type){
<span style="white-space:pre">		</span>for (int i = 0; i < a.length-1; i++) {
<span style="white-space:pre">			</span>String temp=a[i+1];
<span style="white-space:pre">			</span>int left=0;
<span style="white-space:pre">			</span>int right=i;
<span style="white-space:pre">			</span>while(left<=right){
<span style="white-space:pre">				</span>int mid=(left+right)/2;
<span style="white-space:pre">				</span>if(temp.compareTo(a[mid])>0){
<span style="white-space:pre">					</span>if(type==0){
<span style="white-space:pre">						</span>left=mid+1;
<span style="white-space:pre">					</span>}else{
<span style="white-space:pre">						</span>right=mid-1;
<span style="white-space:pre">					</span>}
<span style="white-space:pre">				</span>}else{
<span style="white-space:pre">					</span>if(type==0){
<span style="white-space:pre">						</span>right=mid-1;
<span style="white-space:pre">					</span>}else{
<span style="white-space:pre">						</span>left=mid+1;
<span style="white-space:pre">					</span>}
<span style="white-space:pre">				</span>}
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>for (int j = i; j >= right+1; j--) {
<span style="white-space:pre">				</span>a[j+1]=a[j];
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>a[right+1]=temp;
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}

	//默认从小到大排
	public void insertSort(String[] a){
		insertSort(a,0);
	}

	//对某一段排序
	public boolean insertSort(String[] a,int first,int end,int type){
		if(first<=0)
			return false;
		if(end>=a.length)
			return false;
		if(first>end)
			return false;
		String[] b=new String[end-first+1];
		System.arraycopy(a, first, b, 0, b.length);
		insertSort(b, type);
		for (int i = 0; i < b.length; i++) {
			a[first+i]=b[i];
		}
		return true;
	}
	public boolean insertSort(String[] a,int first,int end){
		return insertSort(a, first, end, 0);
	}
	//交换
	private void swap(int[] a, int j, int i) {
		//借助第三变量
		int temp=a[i];
		a[i]=a[j];
		a[j]=temp;
		//不借助第三变量
		//1
//				a[i]=a[i]+a[j];
//				a[j]=a[i]-a[j];
//				a[i]=a[i]-a[j];
		//2
//				a[i]=a[i]^a[j];
//				a[j]=a[i]^a[j];
//				a[i]=a[i]^a[j];
		
	}
	//输出
	private static void print(String[] a) {
		for (String x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(double[] a) {
		for (double x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(float[] a) {
		for (float x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(long[] a) {
		for (long x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(int[] a) {
		for (int x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(short[] a) {
		for (short x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(byte[] a) {
		for (byte x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
	private static void print(char[] a) {
		for (char x : a) {
			System.out.print(x+" ");
		}
		System.out.println();
	}
}



听听丶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现插入排序实例
09-03
以下是对Java实现插入排序的详细解析： 1. **算法步骤**： - 初始化：首先，定义一个整型数组`nums`，用于存储待排序的数据。 - 外层循环：遍历数组中的每个元素，从第一个元素开始，到倒数第二个元素结束。因为...
常见排序算法之二分插入排序算法
qq_43507104的博客
03-06 1530
1.算法思路 是在插入第i个元素时(i前面的元素必定是有序的)，对前面的0～i-1元素进行折半,先跟他们中间的那个元素比， 如果小，则对前半再进行折半，否则对后半进行折半， 直到left>right，然后再把第i个元素前1位与目标位置之间的所有元素后移， 再把第i个元素放在目标位置上。 2.特点分析 二分法直接插入排序算法是插入排序的升级版本， 但是时间复杂度和直接插入算法一样都是O(n²)...
二分插入法排序
qq_43213240的博客
03-06 946
二分插入排序法
插入排序及其优化
上道的程序员
07-28 5627
插入排序 直接插入排序 时间复杂度为O（n^2）稳定的排序元素移动是顺序的 在一个数组中，将第一个元素看作排序元素序列里的唯一元素，然后用临时变量tmp首先存放第二元素,即可在数组中空第二个元素位置（即此位置可被覆盖）， 将第二个元素与有序序列里面唯一一个元素进行比较，根据排序条件决定元素是否需要向后移动，然后有序序列元素加一，申请空间里面存放将要插进有序序列里面的元素； void Inser...
C语言排序方法-----二分插入排序
HXYDJ的博客
04-03 7479
由于在直接插入排序过程中，待插入数据左边的序列总是有序的，针对有序序列，就可以用二分法去插入数据了，也就是二分入排序法。适用于数据量比较大的情况。 二分插入排序的算法思想是： （1）计算 0 ~ i-1 的中间点，用 i 索引处的元素与中间值进行比较，如果 i 索引处的元素大，说明要插入的这个元素应该在中间值和刚加入i索引之间，反之，就是在刚开始的位置 到中间值的位置，这样...
排序算法之插入排序(带优化)
qq_53933886的博客
11-14 450
排序算法之插入排序(带优化)
基于Java实现各种基本排序及简单优化
最新发布
06-28
本文将详细解析标题“基于Java实现各种基本排序及简单优化”所涉及的知识点，并深入探讨每种排序算法的工作原理、实现方式以及可能的优化策略。 首先，我们来逐一分析这六种基本的排序算法： 1. **冒泡排序**：这...
c代码-直接插入排序
07-14
以上是对"直接插入排序"这一主题的详细解析，涵盖了算法原理、C语言编程基础、代码实现以及测试等方面。这个C代码实现能帮助学习者更好地理解直接插入排序的细节，并提供了一个实际的编程实践机会。
插入排序解析PPT学习教案.pptx
10-08
【插入排序解析】 排序是计算机科学中的一种基本操作，它涉及将一组无序的数据元素按照特定的顺序（通常是升序或降序）排列。插入排序是实现排序算法的一种简单但实用的方法，尤其适用于小规模或者部分有序的数据集...
java代码-插入排序算法的改进
07-16
下面是使用Java实现插入排序算法的一个例子，这里我们采用二分查找法来改进插入过程： ```java public class InsertionSort { public static void insertionSort(int[] arr) { for (int i = 1; i ; i++) { int ...
排序算法 | 插入排序算法原理及实现和优化
挖坑埋你
10-23 5565
插入排序算法是所有排序方法中最简单的一种算法，其主要的实现思想是将数据按照一定的顺序一个一个的插入到有序的表中，最终得到的序列就是已经排序好的数据。 直接插入排序是插入排序算法中的一种，采用的方法是：在添加新的记录时，使用顺序查找的方式找到其要插入的位置，然后将新记录插入。 很多初学者所说的插入排序，实际上指的就是直接插入排序算法，插入排序算法还包括折半插入排序、2-路插入排序，表插入排序和希尔...
二分查找及其优化
weixin_59369584的博客
02-21 877
二分查找及其优化
排序算法 - 二分插入排序、希尔排序（插入排序的优化）
it_lihongmin的博客
03-02 982
目录 1、二分插入排序 2、希尔排序 上一篇博客分析了时间复杂度为O(N²)的三种排序方式，并且基于稳定特性的插入排序和冒泡排序做了性能对比，当数据量级比较小的使用经常会选择插入排序。然而插入排序本身还可以进行优化，让其性能进一步提升，二分插入排序和希尔排序都是在普通插入排序的基础上进一步优化。 1、二分插入排序 插入排序本身就是往后遍历，每次轮训都会把前N个元素排好序，然后再将N+1个元素插入已经排好序的“子数组”里面。直接插入排序判断往哪个下标位置插入时，是遍历了整个子数组，在...
十大经典排序算法之插入排序及其二分优化
Kevinnsm的博客
03-05 884
一、插入排序的实现 1.什么是插入排序呢 插入排序的工作方式像许多人排序一手扑克牌。开始时，我们的左手为空并且桌子上的牌面向下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较。拿在左手上的牌总是排序好的，原来这些牌是桌子上牌堆中顶部的牌 2.具体步骤 第一轮：从第二位置的 6 开始比较，比前面 7 小，交换位置。 第二轮：第三位置的 9 比前一位置的 7 大，无需交换位置。 第三轮：第四位置的 3 比前一位置的 9 小交换
关于几种排序的白话总结+动图（码上方便自己回忆）
阳阳阳的博客
05-22 1781
                            对于排序算法的白话总结+动图   ps（多图预警） 一、理解 · 交换排序：冒泡排序、快速排序 1.冒泡排序：       挨个把最大值元素向右传递（比较相邻元素大小之后选择是否互换位置），传递一次排序完成一个，直至完成所有的排序（反之则传递最小值）。 2.快速排序：       先选择出一个基准，然后从左往右找到小于基准...
二分法插入排序
nrsc
09-06 6523
原理: 同直接插入排序一样,二分法插入排序的原理也是将一个待排序的数,插入到前面已经排好序的数组中,但是相比于直接插入排序来说,二分法插入排序是首先将新插入的数与前面已经排好序的数组中的中间那个数进行比较,如果比中间的数大就再在中间的数之后的数组中进行上诉比较,如果比中间的值小就再在中间的值之前的数组中进行上诉比较,直到找到待插入数的正确位置. 其实上面的原理对应两种情况(情况1,情况2),举...
插入排序与优化笔记
简国堂的博客
10-10 240
下面的方法中是属于插入排序，但是因为其调用的是交换函数,每次都进行交换就会耗费更高的资源 public static void sort(Comparable[] arr){ int n = arr.length; for (int i = 0; i < n; i++) { // 寻找元素arr[i]合适的插入位置 // 写法
排序算法（三）插入排序与其优化（python)
Demon_LMMan的博客
06-09 503
目录1 插入排序1.1 执行流程1.2 逆序对1.3 代码实现1.4 优化11.5 优化21.5.1 普通二分查找1.5.2 二分查找插入位置1.5.3 使用二分的插入排序1.6 时间空间复杂度 1 插入排序 插入排序与我们平时打扑克牌非常相似，将新摸到的牌插入到已有的牌中合适的位置，而已有的牌往往是有序的。 1.1 执行流程 （1）在执行过程中，插入排序会将序列分为2部分，头部是已经排好序的，尾部是待排序的。 （2）从头开始扫描每一个元素，每当扫描到一个元素，就将它插入到头部合
【从头学数据结构和算法】插入排序及其优化（c++实现）
ZhangDanzhu的博客
07-17 599
c++实现的插入排序及其优化 普通插入排序 优化1：二分查找找插入位置 优化2：希尔排序（分治） 测试 完整代码 普通插入排序 原理 每次取一个，按次在前面已排好序的区间中 依次比较找到第一个大于当前待排数据的位置，然后移动原有数据，插入新的数据。 基本性质 时间复杂度（主要是看移动次数） ——最好情况：O（n） ——最坏情况和平均：O（n^2） 空间复杂度 ——O（1）：原地排序 稳...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值