JAVA编程：用Java完成几种罕见的排序算法

为什么外国人还要写那些框架进行代码封装，他们不就是为了别人使用时可以更简单么！如果要达到一个企业级项目的不用框架是很难的。小一些的项目还行，大的光是MVC模式的设计的编码量就够大的了。还有性能方面，单轮windows，这个工具是微软写的，。排序|算法　　用Java言语完成的各类排序，包含拔出排序、冒泡排序、选择排序、Shell排序、疾速排序、合并排序、堆排序、SortUtil等。拔出排序：
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;
/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassInsertSortimplementsSortUtil.Sort{

/*(non-Javadoc)
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
inttemp;
for(inti=1;i<data.length;i++){
for(intj=i;(j>0)&&(data[j]<data[j-1]);j--){
SortUtil.swap(data,j,j-1);
}
}
}

}
冒泡排序：
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassBubbleSortimplementsSortUtil.Sort{

/*(non-Javadoc)
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
inttemp;
for(inti=0;i<data.length;i++){
for(intj=data.length-1;j>i;j--){
if(data[j]<data[j-1]){
SortUtil.swap(data,j,j-1);
}
}
}
}

}
选择排序：
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassSelectionSortimplementsSortUtil.Sort{

/*
*(non-Javadoc)
*
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
inttemp;
for(inti=0;i<data.length;i++){
intlowIndex=i;
for(intj=data.length-1;j>i;j--){
if(data[j]<data[lowIndex]){
lowIndex=j;
}
}
SortUtil.swap(data,i,lowIndex);
}
}

}
Shell排序：
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassShellSortimplementsSortUtil.Sort{

/*(non-Javadoc)
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
for(inti=data.length/2;i>2;i/=2){
for(intj=0;j<i;j++){
insertSort(data,j,i);
}
}
insertSort(data,0,1);
}

/**
*@paramdata
*@paramj
*@parami
*/
privatevoidinsertSort(int[]data,intstart,intinc){
inttemp;
for(inti=start+inc;i<data.length;i+=inc){
for(intj=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){
SortUtil.swap(data,j,j-inc);
}
}
}

}
疾速排序：
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassQuickSortimplementsSortUtil.Sort{

/*(non-Javadoc)
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
quickSort(data,0,data.length-1);
}
privatevoidquickSort(int[]data,inti,intj){
intpivotIndex=(i+j)/2;
file://swap
SortUtil.swap(data,pivotIndex,j);

intk=partition(data,i-1,j,data[j]);
SortUtil.swap(data,k,j);
if((k-i)>1)quickSort(data,i,k-1);
if((j-k)>1)quickSort(data,k+1,j);

}
/**
*@paramdata
*@parami
*@paramj
*@return
*/
privateintpartition(int[]data,intl,intr,intpivot){
do{
while(data[++l]<pivot);
while((r!=0)&&data[--r]>pivot);
SortUtil.swap(data,l,r);
}
while(l<r);
SortUtil.swap(data,l,r);
returnl;
}

}
改善后的疾速排序：
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassImprovedQuickSortimplementsSortUtil.Sort{

privatestaticintMAX_STACK_SIZE=4096;
privatestaticintTHRESHOLD=10;
/*(non-Javadoc)
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
int[]stack=newint[MAX_STACK_SIZE];

inttop=-1;
intpivot;
intpivotIndex,l,r;

stack[++top]=0;
stack[++top]=data.length-1;

while(top>0){
intj=stack[top--];
inti=stack[top--];

pivotIndex=(i+j)/2;
pivot=data[pivotIndex];

SortUtil.swap(data,pivotIndex,j);

file://partition
l=i-1;
r=j;
do{
while(data[++l]<pivot);
while((r!=0)&&(data[--r]>pivot));
SortUtil.swap(data,l,r);
}
while(l<r);
SortUtil.swap(data,l,r);
SortUtil.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;
}

}
file://newInsertSort().sort(data);
insertSort(data);
}
/**
*@paramdata
*/
privatevoidinsertSort(int[]data){
inttemp;
for(inti=1;i<data.length;i++){
for(intj=i;(j>0)&&(data[j]<data[j-1]);j--){
SortUtil.swap(data,j,j-1);
}
}
}

}
合并排序：
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassMergeSortimplementsSortUtil.Sort{

/*(non-Javadoc)
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
int[]temp=newint[data.length];
mergeSort(data,temp,0,data.length-1);
}

privatevoidmergeSort(int[]data,int[]temp,intl,intr){
intmid=(l+r)/2;
if(l==r)return;
mergeSort(data,temp,l,mid);
mergeSort(data,temp,mid+1,r);
for(inti=l;i<=r;i++){
temp[i]=data[i];
}
inti1=l;
inti2=mid+1;
for(intcur=l;cur<=r;cur++){
if(i1==mid+1)
data[cur]=temp[i2++];
elseif(i2>r)
data[cur]=temp[i1++];
elseif(temp[i1]<temp[i2])
data[cur]=temp[i1++];
else
data[cur]=temp[i2++];
}
}

}
改善后的合并排序:
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassImprovedMergeSortimplementsSortUtil.Sort{

privatestaticfinalintTHRESHOLD=10;

/*
*(non-Javadoc)
*
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
int[]temp=newint[data.length];
mergeSort(data,temp,0,data.length-1);
}

privatevoidmergeSort(int[]data,int[]temp,intl,intr){
inti,j,k;
intmid=(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];
}
inta=temp[l];
intb=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];
}
}
}

/**
*@paramdata
*@paraml
*@parami
*/
privatevoidinsertSort(int[]data,intstart,intlen){
for(inti=start+1;i<start+len;i++){
for(intj=i;(j>start)&&data[j]<data[j-1];j--){
SortUtil.swap(data,j,j-1);
}
}
}
}
堆排序：
packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassHeapSortimplementsSortUtil.Sort{

/*(non-Javadoc)
*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])
*/
publicvoidsort(int[]data){
MaxHeaph=newMaxHeap();
h.init(data);
for(inti=0;i<data.length;i++)
h.remove();
System.arraycopy(h.queue,1,data,0,data.length);
}

privatestaticclassMaxHeap{

voidinit(int[]data){
this.queue=newint[data.length+1];
for(inti=0;i<data.length;i++){
queue[++size]=data[i];
fixUp(size);
}
}

privateintsize=0;

privateint[]queue;

publicintget(){
returnqueue[1];
}

publicvoidremove(){
SortUtil.swap(queue,1,size--);
fixDown(1);
}
file://fixdown
privatevoidfixDown(intk){
intj;
while((j=k<<1)<=size){
if(j<size&&queue[j]<queue[j+1])
j++;
if(queue[k]>queue[j])file://不必互换
break;
SortUtil.swap(queue,j,k);
k=j;
}
}
privatevoidfixUp(intk){
while(k>1){
intj=k>>1;
if(queue[j]>queue[k])
break;
SortUtil.swap(queue,j,k);
k=j;
}
}

}

}
SortUtil：
packageorg.rut.util.algorithm;

importorg.rut.util.algorithm.support.BubbleSort;
importorg.rut.util.algorithm.support.HeapSort;
importorg.rut.util.algorithm.support.ImprovedMergeSort;
importorg.rut.util.algorithm.support.ImprovedQuickSort;
importorg.rut.util.algorithm.support.InsertSort;
importorg.rut.util.algorithm.support.MergeSort;
importorg.rut.util.algorithm.support.QuickSort;
importorg.rut.util.algorithm.support.SelectionSort;
importorg.rut.util.algorithm.support.ShellSort;

/**
*@authortreeroot
*@since2006-2-2
*@version1.0
*/
publicclassSortUtil{
publicfinalstaticintINSERT=1;
publicfinalstaticintBUBBLE=2;
publicfinalstaticintSELECTION=3;
publicfinalstaticintSHELL=4;
publicfinalstaticintQUICK=5;
publicfinalstaticintIMPROVED_QUICK=6;
publicfinalstaticintMERGE=7;
publicfinalstaticintIMPROVED_MERGE=8;
publicfinalstaticintHEAP=9;

publicstaticvoidsort(int[]data){
sort(data,IMPROVED_QUICK);
}
privatestaticString[]name={
"insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"
};

privatestaticSort[]impl=newSort[]{
newInsertSort(),
newBubbleSort(),
newSelectionSort(),
newShellSort(),
newQuickSort(),
newImprovedQuickSort(),
newMergeSort(),
newImprovedMergeSort(),
newHeapSort()
};

publicstaticStringtoString(intalgorithm){
returnname[algorithm-1];
}

publicstaticvoidsort(int[]data,intalgorithm){
impl[algorithm-1].sort(data);
}

publicstaticinterfaceSort{
publicvoidsort(int[]data);
}

publicstaticvoidswap(int[]data,inti,intj){
inttemp=data[i];
data[i]=data[j];
data[j]=temp;
}
}

还是要自己一点一点写代码，然后编译，改错再编译好那。还有最重要的是.net的编译环境非常好，你甚是不需要了解太多工具，对于简单的系统，你可以之了解一些语法就哦了。

Java是一种计算机编程语言，拥有跨平台、面向对java

你一定会高兴地说，哈哈，原来成为Java高手就这么简单啊!记得Tomjava也曾碰到过一个项目经理，号称Java很简单，只要三个月就可以学会。

Java是一个纯的面向对象的程序设计语言，它继承了 C++语言面向对象技术的核心。Java舍弃了C ++语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）

所以现在应用最广泛又最好学的就是J2EE了。 J2EE又包括许多组件，如Jsp,Servlet,JavaBean,EJB,JDBC,JavaMail等。要学习起来可不是一两天的事。那么又该如何学习J2EE呢？当然Java语法得先看一看的，I/O包，Util包，Lang包你都熟悉了吗？然后再从JSP学起。

Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

一般学编程语言都是从C语开始学的，我也不例外，但还是可能不学过程语言而直接学面向对象语言的，你是刚接触语言，还是从C开始学比较好，基础会很深点，如果你直接学习JAVA也能上手，一般大家在学语言的时候都记一些语言的关键词，常有的包和接口等。再去做逻辑代码的编写，以后的学习过程都是从逻辑代码编写中提升的，所以这方面都是经验积累的。你要开始学习就从

应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展

一直感觉JAVA很大，很杂，找不到学习方向，前两天在网上找到了这篇文章，感觉不错，给没有方向的我指了一个方向，先不管对不对，做下来再说。