- 浏览: 78815 次
- 性别:
- 来自: 陕西
文章分类
- 全部博客 (53)
- java开发 (27)
- C# (5)
- Extjs (0)
- Python (3)
- 数据库 (5)
- Flex (3)
- Oracle (3)
- mysql (2)
- javaScript (1)
- jsp/servlet (1)
- 数据结构和算法 (6)
- spring (2)
- struts (1)
- Hibernate (3)
- Ibatis (0)
- UML (0)
- Jquery (0)
- android (0)
- 数据结构和算法,排序 (4)
- Linux (2)
- C/C++ (1)
- 工具使用 (4)
- flex,java (1)
- http://irfen.iteye.com/blog/1174699 (0)
- SEO (1)
- java (1)
最新评论
-
eagle59:
谢谢分享。。。。
java SSH面试资料 -
樊明涛:
写的很不错!perfect!
java文件操作2
package temp;
import sun.misc.Sort;
/**
* @author zengjl
* @version 1.0
* @since 2007-08-22
* @Des java几种基本排序方法
*/
/**
* SortUtil:排序方法
* 关于对排序方法的选择:这告诉我们,什么时候用什么排序最好。当人们渴望先知道排在前面的是谁时,
* 我们用选择排序;当我们不断拿到新的数并想保持已有的数始终有序时,我们用插入排序;当给出的数
* 列已经比较有序,只需要小幅度的调整一下时,我们用冒泡排序。
*/
public class SortUtil extends Sort {
/**
* 插入排序法
* @param data
* @Des 插入排序(Insertion Sort)是,每次从数列中取一个还没有取出过的数,并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序。
*/
public int[] insertSort(int[] data) {
int temp;
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
return data;
}
/**
* 冒泡排序法
* @param data
* @return
* @Des 冒泡排序(Bubble Sort)分为若干趟进行,每一趟排序从前往后比较每两个相邻的元素的大小(因此一趟排序要比较n-1对位置相邻的数)并在
* 每次发现前面的那个数比紧接它后的数大时交换位置;进行足够多趟直到某一趟跑完后发现这一趟没有进行任何交换操作(最坏情况下要跑n-1趟,
* 这种情况在最小的数位于给定数列的最后面时发生)。事实上,在第一趟冒泡结束后,最后面那个数肯定是最大的了,于是第二次只需要对前面n-1
* 个数排序,这又将把这n-1个数中最小的数放到整个数列的倒数第二个位置。这样下去,冒泡排序第i趟结束后后面i个数都已经到位了,第i+1趟实
* 际上只考虑前n-i个数(需要的比较次数比前面所说的n-1要小)。这相当于用数学归纳法证明了冒泡排序的正确性
*/
public int[] bubbleSort(int[] data) {
int temp;
for (int i = 0; i < data.length; i++) {
for (int j = data.length - 1; j > i; j--) {
if (data[j] < data[j - 1]) {
swap(data, j, j - 1);
}
}
}
return data;
}
/**
* 选择排序法
* @param data
* @return
* @Des 选择排序(SelectionSort)是说,每次从数列中找出一个最小的数放到最前面来,再从剩下的n-1个数中选择一个最小的,不断做下去。
*/
public int[] chooseSort(int[] data) {
int temp;
for (int i = 0; i < data.length; i++) {
int lowIndex = i;
for (int j = data.length - 1; j > i; j--) {
if (data[j] < data[lowIndex]) {
lowIndex = j;
}
}
swap(data, i, lowIndex);
}
return data;
}
/**
* 关于Shell排序讲解 Shell排序算法依赖一种称之为“排序增量”的数列,不同的增量将导致不同的效率。
* 假如我们对20个数进行排序,使用的增量为1,3,7。那么,我们首先对这20个数进
* 行“7-排序”(7-sortedness)。所谓7-排序,就是按照位置除以7的余数分组进行
* 排序。具体地说,我们将把在1、8、15三个位置上的数进行排序,将第2、9、16个 数进行排序,依此类推。这样,对于任意一个数字k,单看A(k),
* A(k+7), A(k+14),... 这些数是有序的。7-排序后,我们接着又进行一趟3-排序(别忘了我们使用的排序增量
* 为1,3,7)。最后进行1-排序(即普通的排序)后整个Shell算法完成。
*/
/**
* shell排序法
*
* @param data
* @return
*/
public int[] shellSort(int[] data) {
for (int i = data.length / 2; i > 2; i /= 2) {
for (int j = 0; j < i; j++) {
shellInsertSort(data, j, i);
}
}
shellInsertSort(data, 0, 1);
return data;
}
/**
* shell排序“排序增量”方法
*
* @param data
* @param start
* @param inc
*/
public void shellInsertSort(int[] data, int start, int inc) {
int temp;
for (int i = start + inc; i < data.length; i += inc) {
for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
swap(data, j, j - inc);
}
}
}
/**
* 快速排序法
*
* @param data
* @return
*/
private static int MAX_STACK_SIZE = 4096;
private static int THRESHOLD = 10;
public int[] quickSort(int[] data) {
int[] stack = new int[MAX_STACK_SIZE];
int top = -1;
int pivot;
int pivotIndex, l, r;
stack[++top] = 0;
stack[++top] = data.length - 1;
while (top > 0) {
int j = stack[top--];
int i = stack[top--];
pivotIndex = (i + j) / 2;
pivot = data[pivotIndex];
swap(data, pivotIndex, j);
// partition
l = i - 1;
r = j;
do {
while (data[++l] < pivot)
;
while ((r != 0) && (data[--r] > pivot))
;
swap(data, l, r);
} while (l < r);
swap(data, l, r);
swap(data, l, j);
if ((l - i) > THRESHOLD) {
stack[++top] = i;
stack[++top] = l - 1;
}
if ((j - l) > THRESHOLD) {
stack[++top] = l + 1;
stack[++top] = j;
}
}
// 插入排序
insertSort(data);
return data;
}
/**
* 归并排序法
*
* @param data
* @return
*/
public int[] improvedMergeSort(int[] data) {
int[] temp = new int[data.length];
mergeSort(data, temp, 0, data.length - 1);
return data;
}
/**
* 合并排序
* @param data
* @param temp
* @param l
* @param r
*/
private void mergeSort(int[] data, int[] temp, int l, int r) {
int i, j, k;
int mid = (l + r) / 2;
if (l == r)
return;
if ((mid - l) >= THRESHOLD)
mergeSort(data, temp, l, mid);
else
insertSort(data, l, mid - l + 1);
if ((r - mid) > THRESHOLD)
mergeSort(data, temp, mid + 1, r);
else
insertSort(data, mid + 1, r - mid);
for (i = l; i <= mid; i++) {
temp[i] = data[i];
}
for (j = 1; j <= r - mid; j++) {
temp[r - j + 1] = data[j + mid];
}
int a = temp[l];
int b = temp[r];
for (i = l, j = r, k = l; k <= r; k++) {
if (a < b) {
data[k] = temp[i++];
a = temp[i];
} else {
data[k] = temp[j--];
b = temp[j];
}
}
}
private void insertSort(int[] data, int start, int len) {
for (int i = start + 1; i < start + len; i++) {
for (int j = i; (j > start) && data[j] < data[j - 1]; j--) {
swap(data, j, j - 1);
}
}
}
/**
* 交换数据顺序
*
* @param data
* @param i
* @param j
*/
private void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
public static void main(String[] args){
int[] data = {-2,1,2,4,2,0,4,555,3,99};
SortUtil sort = new SortUtil();
System.out.println(System.currentTimeMillis());
data = sort.bubbleSort(data) ;
String str = "" ;
for(int i = 0 ; i < data.length ; i ++ ){
str = str + data[i]+",";
}
System.out.println(str);
System.out.println(System.currentTimeMillis());
}
}
import sun.misc.Sort;
/**
* @author zengjl
* @version 1.0
* @since 2007-08-22
* @Des java几种基本排序方法
*/
/**
* SortUtil:排序方法
* 关于对排序方法的选择:这告诉我们,什么时候用什么排序最好。当人们渴望先知道排在前面的是谁时,
* 我们用选择排序;当我们不断拿到新的数并想保持已有的数始终有序时,我们用插入排序;当给出的数
* 列已经比较有序,只需要小幅度的调整一下时,我们用冒泡排序。
*/
public class SortUtil extends Sort {
/**
* 插入排序法
* @param data
* @Des 插入排序(Insertion Sort)是,每次从数列中取一个还没有取出过的数,并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序。
*/
public int[] insertSort(int[] data) {
int temp;
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
return data;
}
/**
* 冒泡排序法
* @param data
* @return
* @Des 冒泡排序(Bubble Sort)分为若干趟进行,每一趟排序从前往后比较每两个相邻的元素的大小(因此一趟排序要比较n-1对位置相邻的数)并在
* 每次发现前面的那个数比紧接它后的数大时交换位置;进行足够多趟直到某一趟跑完后发现这一趟没有进行任何交换操作(最坏情况下要跑n-1趟,
* 这种情况在最小的数位于给定数列的最后面时发生)。事实上,在第一趟冒泡结束后,最后面那个数肯定是最大的了,于是第二次只需要对前面n-1
* 个数排序,这又将把这n-1个数中最小的数放到整个数列的倒数第二个位置。这样下去,冒泡排序第i趟结束后后面i个数都已经到位了,第i+1趟实
* 际上只考虑前n-i个数(需要的比较次数比前面所说的n-1要小)。这相当于用数学归纳法证明了冒泡排序的正确性
*/
public int[] bubbleSort(int[] data) {
int temp;
for (int i = 0; i < data.length; i++) {
for (int j = data.length - 1; j > i; j--) {
if (data[j] < data[j - 1]) {
swap(data, j, j - 1);
}
}
}
return data;
}
/**
* 选择排序法
* @param data
* @return
* @Des 选择排序(SelectionSort)是说,每次从数列中找出一个最小的数放到最前面来,再从剩下的n-1个数中选择一个最小的,不断做下去。
*/
public int[] chooseSort(int[] data) {
int temp;
for (int i = 0; i < data.length; i++) {
int lowIndex = i;
for (int j = data.length - 1; j > i; j--) {
if (data[j] < data[lowIndex]) {
lowIndex = j;
}
}
swap(data, i, lowIndex);
}
return data;
}
/**
* 关于Shell排序讲解 Shell排序算法依赖一种称之为“排序增量”的数列,不同的增量将导致不同的效率。
* 假如我们对20个数进行排序,使用的增量为1,3,7。那么,我们首先对这20个数进
* 行“7-排序”(7-sortedness)。所谓7-排序,就是按照位置除以7的余数分组进行
* 排序。具体地说,我们将把在1、8、15三个位置上的数进行排序,将第2、9、16个 数进行排序,依此类推。这样,对于任意一个数字k,单看A(k),
* A(k+7), A(k+14),... 这些数是有序的。7-排序后,我们接着又进行一趟3-排序(别忘了我们使用的排序增量
* 为1,3,7)。最后进行1-排序(即普通的排序)后整个Shell算法完成。
*/
/**
* shell排序法
*
* @param data
* @return
*/
public int[] shellSort(int[] data) {
for (int i = data.length / 2; i > 2; i /= 2) {
for (int j = 0; j < i; j++) {
shellInsertSort(data, j, i);
}
}
shellInsertSort(data, 0, 1);
return data;
}
/**
* shell排序“排序增量”方法
*
* @param data
* @param start
* @param inc
*/
public void shellInsertSort(int[] data, int start, int inc) {
int temp;
for (int i = start + inc; i < data.length; i += inc) {
for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
swap(data, j, j - inc);
}
}
}
/**
* 快速排序法
*
* @param data
* @return
*/
private static int MAX_STACK_SIZE = 4096;
private static int THRESHOLD = 10;
public int[] quickSort(int[] data) {
int[] stack = new int[MAX_STACK_SIZE];
int top = -1;
int pivot;
int pivotIndex, l, r;
stack[++top] = 0;
stack[++top] = data.length - 1;
while (top > 0) {
int j = stack[top--];
int i = stack[top--];
pivotIndex = (i + j) / 2;
pivot = data[pivotIndex];
swap(data, pivotIndex, j);
// partition
l = i - 1;
r = j;
do {
while (data[++l] < pivot)
;
while ((r != 0) && (data[--r] > pivot))
;
swap(data, l, r);
} while (l < r);
swap(data, l, r);
swap(data, l, j);
if ((l - i) > THRESHOLD) {
stack[++top] = i;
stack[++top] = l - 1;
}
if ((j - l) > THRESHOLD) {
stack[++top] = l + 1;
stack[++top] = j;
}
}
// 插入排序
insertSort(data);
return data;
}
/**
* 归并排序法
*
* @param data
* @return
*/
public int[] improvedMergeSort(int[] data) {
int[] temp = new int[data.length];
mergeSort(data, temp, 0, data.length - 1);
return data;
}
/**
* 合并排序
* @param data
* @param temp
* @param l
* @param r
*/
private void mergeSort(int[] data, int[] temp, int l, int r) {
int i, j, k;
int mid = (l + r) / 2;
if (l == r)
return;
if ((mid - l) >= THRESHOLD)
mergeSort(data, temp, l, mid);
else
insertSort(data, l, mid - l + 1);
if ((r - mid) > THRESHOLD)
mergeSort(data, temp, mid + 1, r);
else
insertSort(data, mid + 1, r - mid);
for (i = l; i <= mid; i++) {
temp[i] = data[i];
}
for (j = 1; j <= r - mid; j++) {
temp[r - j + 1] = data[j + mid];
}
int a = temp[l];
int b = temp[r];
for (i = l, j = r, k = l; k <= r; k++) {
if (a < b) {
data[k] = temp[i++];
a = temp[i];
} else {
data[k] = temp[j--];
b = temp[j];
}
}
}
private void insertSort(int[] data, int start, int len) {
for (int i = start + 1; i < start + len; i++) {
for (int j = i; (j > start) && data[j] < data[j - 1]; j--) {
swap(data, j, j - 1);
}
}
}
/**
* 交换数据顺序
*
* @param data
* @param i
* @param j
*/
private void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
public static void main(String[] args){
int[] data = {-2,1,2,4,2,0,4,555,3,99};
SortUtil sort = new SortUtil();
System.out.println(System.currentTimeMillis());
data = sort.bubbleSort(data) ;
String str = "" ;
for(int i = 0 ; i < data.length ; i ++ ){
str = str + data[i]+",";
}
System.out.println(str);
System.out.println(System.currentTimeMillis());
}
}
发表评论
-
Flex+spring+hibernate+mysql+blaze DS框架搭建
2015-04-10 09:35 783以前在项目中使用Flex+spring+hibernate ... -
java使用配置文件连接mysql
2015-04-10 09:30 886java程序中连接数据库的方式很多,有的是在程序代码中直接 ... -
http://blog.mn886.net/jqGrid/
2014-12-01 13:47 0/WEB-INF/conf/,web.xml去掉classpa ... -
java中读取服务器配置文件方法
2014-07-30 10:00 1054在程序开发和设计中,我们经常把一些需要改变的数值配置在文件中, ... -
flex 安全沙箱冲突问题
2012-08-29 17:23 2111问题出现情况: 我们采用myeclipse+spring+fl ... -
flex 使用swfLoad注意事项(转)
2012-07-25 19:38 2332var swf : SWFLoader = new SWFLo ... -
javascript获取jsf table值
2012-04-25 21:38 1311这是一个jsf 中的table,我们可以通过javascrip ... -
java 读写Excel (支持office 2007)
2012-04-25 21:21 1247/** * EXCEL文档解析工具类 该工具能将EXCEL文 ... -
java读取Excel文档
2012-02-06 16:29 1138package cn.ccb.odsbsx.common.ut ... -
java 操作csv文件
2012-02-06 16:28 1345package cn.ccb.odsbsx.common.ut ... -
Java 表单提交两种方式(网上整理)
2012-01-07 15:01 2997GET与POST的区别: 一、Get是从服务器上 ... -
java压缩文件或文件夹
2011-12-31 08:59 1095/** * @param inputFilePath ... -
分享java解析XML文件(来源于网上)
2011-12-25 15:00 10371.介绍 1)DOM(JAXP ... -
汉诺塔java算法
2011-12-23 16:15 1890package wgy; import java.io.Bu ... -
java最大子序列和算法分析
2011-12-23 15:28 1980/** * 算法一 */ public int ma ... -
java实现全排列
2011-12-21 09:16 967package wgy; import java.util. ... -
java SSH面试资料
2011-12-20 10:15 2735Java---SSH(MVC) 1. 谈谈你mvc ... -
spring面试资料
2011-12-20 10:11 1724* Spring的优点有什么? 1. Spring是分层的架 ... -
java排序算法
2011-12-18 19:48 15681.判断链表是否存在环型链表 问题:判断一个链表是否存在环,例 ... -
员工在线考试(简单)
2011-11-20 19:14 783一个简单的员工在线考试系统。
相关推荐
本文实例讲述了Java编程实现中英混合字符串数组按首字母排序的方法。分享给大家供大家参考,具体如下: 在Java中对于字符串数组的排序,我们可以使用Arrays.sort(String[])方法很便捷的进行排序。例如: String[]...
可输入的冒泡排序法~ 综合更改的版本~ java ban
Java 8 对自带的排序算法进行了很好的优化。对于整形和其他的基本类型, Arrays.sort() 综合利用了双枢轴快速排序、归并排序和启发式插入排序。这个算法是很强大的,可以在很多情况下通用。针对大规模的数组还支持更...
java课的期末作业,原型是测试排序算法的性能,并在其基础上做修改,图形化界面。 综合了文件读写、多线程技术、以进度条的形式显示排序的完成情况(当测试数据很多时)、随机生成排序数等。 用户界面: 有“输入...
密钥是一种参数,它是在明文转换为密文或将密文转换为明文的算法中输入的数据。 将秘钥容器中的所有秘钥按照f(k)升序排列,以便...数据结构综合应用、排序算法综合应用、算法设计 程序可在eclipse直接导入,亲测可用
Java数据结构与算法学习笔记之排序 冒泡排序,选择排序,插入排序,希尔排序, 归并排序, 快速排序.
包含二分法,插入法,希尔排序法,还有冒泡法和希尔排序的综合。
[MonthMaker.java] 月份表算法类 [Pallet.java] 调色板,统一配色类 Java扫雷源码 Java生成自定义控件源代码 2个目标文件 Java实现HTTP连接与浏览,Java源码下载 1个目标文件 摘要:Java源码,网络相关,HTTP ...
[MonthMaker.java] 月份表算法类 [Pallet.java] 调色板,统一配色类 Java扫雷源码 Java生成自定义控件源代码 2个目标文件 Java实现HTTP连接与浏览,Java源码下载 1个目标文件 摘要:Java源码,网络相关,HTTP ...
例如,排序片段将属于src/main/java/xyz/subho/algorithms/sort文件夹。 如果合适,您也可以创建一个新的类别文件夹。 将算法实现添加到: src/main/java/xyz/subho/algorithms/category/FooAlgorithm.
│ J2EE综合--Struts常见错误的全面汇总.txt │ java程序员面试资料.zip │ JAVA笔试题(上海释锐).pdf │ MIME简介.txt │ SCJP试题详解.pdf │ SQL面试题_心灵深处.htm │ Struts+Hibernate+Spring轻量级J2EE...
│ J2EE综合--Struts常见错误的全面汇总.txt │ java程序员面试资料.zip │ JAVA笔试题(上海释锐).pdf │ MIME简介.txt │ SCJP试题详解.pdf │ SQL面试题_心灵深处.htm │ Struts+Hibernate+Spring轻量级J2EE...
4.4.1 算法-冒泡排序113 4.4.2 插入排序115 4.5 增强for循环116 4.6 本章练习117 第5章 5.1 面向过程的设计思想120 5.2 面向对象的设计思想120 5.3 抽象121 5.3.1 对象的理解121 5.3.2 Java抽象思想的实现122 5.4 ...
│ J2EE综合--Struts常见错误的全面汇总.txt │ java程序员面试资料.zip │ JAVA笔试题(上海释锐).pdf │ MIME简介.txt │ SCJP试题详解.pdf │ SQL面试题_心灵深处.htm │ Struts+Hibernate+Spring轻量级J2EE...
而在Java类库中有一个Arrays类的sort方法已经实现各种数据类型的排序算法。程序员只需要调用该类的方法即可。 代码演示:Arrays实现排序 public static void main(String[] args) { int[] ages={23, 45,12,76,34,...
为目前企业面试最会被考到的问题,包括:java基础、多线程、常见排序算法、23种设计模式、堆栈、tomcat和jboss性能优化、JDK新特性、SSH框架、SQL数据库、面向对象设计原则等一系列综合资料。其中面试问题中内容80%...
87 5.3 数组操作的举例 88 5.3.1 数组元素值的复制 88 5.3.2 数组元素的排序 90 5.3.3 在数组里查找指定元素 91 5.3.4 利用数组打印26个英文字母 92 5.4 综合练习 93 5.5 小结 94 5.6 习题 94 第二篇 面向对象篇 第6...
第21章 Java程序综合案例:教务处管理系统 705 21.1 登录界面的设计与代码实现 705 21.2 功能选择界面的设计 708 21.3 学生信息系统界面的设计 716 21.4 教师信息系统界面的设计 727 21.5 领导信息系统界面的...
算法:搜索、排序、分治、回溯、动态规划、贪心等算法的定义、优缺点、效率、应用场景、解题步骤、示例题目等。 相较于文字,视频和图片具有更高的信息密度和结构化程度,更易于理解。在本书中,重点和难点知识将...