1、首先是插入排序,插入排序也有很多种,比如直接插入排序,二分插入排序等。但原理都基本差不多:在一个已经排好序的数列中插入新的信息。这样依次插入之后,整个数列就是一个有序的数列了。

插入排序

//插入排序

publicstaticint[] insertSort(int[] array)
{
for (int i =1; i < array.Length; i++) //遍历需要排序的数组
{
int j =0;
while (j < i && array[j] < array[i]) //找到满足条件的待插入数
{
j++;
}

int temp = array[i]; //保存待插入的数
int Last = i;

while (Last > j) //数组往后移动
{
array[Last] = array[Last -1];
Last--;
}
array[j] = temp; //把需要插入的数,插入到第j个位置
}
return array;
}

//插入排序

publicstaticint[] insertSort(int[] array)
{
for (int i =1; i < array.Length; i++) //遍历需要排序的数组
{
int j =0;
while (j < i && array[j] < array[i]) //找到满足条件的待插入数
{
j++;
}

int temp = array[i]; //保存待插入的数
int Last = i;

while (Last > j) //数组往后移动
{
array[Last] = array[Last -1];
Last--;
}
array[j] = temp; //把需要插入的数,插入到第j个位置
}
return array;
}

2、冒泡排序,冒泡排序的基本原理是。比较旁边两个数字,(如果按升序排列)然后前面的数字比后面的数字大,则两个进行交换。

冒泡排序

//冒泡排序
publicstaticint[] bubbleSort(int[] array)
{
for (int j =1; j < array.Length; j++) //排N次序
{
for (int i =1; i < array.Length; i++) //遍历一遍,第一次排序
{
if (array[i] < array[i -1]) //如果前面的比后面的大,则两者进行交换
{
int temp = array[i];
array[i] = array[i -1];
array[i -1] = temp;
}
}
}
return array;
}

3、希尔排序,方法的基本思想是:先将整个待排元素序列分割成若干个子序列(由相隔某个“增量”的元素组成的)分别进行冒泡排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序。

希尔排序

//希尔排序
publicstaticint[] shellSort(int[] array)
{
ArrayList list = getDalt(array);
Int32[] dalt = (Int32[])list.ToArray(typeof(Int32)); //转换为数组
for (int i =0; i <dalt.Length; i++)
{
array = shellAdjust(array,dalt[i]);
}
return array;
}
//获得dalt数组,保存比较的增量表
publicstatic ArrayList getDalt(int[] array) {
ArrayList dalt =new ArrayList();
int i = (array.Length+1) /2;
while (i >1)
{
dalt.Add(i);
i =(i+1)/2;
}
dalt.Add(i);
return dalt;
}
//一趟排序
publicstaticint[] shellAdjust(int[] array, int add) //进行排序
{
int i=0;
while (i + add < array.Length)
{
if (array[i] > array[i + add]) //如果前面的比后面的大,则交换
{
int temp = array[i + add];
array[i+add]=array[i];
array[i] = temp;
}
i ++;
}
return array;
}

4、快速排序。快速排序是对冒泡排序的一种改进。主要是通过把整个数列分成若干个小的数列再排序。 首先随便在数组中找到一个目标数,然后移动数组中的元素,使大于改数的移动右边,小于的则移动左边。这样就分成了两部分,一部分比该数大,一部分比该数小。然后通过递归的方式。进行全部排列。

快速排序算法,最核心的就是中间的划分过程。但是上次这个过程并不能正确的划分出来。特此改正,造成误解,一并道歉。特此订正。

 1 public static int paration(Integer[] arrayList,int begin,int end){
 2         int temp=arrayList[begin];
 3         while (begin<end) {
 4             while (begin<end&&arrayList[end]>temp) {
 5                 end--;
 6             }
 7             if (begin<end) {
 8                 arrayList[begin]=arrayList[end];
 9                 begin++;
10             }
11             while (begin<end&&arrayList[begin]<temp) {
12                 begin++;
13             }
14             if (begin<end) {
15                 arrayList[end]=arrayList[begin];
16                 end--;
17             }
18         }
19         arrayList[begin]=temp;
20         return begin;
21     }
22     public static void quickSort(Integer[] arrayList,int begin,int end){
23         if(begin>=end)
24             return;
25         int par=paration(arrayList, begin, end);
26         if(begin<par-1)
27             quickSort(arrayList, begin, par-1);
28         if (par+1<end)
29             quickSort(arrayList, par+1, end);
30
31     }

5、堆排序。堆排序首先需要建立一个堆。可以是大堆(父结点比子结点的元素都要大),也可以是小堆(父节点比子结点都要小);本例建成大堆。

堆排序

//堆排序
publicstaticint[] heapSort(int[] array)
{
for (int i = (array.Length-1)/2; i>=0;i--)
{
//首先整个序列进行堆调整,
heapAdjust(array,i, array.Length);
}
for (int i = array.Length-1; i >=0; i--)
{
//交换第一个和最后一个数据,形成排序
int temp=array[0];
array[0]=array[i];
array[i] = temp;
//堆重新调整
heapAdjust(array,0,i-1);
}
return array;
}

堆调整

///<summary>
/// 堆调整,建成一个大堆
///</summary>
///<param name="array"></param>
///<param name="i">开始调整</param>
///<param name="n">调整的长度</param>
///<returns>返回调整后的数组</returns>
publicstaticint[] heapAdjust(int[] array,int j,int n)
{
int temp = array[j]; //此次需要调整的数
for (int i = j*2+1; i < n; i=2*j+1)
{
if (i+1<n&&array[i] < array[i +1])
i++;
if (temp <array[i]) //如果孩子的结点更大,则交换
{
array[j] = array[i];
j = i;
}
else
break;
}
array[j] = temp; //需要调整的结点保存在适当位置
putOutArray(array);
return array;
}

附录1:输出数组

输出数组

//输出数组
publicstaticvoid putOutArray(int[] array)
{
for (int i =0; i < array.Length; i++)
{
Console.Write(array[i] +"");
}
Console.Write("\n");
}

附录2:测试数组

测试

staticvoid Main(string[] args)
{
int[] array = { 72, 45, 3, 64, 78, 12, 56, 76, 23, 46 };
Console.WriteLine("这是插入排序的结果");
putOutArray(insertSort(array));
Console.WriteLine("这是冒泡排序的结果");
putOutArray(bubbleSort(array));
Console.WriteLine("这是希尔排序的结果:");
putOutArray(shellSort(array));
Console.WriteLine("这是快速排序:");
putOutArray(quickSort(array,0,array.Length-1));
}

//快速排序
publicstaticint[] quickSort(int[] array,int low,int high)
{
int at;
if (low < high)
{
array = quick(array, low, high, out at); //把数组分成两个部分,
quickSort(array,low,at-1); //左边的排序
quickSort(array,at,high); //右边的排序
}
return array;
}
publicstaticint[] quick(int[] array, int first, int end,outint at) {
int mid = array[first]; //同第一个数比较
while (first <= end)
{
while (array[first] < mid) //向右移动,直到找到比mid大或相等的那个数
first++;
while (array[end] > mid) //向左移动,直到找到比Mid小的那个数
end--;
if (first <= end)
{
int temp = array[first]; //交换两个数
array[first] = array[end];
array[end] = temp;
first++;
end--;
}
}
at = first;
return array;
}

版权所有,欢迎转载,但是转载请注明出处:潇一

转载于:https://www.cnblogs.com/xiaoyi115/archive/2011/05/15/2047017.html

各种内部排序算法,C#实现相关推荐

  1. 超详细!各种内部排序算法的比较

    先来个表格总结直观展示下: 各种内部排序算法的性质            算法种类                    时间复杂度  空间复 杂度 稳定性 最好情况 平均情况 最坏情况 插入排序 直 ...

  2. 飞鸽传书内部排序算法的性能比较

    部排序算法的性能比较 飞鸽传书内部排序算法的性能比较 1)排序的稳定性及分析: 假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,ri=r ...

  3. 数据结构之排序算法:内部排序算法的应用与比较

    排序算法:内部排序算法的应用与比较 思维导图: 比较: 应用: 思维导图: 比较: 应用:

  4. 数据结构之内部排序算法总结笔记

    内部排序算法  排序的基本概念: 把一组无序的数据元素按照关键字值递增(或递减)的顺序重新排列.  一.插入排序 思想:将序列分为[有序段]与[无序段]两段,然后依次将[无序段]中的元素插入到[有序段 ...

  5. 《数据结构》--内部排序算法比较

    题目 各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间.试通过随机的数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受. 基本要求: (1) 从以下常用的内部排 ...

  6. 内部排序算法比较-数据结构C语言课设

    名称:内部排序算法比较 内容:在教科书中,各种内部排序算法的时间复杂的分析结果只给出了算法执行时间的阶,或大概执行时间.试通过随机数据比较各种算法的关键字比较次数和关键字移动次数,以取得直观感受. 任 ...

  7. 内部排序算法全面总结

    排序的概念 排序,就是重新排列表中的元素,使表中的元素按照关键字有序的过程. 我所了解的 表 多半是顺序表,因为顺序表实现较为简单,但是链表结构同样可以实现很多排序算法. 定义中的元素一般指什么元素呢 ...

  8. 《内部排序算法比较》

    <内部排序算法比较> 一.[问题描述] 在教科书中,各种内部排序算法的时间复杂度分析结果只给出算法的大致执行时间.试通过随机数据比较各算法的关键字比较次数和关键字移动次数,以获得直观感受 ...

  9. 九大内部排序算法(快速排序、归并排序、堆排序、希尔排序、基数排序)

    排序(Sorting)是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个按关键字有序的序列. 文章目录 由于待排序的记录数量不同,使得排序过程中涉及的存储器 ...

  10. 《数据结构》之内部排序算法比较

    前言 各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间.试通过随机的数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受. 基本要求: (1) 从以下常用的内部排 ...

最新文章

  1. MPB:中科院生态环境中心邓晔组-从环境样本中提取高质量DNA-研磨加DNeasy试剂盒方法...
  2. HTTPS 建立连接的过程
  3. linux操作系统的特点包括什么,什么是Linux操作系统?有哪些主要特点?
  4. 显示屏的方向设置问题
  5. Qt版本中国象棋开发(二)
  6. java AES 加密和linux解密
  7. html5 sidetoggle,javascript-使用React.js实现SlideToggle功能
  8. 使用ycsb测试cassandra
  9. 浅谈Tuple之C#4.0新特性
  10. Oracle 表空间常用sql
  11. 串行口实验 编写程序利用PC机控制单片机实验板上的数码管设备工作
  12. PHP CURL模拟POST提交XML数据
  13. 德鲁伊 oltp oltp_内存中OLTP –招待看门狗的三个关键点–检查点文件
  14. 【服务器防护】centos iptables 防火墙设置 mac过滤
  15. 哪种pdf编辑器更方便使用
  16. windows10查看桌面壁纸路径
  17. CSR-I (WSJ0) Complete又名wsj0数据集
  18. C语言基础-函数的概念
  19. 4.13 使用扇贝工具制作猥琐的老鼠 [Illustrator CC教程]
  20. 诸葛管理:怎么才能快速提升执行力

热门文章

  1. 微信公众号模板消息 access_token missing
  2. java输出int_如何使打印整数函数(没有printf)输出INT_MAX
  3. html基礎之渐变属性(斑马线)
  4. rocketmq 部署启动指南-Docker 版
  5. IDEA 常用设置 与 常用操作(二)
  6. 小D课堂 - 零基础入门SpringBoot2.X到实战_第9节 SpringBoot2.x整合Redis实战_40、Redis工具类封装讲解和实战...
  7. 阶段3 2.Spring_02.程序间耦合_5 编写工厂类和配置文件
  8. 搜索框键盘抬起事件2
  9. rhel6+apache2.4+mysql5.7+php5.6部署LAMP架构
  10. Kotlin——初级篇(三):数据类型详解