- 浏览: 41249 次
- 性别:
- 来自: 广州
文章分类
最新评论
-
老虎仔CKJ:
xuhang1128 写道如果使用反向代理的话,那么是不是用户 ...
反向代理服务器 -
xuhang1128:
如果使用反向代理的话,那么是不是用户访问网站的时候dns会重定 ...
反向代理服务器 -
司华happy:
额,请教个问题!那如果我不想让文字被隐藏,而是换行 ...
一行内文本溢出的处理 -
wzl454823:
hpjianhua 写道测试数据:
int a[] = n ...
选择,插入,冒泡,希尔等排序算法 -
hpjianhua:
测试数据:
int a[] = new int[]{49, ...
选择,插入,冒泡,希尔等排序算法
一。选择排序:
1.原理:
首先,找数组中最小的元素,把它与第一个位置的元素进行交换。然后,找到第二个最小的元素,并用数组中的第二个位置的元素进行交换。这样进行下去,直到整个数组排序完毕。
2.java代码示例:
Java代码
3.简单说明:
对于从1到N-1次的每一个i,有一次交换和N-1次的比较,所以一共有N-1次交换和(N-1)+(N-2)+......+2+1=N(N-1)/2次比较,无论输入数据是怎样的。
选择排序唯一依赖输入部分的事min的更新次数,所以一般选择排序运行效率跟输入的数据关系不大。
二。插入排序:
1.原理:
在数组中将较大的元素向右移动一个位置,为要插入的元素腾出空间,然后较小的元素插入到这个空位置上。
2.java代码示例:
Java代码
3.简单说明:
插入排序的比较交换要根据 输入的数据而定:最好情况就是,序列已经是升序排列了,在这种情况下,需要进行的比较交换操作需(n-1)次即可。最坏情况就是,序列是降序排列,那么此时需要进行的比较共有n(n-1)/2次。所以,如果需要排序的数据量比较小,有一定的顺序用插入排序还是一个不错的选择。
三。冒泡排序:
1.原理:
不断的遍历元素,交换倒序的相邻元素,直到排序完成
2.java代码示例:
Java代码
3.简单说明:
冒泡排序要要比选择排序,插入排序慢,它一般来说要进行N^2/2次 比较和交换,而选择排序一般进行N^2/2次比较,交换需要N次;插入排序最坏的情况下才需要N^2/2比较和交换,一般情况下只需N^2/4次比较和交换即可。但是冒泡排序的最大优点是:实现简单。
四。希尔排序:
1.原理:
插入排序很慢,是因为它只能交换相邻的元素,因此数组中的元素只能移动一个位置,希尔排序是插入排序的一个简单的扩展,它允许相隔很远的元素进行交换从而提高了速度。
先取一个小于数组长度的整数h1作为第一个增量,把一个数组的全部元素分成h1个组。所有距离为h1的倍数的记录放在同一个组中。先在各组内进行直接插人排序;然后,取第二个增量h2<h1重复上述的分组和排序,直至所取的增量ht=1(ht<ht-l<…<h2<h1),即所有记录放在同一组中进行直接插入排序为止。
2.java代码示例:
Java代码
3.简单说明:
在希尔排序开始时增量较大,分组较多,每组的记录数目少,故各组内直接插入较快,后来增量hi逐渐缩小,分组数逐渐减少,而各组的记录数目逐渐增多,但由于已经按hi-1作为距离排过序,使文件较接近于有序状态,所以新的一趟排序过程也较快。
谢谢,我原来代码是在javaeye找的 还没等看。
1.原理:
首先,找数组中最小的元素,把它与第一个位置的元素进行交换。然后,找到第二个最小的元素,并用数组中的第二个位置的元素进行交换。这样进行下去,直到整个数组排序完毕。
2.java代码示例:
Java代码
package com.qingbyqing.algorithm; public class Selectionsort1 { static int[] a = { 2, 3, 1, 43, 23, 32, 5, 7, 4, 0, 31, 4, 7}; public static void main(String[] args) { for (int i = 0; i < a.length - 1; i++) { int minIndex = i;// 最小元素 for (int j = i + 1; j < a.length; j++) { if (a[minIndex] > a[j]) {// 比较 minIndex = j; continue; } } // 交换 int temp = a[i]; a[i] = a[minIndex]; a[minIndex] = temp; } // 测试输出结果 for (int k = 0; k < a.length; k++) { System.out.print(a[k] + " "); } } }
3.简单说明:
对于从1到N-1次的每一个i,有一次交换和N-1次的比较,所以一共有N-1次交换和(N-1)+(N-2)+......+2+1=N(N-1)/2次比较,无论输入数据是怎样的。
选择排序唯一依赖输入部分的事min的更新次数,所以一般选择排序运行效率跟输入的数据关系不大。
二。插入排序:
1.原理:
在数组中将较大的元素向右移动一个位置,为要插入的元素腾出空间,然后较小的元素插入到这个空位置上。
2.java代码示例:
Java代码
package com.qingbyqing.algorithm; public class Insert { static int[] a = { 9, 4, 5, 7, 23, 3, 1, 4, 0, 6 }; public static void main(String[] args) { for (int i = 1; i < a.length; i++) { for (int j = i; j > 0; j--) { if (a[j] < a[j - 1]) {// 比较 // 交换 int temp = a[j]; a[j] = a[j - 1]; a[j - 1] = temp; } } } // 测试输出结果 for (int k = 0; k < a.length; k++) { System.out.print(a[k] + " "); } } }
3.简单说明:
插入排序的比较交换要根据 输入的数据而定:最好情况就是,序列已经是升序排列了,在这种情况下,需要进行的比较交换操作需(n-1)次即可。最坏情况就是,序列是降序排列,那么此时需要进行的比较共有n(n-1)/2次。所以,如果需要排序的数据量比较小,有一定的顺序用插入排序还是一个不错的选择。
三。冒泡排序:
1.原理:
不断的遍历元素,交换倒序的相邻元素,直到排序完成
2.java代码示例:
Java代码
package com.qingbyqing.algorithm; public class Bubble { static int a[] = { 9, 4, 5, 7, 23, 3, 1, 4, 0, 6 }; public static void main(String[] args) { for (int i = 0; i < a.length; i++) { for (int j = i + 1; j < a.length; j++) { if (a[i] > a[j]) {// 比较 // 交换 int temp = a[i]; a[i] = a[j]; a[j] = temp; } } } // 测试输出结果 for (int k = 0; k < a.length; k++) { System.out.print(a[k] + " "); } } }
3.简单说明:
冒泡排序要要比选择排序,插入排序慢,它一般来说要进行N^2/2次 比较和交换,而选择排序一般进行N^2/2次比较,交换需要N次;插入排序最坏的情况下才需要N^2/2比较和交换,一般情况下只需N^2/4次比较和交换即可。但是冒泡排序的最大优点是:实现简单。
四。希尔排序:
1.原理:
插入排序很慢,是因为它只能交换相邻的元素,因此数组中的元素只能移动一个位置,希尔排序是插入排序的一个简单的扩展,它允许相隔很远的元素进行交换从而提高了速度。
先取一个小于数组长度的整数h1作为第一个增量,把一个数组的全部元素分成h1个组。所有距离为h1的倍数的记录放在同一个组中。先在各组内进行直接插人排序;然后,取第二个增量h2<h1重复上述的分组和排序,直至所取的增量ht=1(ht<ht-l<…<h2<h1),即所有记录放在同一组中进行直接插入排序为止。
2.java代码示例:
Java代码
package com.qingbyqing.algorithm; public class ShellSort { static int[] a = { 2, 3, 1, 43, 23, 32, 5, 7, 4, 0, 31, 4, 7 }; public static void main(String[] args) { // 分组 for (int h = a.length / 2; h > 0; h /= 2) { // 组内使用直接插入排序法排序(增量由1变成h) for (int i = h; i < a.length; i++) { int temp = a[i]; int j = 0; for (j = i; j >= h; j -= h) { if (temp < a[j - h]) {// 比较 a[j] = a[j - h]; } else { break; } } // 交换 a[j] = temp; } } // 测试输出结果 for (int k = 0; k < a.length; k++) { System.out.print(a[k] + " "); } } }
3.简单说明:
在希尔排序开始时增量较大,分组较多,每组的记录数目少,故各组内直接插入较快,后来增量hi逐渐缩小,分组数逐渐减少,而各组的记录数目逐渐增多,但由于已经按hi-1作为距离排过序,使文件较接近于有序状态,所以新的一趟排序过程也较快。
评论
2 楼
wzl454823
2010-12-24
hpjianhua 写道
测试数据:
用博主的冒泡算法输出以下结果:
博主应该好好检查下自己的算法!
给出我自己的算法:
输出结果:
int a[] = new int[]{49,38,65,97,76,13,27,49};
用博主的冒泡算法输出以下结果:
第0回排序:[13, 49, 65, 97, 76, 38, 27, 49] 第1回排序:[13, 27, 65, 97, 76, 49, 38, 49] 第2回排序:[13, 27, 38, 97, 76, 65, 49, 49] 第3回排序:[13, 27, 38, 49, 97, 76, 65, 49] 第4回排序:[13, 27, 38, 49, 49, 97, 76, 65] 第5回排序:[13, 27, 38, 49, 49, 65, 97, 76] 第6回排序:[13, 27, 38, 49, 49, 65, 76, 97] 第7回排序:[13, 27, 38, 49, 49, 65, 76, 97]
博主应该好好检查下自己的算法!
给出我自己的算法:
/** * 交换两个数位置的算法 * @param data * @param i * @param j */ public static void swap(int[] data,int i,int j){ int temp = 0; temp = data[i]; data[i] = data[j]; data[j] = temp; } /** * 冒泡排序算法实现 * @param data * @param n */ public static void bubble(int[] data,int n){ for(int i = 0;i<n;i++){ for(int j = 1;j<n;j++){ if(data[j]<data[j-1]){ swap(data,j,j-1); } } System.out.println("第"+i+"回排序:"+Arrays.toString(data)); } }
输出结果:
第0回排序:[38, 49, 65, 76, 13, 27, 49, 97] 第1回排序:[38, 49, 65, 13, 27, 49, 76, 97] 第2回排序:[38, 49, 13, 27, 49, 65, 76, 97] 第3回排序:[38, 13, 27, 49, 49, 65, 76, 97] 第4回排序:[13, 27, 38, 49, 49, 65, 76, 97] 第5回排序:[13, 27, 38, 49, 49, 65, 76, 97] 第6回排序:[13, 27, 38, 49, 49, 65, 76, 97] 第7回排序:[13, 27, 38, 49, 49, 65, 76, 97]
谢谢,我原来代码是在javaeye找的 还没等看。
1 楼
hpjianhua
2010-12-17
测试数据:
用博主的冒泡算法输出以下结果:
博主应该好好检查下自己的算法!
给出我自己的算法:
输出结果:
int a[] = new int[]{49,38,65,97,76,13,27,49};
用博主的冒泡算法输出以下结果:
第0回排序:[13, 49, 65, 97, 76, 38, 27, 49] 第1回排序:[13, 27, 65, 97, 76, 49, 38, 49] 第2回排序:[13, 27, 38, 97, 76, 65, 49, 49] 第3回排序:[13, 27, 38, 49, 97, 76, 65, 49] 第4回排序:[13, 27, 38, 49, 49, 97, 76, 65] 第5回排序:[13, 27, 38, 49, 49, 65, 97, 76] 第6回排序:[13, 27, 38, 49, 49, 65, 76, 97] 第7回排序:[13, 27, 38, 49, 49, 65, 76, 97]
博主应该好好检查下自己的算法!
给出我自己的算法:
/** * 交换两个数位置的算法 * @param data * @param i * @param j */ public static void swap(int[] data,int i,int j){ int temp = 0; temp = data[i]; data[i] = data[j]; data[j] = temp; } /** * 冒泡排序算法实现 * @param data * @param n */ public static void bubble(int[] data,int n){ for(int i = 0;i<n;i++){ for(int j = 1;j<n;j++){ if(data[j]<data[j-1]){ swap(data,j,j-1); } } System.out.println("第"+i+"回排序:"+Arrays.toString(data)); } }
输出结果:
第0回排序:[38, 49, 65, 76, 13, 27, 49, 97] 第1回排序:[38, 49, 65, 13, 27, 49, 76, 97] 第2回排序:[38, 49, 13, 27, 49, 65, 76, 97] 第3回排序:[38, 13, 27, 49, 49, 65, 76, 97] 第4回排序:[13, 27, 38, 49, 49, 65, 76, 97] 第5回排序:[13, 27, 38, 49, 49, 65, 76, 97] 第6回排序:[13, 27, 38, 49, 49, 65, 76, 97] 第7回排序:[13, 27, 38, 49, 49, 65, 76, 97]
发表评论
-
风雨20年:积累的20条编程经验
2010-11-15 07:39 8281. 估算解决问题所需要 ... -
冒泡排序
2010-11-12 14:29 776public static int[] BubbleSort( ... -
IT经理的英文简历
2010-11-08 12:22 1449Mature,dynamic and honest. 思想成 ... -
常用的正则表达式
2010-11-06 19:09 640正则表达式是一种通用 ... -
Js正则表达式
2010-11-06 19:08 808//校验是否全由数字组成 var patrn=/^[0-9] ... -
2010 Linux Journal读者选择奖揭晓
2010-11-04 10:41 1220最佳Linux发行版 Ubuntu 提名: PCLinuxO ... -
Lazyload 延迟加载效果
2010-11-01 16:54 705Lazyload是通过延迟加载来实现按需加载,达到节省资源,加 ... -
Gears
2010-10-30 21:51 722Gears,原称Google Gears,是一款Google开 ... -
反向代理服务器
2010-10-30 17:30 40551.什么是正向代理和正向代理服务器? 正向代理就是通常所说的 ... -
Nginx
2010-10-30 17:25 860Nginx ("engine x") 是一 ... -
条件(三元)运算符 (?:)
2010-10-30 16:17 1770视情况返回以下两个表达式之一。 test ? expressi ... -
网站重构
2010-10-28 18:38 587前不久听到这样一个面试的故事: 面试官:你准备在我们公司做些 ... -
全球四大会计师事务所
2010-10-25 19:22 940普华永道普华永道是全 ...
相关推荐
本话题主要探讨六种内部排序算法:直接插入排序、希尔排序、冒泡排序、快速排序、选择排序以及堆排序。这六种排序算法各有优劣,适用于不同的场景,接下来我们将逐一进行详细阐述。 1. **直接插入排序**: 直接...
本资源提供了七大经典排序算法的实现程序,包括快速排序、冒泡排序、选择排序、归并排序、插入排序、希尔排序和堆排序。下面将逐一详细介绍这些排序算法及其原理。 1. 快速排序:由C.A.R. Hoare提出,是一种采用...
本文将深入探讨C#中常见的四种排序算法:冒泡排序、选择排序、插入排序和希尔排序,以及它们的实现细节和应用场合。 首先,我们来看**冒泡排序**。冒泡排序是一种简单的交换排序方法,它通过不断比较相邻元素并交换...
排序算法汇总P: 冒泡排序快速排序直接选择排序插入排序希尔排序 堆排序........
本文将详细讲解六种经典的排序算法——合并排序、插入排序、希尔排序、快速排序、冒泡排序以及桶排序,并结合提供的文件名(sort.c、set.c、main.c、set.h、sort.h)推测出每个文件可能包含的代码实现。 1. **合并...
本文将深入探讨Java编程语言中实现的七种主要排序算法:直接插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序以及归并排序。每种算法都有其独特性,适用于不同的场景和数据特性。 1. **直接插入排序**:...
排序算法汇总(选择排序、直接插入排序、冒泡排序、希尔排序、快速排序、堆排序) 本资源介绍了六种常用的排序算法:选择排序、直接插入排序、冒泡排序、希尔排序、快速排序和堆排序。下面对每种算法进行详细介绍:...
本主题将详细探讨希尔排序、冒泡排序、堆排序等经典的排序算法,这些都是数据结构与算法学习中的核心内容,尤其对于北邮数据结构课程来说,理解并掌握这些排序方法至关重要。 1. **插入排序**: 插入排序是一种...
这七种算法分别是:冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序和快速排序。 1. **冒泡排序**: 冒泡排序是最基础的排序算法之一,通过重复遍历待排序序列,比较相邻元素并交换位置来实现排序...
根据给定的信息,本文将详细介绍五种经典的排序算法在 C# 中的应用,包括选择排序、冒泡排序、快速排序、插入排序以及希尔排序。 ### 一、选择排序 选择排序是一种简单直观的比较排序算法。它的工作原理是通过从未...
在众多排序算法中,希尔排序、冒泡排序、插入排序和选择排序因其简洁性和易于理解性,成为了经典的入门级算法。本文将对这些算法进行详细的探讨,旨在分析它们的原理、特点及适用场景。 首先,让我们来看看希尔排序...
本篇文章将深入探讨标题和描述中提到的九大排序算法:快速排序、冒泡排序、堆排序、希尔排序、直接插入排序、直接选择排序、基数排序、箱排序和桶排序。 1. **快速排序**:快速排序是一种基于分治策略的排序算法,...
排序算法java版,速度排行:冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序.mht
printf("\t7: 希尔排序\n"); printf("\t***************************\n"); scanf("%d",&i); //输入整数1-7,选择排序方式 switch (i){ case 1: InsertSort(R); break; //值为1,直接插入排序 case 2: ...
各种常用c++排序算法,包括插入排序、冒泡排序、选择排序、快速排序、归并排序、希尔排序等
10种排序算法代码+综合比较代码(直接插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序、折半插入排序、2路插入排序),其中不仅有各种排序算法的代码,还包含10种代码在关键字...
根据提供的文件信息,我们可以深入探讨几种经典的排序算法:冒泡排序、直接插入排序、快速排序以及希尔排序。这些算法在数据结构与算法课程中是非常重要的基础内容,它们各自有着独特的特性和应用场景。 ### 1. ...
了解冒泡,选择,插入,希尔排序 基本的渐进分析
本主题涵盖了六种经典的排序算法:希尔排序、堆排序、快速排序、简单选择排序、插入排序和冒泡排序。这些算法各有特点,适用于不同的场景,下面将逐一详细介绍。 1. **希尔排序**:希尔排序是由Donald Shell提出的...
以下是关于"冒泡排序,选择排序,插入排序,希尔排序,堆排序,归并排序,快速排序"这七种常见排序算法的源码实现及相关知识点的详细解释: 1. **冒泡排序**:冒泡排序是一种简单的排序算法,它重复地遍历待排序的...