【竞赛】排序算法的最快实现-继续

[老紫竹]

由于早上帖子不能访问，我只能忍痛结掉了。并根据现有的成绩分配了积分。

澄清一下这个竞赛的目的，是为了大家共同拿到几个排序的好的算法，注意是几个，而不是一个。
在不同的情况下，各个算法的表现是不同的。

新的测试代码可以自行定义测试的次数和随机的种子。 可以对测试结果自动排序。
下面给出新的测试代码框架。

完整代码太长，需要的请到这里获取， 其中包括已经在另一个帖子给出算法的测试。 http://blog.zhaoxq.java2000.net/v16

package sort;

import java.util.Arrays;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;

/**
 * CSDN 排序竞赛
 * @version 2008-06-24 07:31
 */
class TestSort {
  static int MAX = 1000000; // 最大数据量

  static int[] nums = new int[MAX]; // 特意移到类一级，免得他们需要时没有这个

  static Map<Long, String> map = new TreeMap<Long, String>(); // 排序的结果，纳秒为单位了。

  static long seed = 20080623;

  private static void init() {
    Random r = new Random(seed);
    for (int i = 0; i < MAX; i++) {
      nums[i] = r.nextInt(MAX);
    }
  }

  private static String showResult() { // 这里随便选了几个进行排序结果的测试
    return nums[1] + " " + nums[1234] + " " + nums[23456] + " " + nums[67890] + " " + nums[MAX - 1];
  }

  public static void main(String[] args) {
    Random ran = new Random();
    for (int i = 1; i <= 1; i++) { // 此处定义循环测试的次数
      seed = ran.nextInt(999999999);
      test();
    }
    for (String str : map.values()) {
      System.out.print(str);
    }
  }

  public static void test() {
    long begin;
    long end;
    //
    // 测试代码框架开始
    init();
    begin = System.nanoTime();
    sort_JDK(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_JDK=", (end - begin), showResult()));
    // 测试代码框架结束



    // 其它的测试代码将按照顺序逐个放到后面进行测试。
    // 某些方法没有使用我提供的标准调用，造成我手工修改，引起不必要的问题。
    // 请大家查看我测试的完整代码，并根据你的需求进行完善与修改。

   }
  public static int[] sort_JDK(int[] nums) {
    Arrays.sort(nums);
    return nums;
  }
}

请大家整理好自己的算法帖子，命名方法为
public static int[] sort_${CSDN_USERNAME}(int[] nums)
比如
public static int[] sort_java2000_net(int[] nums)
public static int[] sort_talent_marquis(int[] nums) {

[andy6277]

顶个再说

[ILOVEYOULOVEME]

[Quote=引用 149 楼 rightyeah 的回复:]
没创意的比赛！！！
首先是lz出的题不好，用随机数发生器产生整数也就罢了，居然还弄得数组长度和数值上界一样，更可恶的是一个个都用桶排序，还号称“排序算法的最快实现”，改天你们都用桶排序去排序浮点数给我看看！
[/Quote]

很有道理!
而且以上给的五个排序的思想是一样的，只是写法不同而已。。。。。。。。

[yqw945]

记号，学习！

[gristotle]

学习

[nsdcomputer]

引用代码：

 public static int[] sort_sagezk2(int[] nums) {
    final int LEN = nums.length;
    int i, j, t, p;
    int[] temp = new int[LEN];
    for (i = 0; i < LEN;) {
      temp[nums[i++]]++;
    }
    for (i = 0, p = 0; i < LEN; ++i) {
      if ((t = temp[i]) == 0)
        continue;
      for (j = 0; j < t; ++j) {
        nums[p++] = i;
      }
    }
    return nums;
  }

感觉几种高效的算法中，都是采用了hash思路，但是感觉会有溢出的危险，呵呵：

...
final int LEN = nums.length;
...
int[] temp = new int[LEN];
...
temp[nums[i++]]++;    //这里有点危险

但是具体情况具体分析，这里的危险就像lwouyang所说的

不会猜不中吧?! 真猜不中的话立马去买彩票!! ^_^

=========
个人鄙建，如有不妥，请批评!!

[lzycsd]

mark

[hn1232]

这帖子有意思，好好研究研究！

[hudielei45]

来学习的 现在还没有看懂

[goosman]

哇. 我来的好迟啊, 我这个500万数据1700毫秒....

package selfimpr.datastruct.highsort;

public class QuickSort {
	public static int copyCount = 0;
	public static int compareCount = 0;
	public static void sort(long[] array) {
		sort(array, 0, array.length-1);
	}

	public static void sort(long[] array, int left, int right) {
		if(right - left <= 0) return ;
		long division = array[right];
		int partitionIndex = partition(array, division, left, right);
		sort(array, left, partitionIndex - 1);
		sort(array, partitionIndex + 1, right);
	}
	
	public static void optimizeSort(long[] array, int left, int right) {
		if(right - left <= 0) return ;
		compareCount ++;
		long division = (array[left] + array[right] + array[(left+right)/2])/3;
		int partitionIndex = partition(array, division, left, right);
		sort(array, left, partitionIndex - 1);
		sort(array, partitionIndex + 1, right);
	}
	
	public static int partition(long[] array, long division, int left, int right) {
		int leftPointer = left-1;
		int rightPointer = right;
		while(true) {
			while(array[++leftPointer] < division) {
				compareCount ++;
			}
			while(rightPointer > left && array[--rightPointer] > division) {
				compareCount ++;
			}
			if(leftPointer < rightPointer) {
				swap(array, leftPointer, rightPointer);
			} else {
				break;
			}
		}
		swap(array, leftPointer, right);
		return leftPointer;
	}

	private static void swap(long[] array, int leftPointer, int rightPointer) {
		long temp = array[leftPointer];
		array[leftPointer] = array[rightPointer];
		array[rightPointer] = temp;
		copyCount += 3;
	}
}

[potahai]

留名学习

[lyn0032]

查找算法呀 有比二分查找更快的方法吗

[xiangchuwang]

全是数字的话 有线性时间的算法

[zhengbiao5]

这种竞赛很好~
希望多举办，甚至定期举办搞成联赛

[C271579305]

密切关注

[windwuya]

学习！

[望舒]

import java.util.Random;

class T {
  public static void main(String[] args) {
    int MAX = 100000;
    int[] nums = new int[MAX];
    Random r = new Random(20080623);
    for (int i = 0; i < MAX; i++) {
      nums[i] = r.nextInt(MAX);
    }
    long begin = System.currentTimeMillis();
    sort(nums);
    long end = System.currentTimeMillis();
    System.out.println((end - begin)); // 以这个时间为标准，越小越好。
      }

  public static int[] sort(int[] nums) {
    // 您的排序代码放在这里啦
	  int[] t=new int[20080623];
	  for(int i:nums){
		  t[i]++;
	  }
	  int index=0;
	  for(int z=0;z<t.length;z++){
		  if(t[z]!=0){
			  int b=t[z];
			  while(b>0){
				  nums[index++]=z;
				  b--;
			  }
		  }
	  }
    return nums;
  }
}

[lliiqiang]

时间可以等，空间不够了就是不够了

[shizieeeee]

哪位大神能帮我编一下这个程序，要用数据结构的，急用~~谢谢了~~~~邮箱：[e-mail]

找出下列数的规律：
4，6，9，10，14，15，21，22，25，26，33，34，35，38，39，…
试编写算法，求：
(1) 输入数字n，求出第n个数；
(2) 输入任意数m，判断与m最接近的数在第几项？
请分别用顺序结构与链式结构实现你的算法，并分析算法的时间复杂度。
哪位大神能帮我编一下这个程序，要用数据结构的，急用~~谢谢了~~~~邮箱：[e-mail]

[lovezx1028]

顶贴！！！！

[合肥歌瑞森小雪]

关注 ...............