BlogJava-爱女孩的小火柴-文章分类-算法和数据结构

对Java中四种基本排序的总结

my — Thu, 13 Sep 2007 03:12:00 GMT

作者：佚名文章来源：net 点击数：471 更新时间：2007-7-25 8:23:52

JAVA四种基本排序,包括冒泡法,插入法,选择法,SHELL排序法.其中选择法是冒泡法的改进,SHELL排序法是插入法的改进.所以从根本上来说可以归纳为两种不同的排序方法:即:插入法＆冒泡法

一插入法:

遍历排序集合，每到一个元素时，都要将这个元素与所有它之前的元素遍历比较一遍，让符合排序顺序的元素挨个移动到当前范围内它最应该出现的位置。交换是相邻遍历移动，双重循环控制实现.这种排序法属于地头蛇类型,在我的地牌上我要把所有的东西按一定的顺序规整,过来一个,规整一个.

处理代码如下:

public void sort(int[] data) {
                        int temp;
                        for(int i=1; i〈data.length; i++){
                        for(int j=i; (j〉0)&&(data[j]〉data[j-1]); j--){
                        temp=date[j];
                        data[j]=data[j-1];
                        data[j-1]=temp; }
                        }
                        }

二冒泡法:

比较容易，它的内层循环保证遍历一次后，集合中最小（大）元素出现在它的正确位置，下一次就是次小元素。。。该方法在集合分布的各种情况下交换移动的次数基本不变，属于最慢的一种排序。实现也是双重循环控制。这种排序法属于过江龙,就是要找到极端,但是过奖龙也有大哥,二哥等,所以他们只能是大哥挑了二哥挑.

处理代码如下:

public static int [] maopao(int[] data) {
                        int temp;
                        for(int i=0; i〈data.length-1; i++){
                        for(int j=i+1; j〈data.length; j++){
                        if(data[i]〈data[j]){
                        temp=data[i];
                        data[i]=data[j];
                        data[j]=temp;
                        }
                        }
                        }
                        return data;

三选择法:

该方法只是通过遍历集合记录最小（大）元素的位置，一次遍历完后，再进行交换位置操作，类似冒泡，但在比较过程中，不进行交换操作，只记录元素位置。一次遍历只进行一次交换操作。这个对与交换次序比较费时的元素比较适合。这种排序法比冒泡法要城府要深的多,我先记住极端数据,待遍历数据完了之后,我再处理,不像冒泡法那样只要比自己极端一点的就要处理,选择法只处理本身范围内的最极端数据.

public static void xuanze(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;
                        }
                        }
                        temp=data[i];
                        data[i]=data[lowIndex];
                        data[lowIndex]=temp;
                        }
                        }

四 Shell排序：

它是对插入排序的一种改进，是考虑将集合元素按照一定的基数划分成组去排序，让每一组在局部范围内先排成基本有序，最后在进行一次所有元素的插入排序。

public void sort(int[] data) {
                        for(int i=data.length/2; i〉2; i/=2){
                        for(int j=0; j〈i; j++){
                        insertSort(data,j,i);
                        }
                        }
                        insertSort(data,0,1);
                        }
                        private void insertSort(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){
                        temp=data[j];
                        data[j]=data[j-inc]
                        data[j-inc]=temp;
                        }
                        }
                        }

my 2007-09-13 11:12 发表评论

有104瓶啤酒，每3个空瓶子能换一瓶新啤酒，问能喝到多少瓶啤酒？

my — Tue, 29 May 2007 02:08:00 GMT

/*有104瓶啤酒，每3个空瓶子能换一瓶新啤酒，问能喝到多少瓶啤酒？//递归算法*/
class Test
{
int sum=104;//开始喝的104瓶啤酒
int nullsum=104;//空酒瓶

public static void main(String[] args)
{
  Test test = new Test();
  test.printSum();
}

public void printSum(){
  System.out.println("可以喝到"+getSum()+"瓶酒");

}

public int getSum(){
  int tmp=0;
     if(nullsum>=3){
    tmp=nullsum/3;//喝了多少瓶
    sum+=tmp;
    nullsum=nullsum%3;//还剩多少空瓶子
                nullsum+=tmp;
    getSum();
  }
  else{
      System.out.println("最后剩余空瓶子"+nullsum);
  }
  return sum;

}
}
//问题是当剩2个空瓶子的时候，如果老板肯借一瓶给你就可以多喝一瓶，呵呵

my 2007-05-29 10:08 发表评论

常用的排序算法zz

my — Mon, 28 May 2007 07:49:00 GMT

排序算法在程序中会用到很多，这里介绍几种常见的排序方法以及比较

冒泡排序：对一个队列里的数据，挨个进行轮询和交换，每次轮询出一个当前最大或者最小的值放在队尾，然后继续下次轮询，轮询长度-1，就跟冒泡一样，所以称为冒泡排序，运算时间复杂度N平方

选择排序：对一个队列里的数据，选出当前最大或者最小的值，然后将他与队首的数据交换，然后从第二个开始，进行相同的操作，运算时间复杂度N平方，但由于他不像冒泡一样需要不停的交换位置，所以会比冒泡快一些

插入排序：对一个队列里的数据，从第二个开始，与此位置之前的数据进行比较，形成局部有序的队列，循环此操作，直到队尾，运算时间复杂度依然为N平方，但他由于保证了局部的有序性，所以比较的次数会更少一些，相对前两种会更快

希尔排序：其实就是用步长控制的插入排序，希尔排序通过加大插入排序中元素之间的间隔，并在这些有间隔的元素中进行插入排序，从而让数据项可以大幅度移动，这样的方式可以使每次移动之后的数据离他们在最终序列中的位置相差不大，保证数据的基本有序，大大提升了排序速度，运算时间复杂度N*logN

快速排序：对一个队列，以他队尾的数据为基准值，先划分成两块数据，一块都大于这个值，一块小于这个值，然后对这两块进行同样的操作，这是最快的排序方法，运算时间复杂度N*logN

下面是代码：

public static void sort(int[] a)
{
  long time1,time2;
  int c;
  time1=System.currentTimeMillis();
//  /*冒泡排序*/
//  for(int i=a.length-1;i>1;i--)
//  {
//   for(int j=0;j//   {
//
//    if(a[j]//    {
//     c=a[j];
//     a[j]=a[j+1];
//     a[j+1]=c;
//    }
//   }
//  }
//  /*选择排序*/
//  int pos=0;
//  for(int i=0;i//  {
//   for(int j=i;j//   {
//    if(a[pos]//     pos=j+1;
//   }
//   c=a[i];
//   a[i]=a[pos];
//   a[pos]=c;
//   pos=i+1;
//  }
//  /*插入排序*/
//  for(int i=1;i//  {
//   c=a[i];
//   int m=i-1;
//   while(m>=0&&a[m]//   {
//    a[m+1]=a[m];
//    m--;
//   }
//   a[m+1]=c;
//  }
//  /*希尔排序*/
//  int h=1;
//  int m=0;
//  while(3*h+1//   h=3*h+1;
//  while(h>0)
//  {
//   for(int i=h;i//   {
//    c=a[i];
//    m=i-h;
//    while(m>=0&&a[m]//    {
//     a[m+h]=a[m];
//     m-=h;
//    }
//    a[m+h]=c;
//
//   }
//   h=(h-1)/3;
//  }
  /*快速排序*/
  provide(a,0,a.length-1);
  time2=System.currentTimeMillis();
  System.out.println("time:"+(time2-time1));
}
/*递归调用划分*/
public static void provide(int[] a,int left,int right)
{
  try
  {
   if(right<=left)
    return;
   else
   {
    /*设置基准点*/
    int prov=a[right];
    /*取得划分中断点*/
    int par=partitionIt(a,left,right,prov);
    /*对划分后的两边再次划分*/
    provide(a,left,par-1);
    provide(a,par+1,right);

   }
  }
  catch(Exception e)
  {
   System.out.println("eer:"+left+"."+right);
  }
}
/*划分算法*/
public static int partitionIt(int[] a,int left,int right,int prov)
{
  /*设置左右端点的指针*/
  int leftP=left-1;
  int rightP=right;
  int c;//用于交换的中间变量
  /*当左右指针未相遇时继续操作*/
  while(leftP  {
   /*当左指针的数据小于基准值时跳出*/
   while(leftPprov)
    ;
   /*当右指针的数据大于基准值时跳出*/
   while(rightP>leftP&&a[--rightP]    ;
   /*左右指针都停下时交换数据*/
   c=a[leftP];
   a[leftP]=a[rightP];
   a[rightP]=c;
  }
  /*划分结束，将基准点与指针的相遇点交换*/
  c=a[rightP];
  a[rightP]=a[right];
  a[right]=c;
  return leftP;
}

my 2007-05-28 15:49 发表评论