1.直接插入排序算法

 1 // 直接插入排序
 2 //Code by Larman Yuan 2009-6-28
 3 
 4 #include "stdafx.h"
 5 
 6 void insertSort(int * sortArray, int size)
 7 {
 8     int j;
 9     for(int i = 1; i < size; i++)
10     {
11         j = i - 1;
12         int temp = sortArray[i];
13         while(sortArray[j]  > temp && j >= 0)
14         {
15             sortArray[j + 1] = sortArray[j];
16             j--;
17         }
18         if(j != (i - 1))
19             sortArray[j + 1] = temp;
20 
21     }
22 }
23 
24 void printArray(int arrayToPrint[],int size)
25 {
26        for(int i = 0; i < size; i++)
27     {
28         printf("%d ", arrayToPrint[i]);
29     }
30     printf("\n");
31 }
32 int _tmain(int argc, _TCHAR* argv[])
33 {
34     int  sortArray[8] = {49, 38, 65, 97,76, 13, 27, 49};
35     printf("Array before sort: ");
36     printArray(sortArray, 8);
37     insertSort(sortArray, 8);
38         printf("Array after sort : ");
39     printArray(sortArray, 8);
40     return 0;
41 }

运行结果：

Array before sort: 49 38 65 97 76 13 27 49

Array after sort : 13 27 38 49 49 65 76 97

2.二分插入排序算法

 1 // 二分法插入排序
 2 //Code by Larman Yuan 2009-6-28
 3 
 4 #include "stdafx.h"
 5 
 6 void binInsertSort(int* sortArray, int size)
 7 {
 8     int left, right,middle, i,j, temp;
 9     for(i = 1; i < size; i++)
10     {
11         temp = sortArray[i];
12         left = 0;
13         right = i - 1;
14 
15         while(left <= right)
16         {
17             middle = (left + right) / 2;
18             if(temp < sortArray[middle])
19                 right = middle -1;
20             else
21                 left = middle + 1;
22         }
23 
24         for(j = i - 1; j >= left; j--)
25             sortArray[j + 1] = sortArray[j];
26         if(left != i)
27             sortArray[left] = temp;
28     }
29 }
30 
31 void printArray(int arrayToPrint[],int size)
32 {
33        for(int i = 0; i < size; i++)
34     {
35         printf("%d ", arrayToPrint[i]);
36     }
37     printf("\n");
38 }
39 
40 int _tmain(int argc, _TCHAR* argv[])
41 {
42     int  sortArray[8] = {49, 38, 65, 97,76, 13, 27, 49};
43     printf("Array before sort: ");
44     printArray(sortArray, 8);
45     binInsertSort(sortArray, 8);
46         printf("Array after sort : ");
47     printArray(sortArray, 8);
48     return 0;
49 }

运行结果：

Array before sort: 49 38 65 97 76 13 27 49

Array after sort : 13 27 38 49 49 65 76 97

3.表插入排序算法

 1 // 表插入排序
 2 //Code by larman Yuan 2009-6-28
 3 
 4 #include "stdafx.h"
 5 #include <stdlib.h>
 6 struct Node;
 7 typedef struct Node ListNode;
 8 struct Node
 9 {
10     int key;
11     ListNode* next;
12 };
13 typedef ListNode* LinkList;
14 
15 void listInsertSort(LinkList * palist)
16 {
17     ListNode * now, *pre, *p, *q, *head;
18     head = *palist;
19     pre = head ->next;
20     now = pre->next;
21     if(pre == NULL || now == NULL)
22     {
23         return;
24     }
25     while(now != NULL)
26     {
27         q = head;
28         p = head->next;
29         while(p != now && p->key <= now->key)
30         {
31             q = p;
32             p = p->next;
33         }
34         if(p == now)
35         {
36             pre = pre->next;
37             now = pre->next;
38             continue;
39         }
40         pre->next = now->next;
41         q->next = now;
42         now->next = p;
43         now = pre->next;
44     }
45 }
46 
47 void printList(LinkList * palist)
48 {
49     ListNode * p = (*palist)->next;
50         while(p != NULL)
51         {
52             printf("%d ",p->key);
53             p = p->next;
54         }
55         printf("\n");
56 }
57 
58 void insertElement(LinkList * palist, int value)
59 {
60     ListNode * head, *p, * nodeToInsert;
61     if(palist == NULL || *palist == NULL)
62     {
63         return;
64     }
65     head = *palist;
66     p = head;
67     while(p->next != NULL)
68     {
69         p = p->next;
70     }
71     nodeToInsert = (ListNode *)malloc(sizeof(struct Node));
72     nodeToInsert->key = value;
73     nodeToInsert->next = NULL;
74     p->next = nodeToInsert;    
75 }
76 int _tmain(int argc, _TCHAR* argv[])
77 {
78       LinkList list = (ListNode *)malloc(sizeof(struct Node));
79       list->next = NULL;
80        insertElement(&list,49);
81        insertElement(&list,38);
82        insertElement(&list,65);
83        insertElement(&list,97);
84        insertElement(&list,76);
85        insertElement(&list,13);
86        insertElement(&list,27);
87        insertElement(&list,49);
88        printf("List before sort: ");
89        printList(&list);
90        listInsertSort(&list);
91        printf("List after  sort: ");
92        printList(&list);
93     return 0;
94 }

运行结果：

List before sort: 49 38 65 97 76 13 27 49

List after  sort: 13 27 38 49 49 65 76 97

4.Shell排序算法 

 1 // shellSort.cpp: 主项目文件。
 2 
 3 #include "stdafx.h"
 4 #include <stdio.h>
 5 
 6 using namespace System;
 7 
 8 void shellSort(int* sortArray, int size,int d)
 9 {
10     int i, j, increment, temp;
11     for(increment = d; increment > 0; increment /= 2)
12     {
13         for(i = increment; i < size; i++)
14         {
15             temp = sortArray[i];
16             j = i - increment;
17             while(j >= 0 && temp < sortArray[j])
18             {
19                 sortArray[j + increment] = sortArray[j];
20                 j -= increment;
21             }
22             sortArray[j + increment] = temp;
23         }
24     }
25 }
26 
27 void printArray(int arrayToPrint[],int size)
28 {
29        for(int i = 0; i < size; i++)
30     {
31         printf("%d ", arrayToPrint[i]);
32     }
33     printf("\n");
34 }
35 
36 int main(array<System::String ^> ^args)
37 {
38     int sortArray[8] = {49,38,65,97,13,76,27,49};
39     printf("Array before sort: ");
40     printArray(sortArray, 8);
41     shellSort(sortArray, 8, 4);
42     printf("Array after sort:  ");
43     printArray(sortArray, 8);
44     return 0;
45 }

运行结果：

Array before sort: 49 38 65 97 13 76 27 49

Array after sort:  13 27 38 49 49 65 76 97

转载于:https://www.cnblogs.com/LarmanYuan/archive/2009/06/28/1512822.html

数据结构-排序（插入排序）相关推荐

  1. 数据结构—排序算法总结(插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、合并排序、计数排序)

    *排序 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作. 稳定性 在待排序的数组中,如果出现多个相同的关键字,例如:98751555512,中出现重复的数字,在 ...

  2. 02_Python算法+数据结构笔记-冒泡排序-选择排序-插入排序-快排-二叉树

    b站视频:路飞IT学城 清华计算机博士带你学习Python算法+数据结构_哔哩哔哩_bilibili 文章目录 #11 排序介绍 #12 冒泡排序介绍 #13 冒泡排序 #14 选择排序 #15 插入 ...

  3. 【数据结构-排序】1. 图解插入排序三种实现(插入排序/折半排序/希尔排序)

    直接插入排序(插入排序) 排序思想 对于一个数组 A[0,n] 的排序问题,假设认为数组在 A[0,n-1] 排序的问题已经解决了. 考虑 A[n] 的值,从右向左扫描有序数组 A[0,n-1] ,直 ...

  4. 数据结构 - 直接插入排序法

    数据结构 - 直接插入排序法. 之前的博文已经介绍了 冒泡排序法 和 简单选择排序法. 其实上面两种的基本思路是一样的, 就是通过两层循环, 在每1个内循环中找到1个未排序的极值元素, 然后把这个元素 ...

  5. C语言排序算法 选择排序 插入排序 快速排序 qsort实现快排 堆排序

    常见排序算法 选择排序 选择排序(Selection sort)是一种简单直观的排序算法. 它的工作原理如下. 首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素 ...

  6. 数据结构---简单插入排序

    数据结构-简单插入排序 原理:参考趣学数据结构 代码: #include<stdio.h> #include<stdlib.h> void simpleInsertSort(i ...

  7. 数据结构---排序算法的总结

    数据结构-排序算法的总结 分类 冒泡排序,时间复杂度O(n x n),空间复杂度O(1),稳定 简单选择排序,时间复杂度O(n x n),空间复杂度O(1),不稳定 希尔排序,时间复杂度O(n^1.3 ...

  8. 数据结构-排序基础代码

    数据结构-排序基础代码 1.快排的递归算法: void QuickSort(int A[],int n){Qsort(A,0,n-1); } void Qsort(int A[],int left,i ...

  9. 【数据结构排序算法系列】数据结构八大排序算法

    排序算法在计算机应用中随处可见,如Windows操作系统的文件管理中会自动对用户创建的文件按照一定的规则排序(这个规则用户可以自定义,默认按照文件名排序)因此熟练掌握各种排序算法是非常重要的,本博客将 ...

  10. 数据结构-排序算法总结与感悟

    数据结构-排序算法总结 一,排序的基本概念 排序:有n个记录的序列{R1,R2,-,Rn},其相应关键字的序列是{K1,K2, -,Kn },相应的下标序列为1,2,-, n.通过排序,要求找出当前下 ...

最新文章

  1. 如何救队友_第五人格中高端局如何救队友，这些技巧很实用，不卡血量是关键...
  2. 创业路上的这点事之 从无到有，从有到......
  3. 英特尔核显自定义分辨率_让免费的核显更好用！英特尔酷睿集成的GPU如何优化？...
  4. 为什么iPad-WIFI版无3G模块也可以准确定位？
  5. 关于linux系统端口查看和占用的解决方案
  6. PostgreSQL 12系统表(6)pg_namespace
  7. javascript开发中的封装模式（转）
  8. Windows字体修改工具：一键更换系统字体 noMeiryoUI 2.41.0 中文绿色版
  9. 超声前置放大器原理是什么意思，前置放大器和功放区别
  10. html表单中按钮居中,Ant design StepsForm中如何使底部按钮居中
  11. Python+FFmpeg音视频格式转换
  12. 防盗系统Java_java小区防盗报警系统
  13. Excel如何快速删除指定区域公式保留数值
  14. 苹果公司CEO乔布斯演讲的15个秘诀
  15. 2021年茶艺师（初级）考试题库及茶艺师（初级）考试技巧
  16. SQL SERVER DAY函数
  17. linux修复引导工具,linux 修复引导工具
  18. java常用代码架构示例
  19. 配置基于虚拟隧道接口的IPSec隧道实验
  20. 杰里最新的 授权工具版本【篇】

热门文章

  1. 图解高内聚与低耦合，傻瓜都能看懂！
  2. 自学架构设计的一个好方法
  3. Go: GoRoutine是如何实现的？
  4. 43.StrVec类：std::move调用移动构造函数的一个实例
  5. 怎么样让body、div占满整个浏览器的窗口
  6. html多重边框，中间空白,CSS揭秘之多重边框的实现
  7. jpa query 取数组第一个_数据结构基础-数组
  8. 怎样用springboot开发cs_springboot开发之配置自定义的错误界面和错误信息
  9. 怎样打造高效节能的数据中心
  10. 安全用电基本知识，弱电工程人员要学会！