Java版排序竞赛最终程序汇总

最新推荐文章于 2022-12-15 15:32:49 发布
最新推荐文章于 2022-12-15 15:32:49 发布
阅读量122 收藏
点赞数
文章标签： Java J# 算法 JavaScript .net ViewUI

竞赛的历史信息地址如下

http://topic.csdn.net/u/20080623/14/23ab6317-1179-4c24-bb41-39b2d00697d5.html

 http://topic.csdn.net/u/20080624/11/55e5a350-d260-4a35-a02a-71b4c1795a00.html

源代码

package sort;

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

/**
 * CSDN 排序竞赛
 * 
 * @version 2008-06-25 17:31
 */
class Sort {
  static int MAX = 1000000;

  static int[] nums = new int[MAX];

  static Map map = new TreeMap();

  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[MAX / 4] + " " + nums[MAX / 2] + " " + nums[MAX * 3 / 4] + " " + 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_sagezk2(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_sagezk2=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    sort_superdullwolf(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_superdullwolf=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    sort_john_sheep(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_john_sheep=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    quickSort_B_Lee(nums, 0, MAX - 1);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_B_Lee2=", (end - begin), showResult()));
    //
    //
    // init();
    // begin = System.nanoTime();
    // sort_OXFORD_216(nums, 0, nums.length - 1); 在1000万的测试中发现数据错误
    // end = System.nanoTime();
    // map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_OXFORD_216=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    qSort_hmsuccess(0, MAX - 1);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "qSor_hmsuccess=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    sort_joneyonly3(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_joneyonly3=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    sort_J_Factory(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_J_Factory=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    sort_talent_marquis(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_talent_marquis=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    sort_lwouyang(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_lwouyang=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    sort_roofalison(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_roofalison=", (end - begin), showResult()));
    //
    //
    init();
    begin = System.nanoTime();
    sort_scf37(nums);
    end = System.nanoTime();
    map.put((end - begin), String.format("%20s%15d %s\r\n", "sort_scf37=", (end - begin), showResult()));
  }

  public static void quickSort_B_Lee(int[] array, int star, int end) {
    // 记录原来的位置
    int priStar = star;
    int priEnd = end;
    if (star == end) {// 只有一个元素
      return;
    } else {
      int key = array[star]; // 以第一个元素作为关键数据
      int tem = 0; // 交换数据时用所的中间变量
      while (star < end) {
        while (star < end && array[end] >= key) {// 从最后一个元素开始找第一个比key小的元素
          end--;
        }
        if (star != end) {// 两都不等，说明找到,交换
          tem = array[star];
          array[star] = array[end];
          array[end] = tem;
        }
        while (star < end && array[star] <= key) {// 从第一个元素开始找第一个比key大的元素
          star++;
        }
        if (star != end) {// 两都不等，说明找到,交换
          tem = array[star];
          array[star] = array[end];
          array[end] = tem;
        }
      }// while
      if (priStar < star - 1) { // 如果关键值不是处于第一位，则对关键值前一部分进行递归排序
        quickSort_B_Lee(array, priStar, star - 1);
      }
      if (priEnd > end + 1) { // 如果关键值不是牌最后一位，则对关键值后面的部分进行递归排序
        quickSort_B_Lee(array, end + 1, priEnd);
      }
    }
  }

  public static int[] sort_OXFORD_216(int[] nums, int left, int right) {
    int i, j;
    int middle, Temp;
    i = left;
    j = right;
    middle = nums[(i + j) / 2];
    do {
      if ((nums[i] < middle) && (i < right))
        i++;
      if ((nums[j] > middle) && (j > left))
        j--;
      else if (nums[i] >= nums[j]) {
        Temp = nums[i];
        nums[i] = nums[j];
        nums[j] = Temp;
        i++;
        j--;
      }
    } while (i <= j);
    if (left < j)
      sort_OXFORD_216(nums, left, j);
    if (right > i)
      sort_OXFORD_216(nums, i, right);
    return nums;
  }

  static void qSort_hmsuccess(int begin, int end) {
    if (begin < end) {
      int q = partition_hmsuccess(begin, end);
      qSort_hmsuccess(begin, q - 1);
      qSort_hmsuccess(q + 1, end);
    }
  }

  static int partition_hmsuccess(int begin, int end) {
    int i = begin;
    int j = end + 1;
    int firstdata = nums[begin];
    while (true) {
      while (i < end && (nums[++i] < firstdata))
        ;
      while (j > 0 && (nums[--j] > firstdata))
        ;
      if (i >= j) {
        break;
      }
      int temp;
      temp = nums[i];
      nums[i] = nums[j];
      nums[j] = temp;
    }
    nums[begin] = nums[j];
    nums[j] = firstdata;
    return j;
  }

  public static int[] sort_joneyonly(int[] nums) {
    MaxHeap_joneyonly h = new MaxHeap_joneyonly();
    h.init(nums);
    for (int i = 0; i < nums.length; i++)
      h.remove();
    System.arraycopy(h.queue, 1, nums, 0, nums.length);
    return nums;
  }

  private static class MaxHeap_joneyonly {
    void init(int[] data) {
      this.queue = new int[data.length + 1];
      for (int i = 0; i < data.length; i++) {
        queue[++size] = data[i];
        fixUp(size);
      }
    }

    private int size = 0;

    private int[] queue;

    public int get() {
      return queue[1];
    }

    public void remove() {
      swap_joneyonly(queue, 1, size--);
      fixDown(1);
    }

    private void fixDown(int k) {
      int j;
      while ((j = k << 1) <= size) {
        if (j < size && queue[j] < queue[j + 1])
          j++;
        if (queue[k] > queue[j])
          break;
        swap_joneyonly(queue, j, k);
        k = j;
      }
    }

    private void fixUp(int k) {
      while (k > 1) {
        int j = k >> 1;
        if (queue[j] > queue[k])
          break;
        swap_joneyonly(queue, j, k);
        k = j;
      }
    }
  }

  public static void swap_joneyonly(int[] data, int i, int j) {
    int temp = data[i];
    data[i] = data[j];
    data[j] = temp;
  }

  private static int MAX_STACK_SIZE_joneyonly3 = 4096;

  private static int THRESHOLD_joneyonly3 = 10;

  public static int[] sort_joneyonly3(int[] data) {
    int[] stack = new int[MAX_STACK_SIZE_joneyonly3];
    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_joneyonly3(data, pivotIndex, j);
      l = i - 1;
      r = j;
      do {
        while (data[++l] < pivot)
          ;
        while ((r != 0) && (data[--r] > pivot))
          ;
        swap_joneyonly3(data, l, r);
      } while (l < r);
      swap_joneyonly3(data, l, r);
      swap_joneyonly3(data, l, j);
      if ((l - i) > THRESHOLD_joneyonly3) {
        stack[++top] = i;
        stack[++top] = l - 1;
      }
      if ((j - l) > THRESHOLD_joneyonly3) {
        stack[++top] = l + 1;
        stack[++top] = j;
      }
    }
    insertSort_joneyonly3(data);
    return data;
  }

  private static void insertSort_joneyonly3(int[] data) {
    for (int i = 1; i < data.length; i++) {
      for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
        swap_joneyonly3(data, j, j - 1);
      }
    }
  }

  public static void swap_joneyonly3(int[] data, int i, int j) {
    int temp = data[i];
    data[i] = data[j];
    data[j] = temp;
  }

  public static int[] sort_john_sheep(int[] nums) {
    int max = getMax_john_sheep(nums) + 1;
    int[] temp = new int[max];
    for (int i : nums) {
      temp[i]++;
    }
    int pos = 0;
    for (int i = 0; i < max; i++) {
      if (temp[i] > 0) {
        for (int l = 0; l < temp[i]; l++)
          nums[pos++] = i;
      }
    }
    return nums;
  }

  private static int getMax_john_sheep(int[] data) {
    int max = 0;
    for (int i : data) {
      if (i > max) {
        max = i;
      }
    }
    return max;
  }

  public static int[] sort_J_Factory(int[] nums) {
    // 您的排序代码放在这里啦
    quickSort_J_Factory(nums, 0, nums.length - 1);
    return nums;
  }

  private static int partity_J_Factory(int array[], int first, int last) {
    int s1last = first;
    int start = first;
    int poitle = array[first++];
    int temp;
    while (first - 1 < last) {
      if (poitle <= array[first]) {
        first++;
      } else {
        temp = array[first];
        array[first] = array[s1last + 1];
        array[++s1last] = temp;
        first++;
      }
    }
    if (s1last >= 0) {
      temp = array[s1last];
      array[s1last] = poitle;
      array[start] = temp;
    }
    return s1last;
  }

  public static void quickSort_J_Factory(int[] array, int first, int last) {
    if (first < last) {
      int poite = partity_J_Factory(array, first, last);
      quickSort_J_Factory(array, first, poite - 1);
      quickSort_J_Factory(array, poite + 1, last);
    }
  }

  public static int[] sort_sagezk(int[] nums) {
    // 您的排序代码放在这里啦
    quickSort_sagezk(nums, 0, nums.length - 1);
    return nums;
  }

  private static void quickSort_sagezk(int[] a, int lo, int hi) {
    int lot = lo;
    int hit = hi;
    int mid;
    if (hi > lo) {
      mid = a[(lo + hi) / 2];
      while (lot <= hit) {
        while ((lot < hi) && (a[lot] < mid))
          ++lot;
        while ((hit > lo) && (a[hit] > mid))
          --hit;
        if (lot <= hit) {
          int t = a[lot];
          a[lot] = a[hit];
          a[hit] = t;
          ++lot;
          --hit;
        }
      }
      if (lo < hit)
        quickSort_sagezk(a, lo, hit);
      if (lot < hi)
        quickSort_sagezk(a, lot, hi);
    }
  }

  private static int[] resultData_talent_marquis;

  public static int[] sort_talent_marquis(int[] numsP) {
    // 您的排序代码放在这里啦
    resultData_talent_marquis = new int[nums.length];
    countingSort_talent_marquis(nums, resultData_talent_marquis, getMaxInt_talent_marquis(nums));
    nums = resultData_talent_marquis;
    return nums;
  }

  private static int getMaxInt_talent_marquis(int[] data) {
    int max = 0;
    for (int i : data) {
      if (i > max) {
        max = i;
      }
    }
    return max;
  }

  private static void countingSort_talent_marquis(int[] oriData, int[] resultData, int k) {
    int[] assistData = new int[k + 1];
    for (int i = 0; i < assistData.length; i++) {
      assistData[i] = 0;
    }
    for (int j = 0; j < oriData.length; j++) {
      assistData[oriData[j]] = assistData[oriData[j]] + 1;
    }
    for (int i = 1; i < assistData.length; i++) {
      assistData[i] = assistData[i] + assistData[i - 1];
    }
    for (int j = oriData.length - 1; j >= 0; j--) {
      resultData[assistData[oriData[j]] - 1] = oriData[j];
      assistData[oriData[j]] = assistData[oriData[j]] - 1;
    }
  }

  public static int[] sort_lwouyang(int[] nums) {
    int max = MAX / 2; // 不会猜不中吧?! 真猜不中的话立马去买彩票!! ^_^
    int[] temp = new int[nums.length];
    for (int i : nums) {
      temp[i]++;
      if (i > max)
        max = i;
    }
    int pos = 0;
    for (int i = 0; i <= max; i++)
      for (int l = 0; l < temp[i]; l++)
        nums[pos++] = i;
    return nums;
  }

  public static int[] sort_roofalison(int[] nums) {
    // 您的排序代码放在这里啦
    int[] flag = new int[nums.length + 1];
    for (int i = 0; i < nums.length; ++i)
      ++flag[nums[i]];
    int ct = 0;
    for (int i = 0; i < nums.length; ++i)
      while (flag[i]-- > 0)
        nums[ct++] = i;
    return nums;
  }

  public static int[] sort_scf37(int[] nums) {
    int max = nums.length;
    int i, j;
    int[] temp = new int[max];
    for (i = 0; i < max;) {
      temp[nums[i++]]++;
    }
    int pos = 0;
    for (i = 0; i < max; ++i) {
      for (j = 0; j < temp[i]; ++j) {
        nums[pos++] = i;
      }
    }
    return nums;
  }

  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;
  }

  public static void sort_superdullwolf(int[] a) {
    int MaxRange = a.length;
    int[] p = new int[MaxRange + 1];
    // for (int i = 0; i <= MaxRange; i++) {
    // p[i] = 0;
    // }
    for (int i = 0; i < MaxRange; i++) {
      p[a[i]]++;
    }
    for (int i = 0, j = 0; i <= MaxRange; i++) {
      while (p[i] > 0) {
        a[j++] = i;
        p[i]--;
      }
    }
  }
}

竞赛结果

根据综合表现，决定奖励人员如下

1talent_marquis 许多人借鉴了他的算法，且最受大家尊敬，而且提出了更好的建议 http://topic.csdn.net/u/20080624/12/1f8a6a2d-0e2a-4cc6-a6bf-747de44626f8.html

2 john_sheeping 算法最稳定，且没有漏洞，而且非常活跃

以上二人分享600专家分，决定每人300，不再排名

3 SageZk

4 scf37

5 sort_superdullwolf

以上三名每人分得100专家分。







<script type="text/javascript"> </script> <script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript"> </script>
java2000_test
关注
2022届校招Java面试题汇总(含题解)
JE_9664的博客
08-30 1万+
本文将笔者在面试中遇到的真实题目汇总成集，初衷是为了每次面试完能够及时复盘，以便查漏补缺。此外，如果能给他人以参考也是好的。
2024-JAVA-大数据-面试汇总_大数据java部门面试(2)
最新发布
2401_84141419的博客
04-27 745
RDD就是弹性分布式数据集，可以理解为一种数据结构，拥有多种不同的RDD算子。
竞赛技巧（简单排序）
moyangxian
05-21 1166
链接：https://ac.nowcoder.com/acm/problem/15056 来源：牛客网 题目描述 在ACM竞赛中，当遇到有两个队伍（人） 解出相同的题目数量的时候，我们需要通过他们解决问题的总时间进行排序。 一共有 N(1<=N<=5,000)条时间被以时(0<=Hours<=99)， 分(0<=Minutes<=59)，秒(0<=Seconds<=59)的形式记录。 你必须要把他们按时，分，秒排序为 升序，最少的时间最先。 考虑到如下的样例，
C++ 竞赛排序
_Gion
08-16 1299
选择、冒泡、桶排、快排、插入、希尔 排序
算法竞赛——快速排序
Switch的博客
05-29 913
算法竞赛——快速排序快速排序算法和归并排序算法都可以用分治法的思想来解决，其区别是归并排序是等份左右划分，而快速排序则是按标兵进行划分，也不需要合并。 分治三步骤 划分问题：按标兵元素，将序列分成左右两部分，左边序列全小于等于标兵元素，右边序列全大于等于标兵元素。递归求解：把左右两部分分别排序。合并问题：不用合并，因为容器内元素已然有序。 算法实现// 快速排序算法 void qSort(int *
竞赛训练3 排序：Bubble Sort
qq_41644834的博客
09-19 190
竞赛训练3 排序：Bubble Sort 题目来源：《挑战程序设计竞赛》 题目：顾名思义，冒泡排序就是让元素像水中的气泡一样逐渐上浮，进而达到排序的目的。请编写一个程序，读取数列A，利用冒泡排序将其按升序排序并输出。另外，请报告冒泡排序执行元素交换的次数。 输入：在第一行输入定义数组长度的整数N。在第二行输入N个整数，以空格隔开。 输出：输出总计2行。请在第一行输出排序后的数列。数列相邻元素用一个...
java程序设计项目案例化教程题库及答案
m0_63394128的博客
08-04 5911
1、 Java源程序文件的后缀是 *.java ，Java字节码文件的后缀名称是 *.class 。2、 Java程序实现可移值性，依靠的是 JVM 。3、 Java语言的三个分支是： JAVA SE 、 JAVA ME 、 JAVA EE 。4、 Java程序由 类 组成，如果Java使用 public class 声明类，则文件名称必须与类名称一致。5、 Java执行是从 main() 方法开始执行的，此方法的完整定
护理管理学选择题汇总(人卫第三版)
qq_67692062的博客
09-27 1787
护理管理学选择题第一章：绪论 一、单选题： C 1、组织职能的主要内容包括( ) A、计划与总结、人员配备、规划与变动、授权 B、结构设计、计划与总结、规划与变动、授权C、结构设计、人员配备、规划与变动、授权 D、结构设计、人员配备、计划与总结、授权 B 2、领导工作是一种行为活动，领导工作成功的关键在于( ) A、精打细算、善于沟通、善于激励 B、善于沟通、善于激励、善于用人C、精打细算、善于激励、善于用人
lightgbm java_开源|LightGBM基本原理，以及调用形式
weixin_33050117的博客
02-19 723
久前微软 DMTK (分布式机器学习工具包)团队在 GitHub 上开源了性能超越其他 boosting 工具的 LightGBM知乎上有近千人关注“如何看待微软开源的 LightGBM？”问题，被评价为“速度惊人”，“非常有启发”，“支持分布式”，“代码清晰易懂”，“占用内存小”等。GBDT ：GBDT (Gradient Boosting Decision Tree) 是机器学习中一个长盛不衰...
大学生常见竞赛重要程度排序情况
snail9610的博客
06-21 3252
第一类 “互联网+”大学生创新创业大赛; “挑战杯”大学生课外学术科技作品竞赛； “创青春”大学生创业大赛; 全国大学生数学建模竞赛； 全国大学生电子设计竞赛; 国际大学生数学建模竞赛; 第二类 山东省机电产品创新大赛 中国机器人大赛暨RoboCup公开赛 全国大学生电工数学建模竞赛（不知道是什么） 全国大学生数学竞赛 ACM程序设计竞赛 全国大学生英语竞赛 第三类 全国大学生“飞思卡尔”杯智能汽车竞赛 “电脑鼠走迷宫”竞赛 “高教杯”全国大学生先进成图技术与产品信息建模创新大赛 山东省大学生汽车技
算法竞赛中常用的排序和查找算法
不负AC不负卿的博客
02-06 1431
本文详细给出了快速排序、归并排序、sort自定义排序的代码模板，以及二分查找的代码模板。能解决你99%的疑惑
算法竞赛中常用的排序算法
qq_62004235的博客
11-01 436
算法竞赛中排序算法
【竞赛】排序算法的最快实现
superdullwolf的专栏
07-22 1626
 【竞赛】排序算法的最快实现 C# code using System; namespace ConsoleApplication1 {     class Program     {         static int MaxRange = 20080623;         static void Main(string[] args)         {             T
常用几种排序方法
i_kun_的博客
12-15 155
常用几种排序方法
信息学奥赛中常用的六种排序算法
小马的博客
10-04 5395
六种排序算法一、冒泡排序1.基本思想2.排序过程3.程序实现4.改进后的冒泡排序5.说明二、选择排序1.基本思想2. 排序过程3.程序实现5.说明三、插入排序1.基本思想 一、冒泡排序 1.基本思想 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走...
Java程序实现大量数据排序功能
由于描述中提到了对输入数据进行排序，我们可以推断该程序可能涉及到数据的读取、内存中的排序处理以及最终输出排序后的数据。 在实际应用中，对于排序大规模数据集，Java程序员可能会面临几个挑战： 1. 数据量超出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值