包含插入排序算法的词条

本篇文章给大家谈谈插入排序算法，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、插入排序法是什么??
• 2、c语言插入法排序的算法步骤
• 3、C语言的插入排序法是什么？
• 4、简单插入排序
• 5、常见的排序算法—选择，冒泡，插入，快速，归并

插入排序法是什么??

排序

排序(Sorting)的基本功能是依某种条件将资料项目按顺序排列,例如依照数字的大小由

小至大排列,或是按笔画顺序排列姓名 .

插入排序法 :

所谓插入排序法乃是将一个数目插入该占据的位置.假设我们输入的是

5,1,4,2,3

我们从第二个数字开始,这个数字是1,我们的任务只要看看1有没有正确的位置,我

们的做法是和这个数字左边的数字来比,因此我们比较1和5,1比5小,所以我们就交

换1和5,原来的排列就变成了

1,5,4,2,3

接下来,我们看第3个数字有没有在正确的位置.这个数字是4,它的左边数字是5,4

比5小,所以我们将4和5交换,排列变成了

1,4,5,2,3

我们必须继续看4有没有在正确的位置,4的左边是1,1比4小,4就维持不动了.

再来看信闹银第四个数字,这个数字是2,我们将2和它左边的数字相比,都比2大,所滑宴以就

将2一路往左移动,一直移到2的左边是1,这时候排序变成了

1,2,4,5,3

最后,我们检查第五个数字,这个数字是3,3必须往左移弯雹,一直移到3的左边是2为止,

所以我们的排列就变成了

1,2,3,4,5

排序因此完成了.

所谓插入排序法,就是检查第i个数字,如果在它的左边的数字比它大,进行交换,这

个动作一直继续下去,直到这个数字的左边数字比它还要小,就可以停止了.

插入排序法主要的回圈有两个变数:i和j,每一次执行这个回圈,就会将第i个数字放

到左边恰当的位置去.

时间复杂度： O(n的平方)

c语言插入法排序的算法步骤

算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如樱槐下：

从第一个元素开始，该元素可以认为已经被排肆镇序

取出下一个元素，在已经排序的元素序列中从后向前扫描

如果该元素（已排序）大于新元素，将该元素移到下一位置

重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

将新元素插入脊雹友到该位置后

重复步骤2~5

如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找排序。

范例程式码

void insertion_sort(int array[], int first, int last)

{

int i,j;

int temp;

for (i = first+1; i=last;i++)

{

temp = array[i];

j=i-1;

while((j=first) (array[j] temp))

{

array[j+1] = array[j];

　j--;

}

array[j+1] = temp;

}

}

C语言的插入排序法是什么？

插入排序(insertion sort)

如果需要对一个小型数组进行升序排列，那么可以选用插入排序，插入排序可以用打牌时对摸起的牌根据牌的点数来对其进行插入排列来描述。

可以把左手中的牌比做已经摸起的牌，即已经被排列好的牌，左手可以容纳的牌数的空间可以假想为和要摸的牌的总数相同；而在桌子上的那部分没摸的牌则是未被排序的牌，这二者的关系可以抽象为数组中已经被排序好的部分和未被排序好的部分。

一开始摸起的第一张牌不需要排序，可以认定其为已排序的牌。

如果用外层循环for来表示摸起的牌的话，则可以抽象为：

// 对象数组

// 桌子上的牌

int A[] = {5,1,3,6,2,4};

// 从数组的第二个元素开始抽取

for(int i = 1; i sizeof A/sizeof A[0]; ++i)

{

int pick = A[i]; // 被摸起的牌

int j = i - 1; // j记录已排序部分的最后一张牌的位置

. . .

}

而后摸起的排要根据排列策略和先前摸起的牌的点数的大小来确定其插入的合适位置，这里示范的排列策略是升序排列，摸起了这张牌后，便自右向左地和手中的牌进行比较。

把pick称作摸起的牌，如果pick比手中的牌小，则手中较大的那张牌就向右挪一位，pick再和下一张牌做隐野比较，如果下一张牌困郑仍然比pick大，那么那张牌便也向右移动一个位置，依此类推。

如果手中下一张和pick比较的牌比pick小，那么pick就被插入在了手中前一张牌移动后空下的位置；

或者手中所有的牌都比pick大，那么所有的牌就都向右移动过一个位置，所以pick最终被插入在了手中最左边的位置。

这个过程可以抽象为：

// 对象数组

// 桌子上的牌

int A[] = {5,1,3,6,2,4};

// 从数组的第二灶尺喊个元素开始抽取

for(int i = 1; i sizeof A/sizeof A[0]; ++i)

{

int pick = A[i]; // 被摸起的牌

int j = i - 1; // j记录已排序部分的最后一张牌的位置

// 如果循环了j+1次，即j = -1时还未找到比pick小的牌

// 那么pick就是最小的牌被插入在位置A[0]处

// A[j]是当前手中和pick进行比较的牌

while(j = 0 A[j] pick)

{

// 未找到可插入位置，则A[j]向后挪一位

A[j+1] = A[j];

// j减1继续向左定位手中下一张供和pick比较的牌--j;

}

// while结束后，j+1所表达的位置便是pick可以插入的位置

A[j+1] = pick;

}

// 对于有N个元素的数组A，采用插入排序法排序时，当外层循环进行了N-1次后排序完毕

[img]

简单插入排序

简单插入排序是指把表分成两部分，前半部分已排序，后半部分未排序，最坏情况需要n（n-1）/2次比较。

排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

常见的内部排序算法有戚陆迹：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。以下是插入排序算法：  插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理悉段应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。

插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位高并置并插入。  插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

常见的排序算法—选择，冒泡，插入，快速，归并

太久没看代码了，最近打算复习一下java，又突然想到了排序算法，就把几种常见的排序算法用java敲了一遍，这里统一将无序的序列从小到大排列。

选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小元素，继续放在下一个位置，直到待排序元素个数为0。

选择排序代码如下：

public void Select_sort(int[] arr) {

int temp,index;

for( int i=0;i10;i++) {

index = i;

for(int j = i + 1 ; j 乱山 10 ; j++) {

if(arr[j] arr[index])

index = j;

}

/*

temp = arr[i];

arr[i] = arr[index];

arr[index] = temp;

*/

swap(arr,i,index);

}

System.out.print("经过选择排序后：");

for(int i = 0 ; i 10 ; i++)

System.out.print( arr[i] +" ");

System.out.println("");

}

冒泡排序是一种比较基础的排序算法，其思想是相邻的元素两两比较，较大的元素放后面，较小的元素放前面，这样一次循环下来，最大元素就会归位，若数组中元素个数为n，则经过（n-1）次后，所有元素就依次从小到大排好序了。整个过程如同气泡冒起，因此被称作冒泡排序。

选择排序代码如下：

public void Bubble_sort(int[] arr) {

int temp;

for(int i = 0 ; i 9 ; i++) {

for(int j = 0 ; j 10 - i - 1 ;j++) {

if(arr[j] arr[j+1]) {

/*

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

*/

swap(arr,j,j+1);

}

}

}

System.out.print("经过冒泡排序后：");

for(int i = 0 ; i 哗侍中 10 ; i++)

System.out.print( arr[i] +" ");

System.out.println("");

}

插入排序也是一种常见的排序算法，插入谈咐排序的思想是：创建一个与待排序数组等大的数组，每次取出一个待排序数组中的元素，然后将其插入到新数组中合适的位置，使新数组中的元素保持从小到大的顺序。

插入排序代码如下：

public void Insert_sort(int[] arr) {

int length = arr.length;

int[] arr_sort = new int[length];

int count = 0;

for(int i = 0;i length; i++) {

if(count == 0) {

arr_sort[0] = arr[0];

}else if(arr[i] = arr_sort[count - 1]) {

arr_sort[count] = arr[i];

}else if(arr[i] arr_sort[0]) {

insert(arr,arr_sort,arr[i],0,count);

}else {

for(int j = 0;j count - 1; j++) {

if(arr[i] = arr_sort[j] arr[i] arr_sort[j+1]) {

insert(arr,arr_sort,arr[i],j+1,count);

break;

}

}

}

count++;

}

System.out.print("经过插入排序后：");

for(int i = 0 ; i 10 ; i++)

System.out.print( arr_sort[i] +" ");

System.out.println("");

}

public void insert(int[] arr,int[] arr_sort,int value,int index,int count) {

for(int i = count; i index; i--)

arr_sort[i] = arr_sort[i-1];

arr_sort[index] = value;

}

快速排序的效率比冒泡排序算法有大幅提升。因为使用冒泡排序时，一次外循环只能归位一个值，有n个元素最多就要执行（n-1）次外循环。而使用快速排序时，一次可以将所有元素按大小分成两堆，也就是平均情况下需要logn轮就可以完成排序。

快速排序的思想是：每趟排序时选出一个基准值（这里以首元素为基准值），然后将所有元素与该基准值比较，并按大小分成左右两堆，然后递归执行该过程，直到所有元素都完成排序。

public void Quick_sort(int[] arr, int left, int right) {

if(left = right)

return ;

int temp,t;

int j = right;

int i = left;

temp = arr[left];

while(i j) {

while(arr[j] = temp i j)

j--;

while(arr[i] = temp i j)

i++;

if(i j) {

t = arr[i];

arr[i] = arr[j];

arr[j] = t;

}

}

arr[left] = arr[i];

arr[i] = temp;

Quick_sort(arr,left, i - 1);

Quick_sort(arr, i + 1, right);

}

归并排序是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，每两个小分组合并成一个大的分组，逐层进行，最终所有的元素都是有序的。

public void Mergesort(int[] arr,int left,int right) {

if(right - left 0) {

int[] arr_1 = new int[(right - left)/2 + 1];

int[] arr_2 = new int[(right - left + 1)/2];

int j = 0;

int k = 0;

for(int i = left;i = right;i++) {

if(i = (right + left)/2) {

arr_1[j++] = arr[i];

}else {

arr_2[k++] = arr[i];

}

}

Mergesort(arr_1,0,(right - left)/2);

Mergesort(arr_2,0,(right - left - 1)/2);

Merge(arr_1,arr_2,arr);

}

}

public void Merge(int[] arr_1,int[] arr_2,int[] arr) {

int i = 0;

int j = 0;

int k = 0;

int L1 = arr_1.length;

int L2 = arr_2.length;

while(i L1 j L2) {

if(arr_1[i] = arr_2[j]) {

arr[k] = arr_1[i];

i++;

}else {

arr[k] = arr_2[j];

j++;

}

k++;

}

if(i == L1) {

for(int t = j;j L2;j++)

arr[k++] = arr_2[j];

}else {

for(int t = i;i L1;i++)

arr[k++] = arr_1[i];

}

}

归并排序这里我使用了left，right等变量，使其可以通用，并没有直接用数字表示那么明确，所以给出相关伪代码，便于理解。

Mergesort(arr[0...n-1])

//输入：一个可排序数组arr[0...n-1]

//输出：非降序排列的数组arr[0...n-1]

if n1

copy arr[0...n/2-1] to arr_1[0...(n+1)/2-1]//确保arr_1中元素个数=arr_2中元素个数

//对于总个数为奇数时，arr_1比arr_2中元素多一个；对于总个数为偶数时，没有影响

copy arr[n/2...n-1] to arr_2[0...n/2-1]

Mergesort(arr_1[0...(n+1)/2-1])

Mergesort(arr_2[0...n/2-1])

Merge(arr_1,arr_2,arr)

Merge(arr_1[0...p-1],arr_2[0...q-1],arr[0...p+q-1])

//输入：两个有序数组arr_1[0...p-1]和arr_2[0...q-1]

//输出：将arr_1与arr_2两数组合并到arr

int i-0;j-0;k-0

while i

p span="" do="" j

if arr_1[i] = arr_2[j]

arr[k] - arr_1[i]

i-i+1

else arr[k] - arr_2[j];j-j+1

k-k+1

if i=p

copy arr_2[j...q-1] to arr[k...p+q-1]

else copy arr_1[i...p-1] to arr[k...p+q-1]

package test_1;

import java.util.Scanner;

public class Test01 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int[] arr_1 = new int[10];

for(int i = 0 ; i 10 ; i++)

arr_1[i] = sc.nextInt();

Sort demo_1 = new Sort();

//1~5一次只能运行一个，若多个同时运行，则只有第一个有效，后面几个是无效排序。因为第一个运行的已经将带排序数组排好序。

demo_1.Select_sort(arr_1);//-----------------------1

//demo_1.Bubble_sort(arr_1);//---------------------2

/* //---------------------3

demo_1.Quick_sort(arr_1, 0 , arr_1.length - 1);

System.out.print("经过快速排序后：");

for(int i = 0 ; i 10 ; i++)

System.out.print( arr_1[i] +" ");

System.out.println("");

*/

//demo_1.Insert_sort(arr_1);//--------------------4

/* //--------------------5

demo_1.Mergesort(arr_1,0,arr_1.length - 1);

System.out.print("经过归并排序后：");

for(int i = 0 ; i 10 ; i++)

System.out.print( arr_1[i] +" ");

System.out.println("");

*/

}

}

class Sort {

public void swap(int arr[],int a, int b) {

int t;

t = arr[a];

arr[a] = arr[b];

arr[b] = t;

}

public void Select_sort(int[] arr) {

int temp,index;

for( int i=0;i10;i++) {

index = i;

for(int j = i + 1 ; j 10 ; j++) {

if(arr[j] arr[index])

index = j;

}

/*

temp = arr[i];

arr[i] = arr[index];

arr[index] = temp;

*/

swap(arr,i,index);

}

System.out.print("经过选择排序后：");

for(int i = 0 ; i 10 ; i++)

System.out.print( arr[i] +" ");

System.out.println("");

}

public void Bubble_sort(int[] arr) {

int temp;

for(int i = 0 ; i 9 ; i++) {

for(int j = 0 ; j 10 - i - 1 ;j++) {

if(arr[j] arr[j+1]) {

/*

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

*/

swap(arr,j,j+1);

}

}

}

System.out.print("经过冒泡排序后：");

for(int i = 0 ; i 10 ; i++)

System.out.print( arr[i] +" ");

System.out.println("");

}

public void Quick_sort(int[] arr, int left, int right) {

if(left = right)

return ;

int temp,t;

int j = right;

int i = left;

temp = arr[left];

while(i j) {

while(arr[j] = temp i j)

j--;

while(arr[i] = temp i j)

i++;

if(i j) {

t = arr[i];

arr[i] = arr[j];

arr[j] = t;

}

}

arr[left] = arr[i];

arr[i] = temp;

Quick_sort(arr,left, i - 1);

Quick_sort(arr, i + 1, right);

}

public void Insert_sort(int[] arr) {

int length = arr.length;

int[] arr_sort = new int[length];

int count = 0;

for(int i = 0;i length; i++) {

if(count == 0) {

arr_sort[0] = arr[0];

}else if(arr[i] = arr_sort[count - 1]) {

arr_sort[count] = arr[i];

}else if(arr[i] arr_sort[0]) {

insert(arr,arr_sort,arr[i],0,count);

}else {

for(int j = 0;j count - 1; j++) {

if(arr[i] = arr_sort[j] arr[i] arr_sort[j+1]) {

insert(arr,arr_sort,arr[i],j+1,count);

break;

}

}

}

count++;

}

System.out.print("经过插入排序后：");

for(int i = 0 ; i 10 ; i++)

System.out.print( arr_sort[i] +" ");

System.out.println("");

}

public void insert(int[] arr,int[] arr_sort,int value,int index,int count) {

for(int i = count; i index; i--)

arr_sort[i] = arr_sort[i-1];

arr_sort[index] = value;

}

public void Mergesort(int[] arr,int left,int right) {

if(right - left 0) {

int[] arr_1 = new int[(right - left)/2 + 1];

int[] arr_2 = new int[(right - left + 1)/2];

int j = 0;

int k = 0;

for(int i = left;i = right;i++) {

if(i = (right + left)/2) {

arr_1[j++] = arr[i];

}else {

arr_2[k++] = arr[i];

}

}

Mergesort(arr_1,0,(right - left)/2);

Mergesort(arr_2,0,(right - left - 1)/2);

Merge(arr_1,arr_2,arr);

}

}

public void Merge(int[] arr_1,int[] arr_2,int[] arr) {

int i = 0;

int j = 0;

int k = 0;

int L1 = arr_1.length;

int L2 = arr_2.length;

while(i L1 j L2) {

if(arr_1[i] = arr_2[j]) {

arr[k] = arr_1[i];

i++;

}else {

arr[k] = arr_2[j];

j++;

}

k++;

}

if(i == L1) {

for(int t = j;j L2;j++)

arr[k++] = arr_2[j];

}else {

for(int t = i;i L1;i++)

arr[k++] = arr_1[i];

}

}

}

若有错误，麻烦指正，不胜感激。

关于插入排序算法和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。