写过的代码：基数排序

主要的类：

//基数排序

import java.util.*;

public class RadixSort3 {
    // 数据
    /*
     * HashMap<Integer,LinkedList<Integer>> map = new
     * HashMap<Integer,LinkedList<Integer>>() ; LinkedList<Integer> list0 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list1 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list2 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list3 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list4 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list5 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list6 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list7 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list8 = new
     * LinkedList<Integer>() ; LinkedList<Integer> list9 = new
     * LinkedList<Integer>() ;
     */
    HashMap<Integer, FirstLastList> map = new HashMap<Integer, FirstLastList>();
    FirstLastList[] list = new FirstLastList[10];

    // 方法
    // --------------------------------------------------
    public RadixSort3() {
        /*
         * map.put(0,list0) ; map.put(1,list1) ; map.put(2,list2) ;
         * map.put(3,list3) ; map.put(4,list4) ; map.put(5,list5) ;
         * map.put(6,list6) ; map.put(7,list7) ; map.put(8,list8) ;
         * map.put(9,list9) ;
         */
        // 初始化链表
        for (int i = 0; i < 10; i++)
            list[i] = new FirstLastList();
        // 将链表插入到映射中
        for (int i = 0; i < 10; i++)
            map.put(i, list[i]);

    }

    // --------------------------------------------------
    // 基数排序
    public void radixSort(long[] array) {
        int digit;// 记录当前的位数
        int figure;// 记录当前位数所指定的数字
        int maxSize = getMaxSize(array);// 存储数组中最大数的位数
        for (digit = 1; digit <= maxSize; digit++) {
            // 把各个数插入到符合的链表
            for (int index = 0; index < array.length; index++) {
                figure = getDigit(digit, array[index]);
                putIntoList(figure, array[index]);
            }
            // 把链表中的值返回到数组中
            returnIntoArray(array);
        }
    }

    // --------------------------------------------------
    // 显示数组
    public void displayArray(long[] array) {
        for (int index = 0; index < array.length; index++)
            System.out.print(array[index] + " ");
        System.out.println();
    }

    // ---------------------------------------
    // 返回各位数
    private int getDigit(int digit, long number) {
        /*
         * 假设最大位数为5位 switch(digit) { case 1:return ((int)(number%10)) ; case
         * 2:return ((int)(number/10)%10) ; case 3:return ((int)(number/100)%10)
         * ; case 4:return ((int)(number/1000)%10) ; case 5:return
         * ((int)(number/10000)) ; }
         */
        for (int k = 1; k < digit; k++)
            number = number / 10;
        return (int) number % 10;
    }

    // -----------------------------------------
    // 把数据插入到链表中
    private void putIntoList(int figure, long number) {
        switch (figure) {
        case 0:
            list[0].insertLast(number);
            break;
        case 1:
            list[1].insertLast(number);
            break;
        case 2:
            list[2].insertLast(number);
            break;
        case 3:
            list[3].insertLast(number);
            break;
        case 4:
            list[4].insertLast(number);
            break;
        case 5:
            list[5].insertLast(number);
            break;
        case 6:
            list[6].insertLast(number);
            break;
        case 7:
            list[7].insertLast(number);
            break;
        case 8:
            list[8].insertLast(number);
            break;
        case 9:
            list[9].insertLast(number);
            break;
        }
    }

    // ----------------------------------------------------
    // 将数据返回到数组中
    public void returnIntoArray(long[] array) {
        // LinkedList<Integer> list ;
        FirstLastList list;
        int flag = -1;
        for (int i = 0; i < 10; i++) {
            list = (map.get(i));
            // Object data = list.pollFirst() ;

            while (!list.isEmpty()) {
                array[++flag] = list.deleteFirst();
            }
        }
    }

    // ----------------------------------------------------
    // 返回数组中最大的那个值的位数
    public int getMaxSize(long[] array) {
        // 找到最大数
        long max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i])
                max = array[i];
        }
        /*
         * if(max>10000&&max<100000) return 5 ; else if(max>1000) return 4 ;
         * else if(max>100) return 3 ; else return (max>10?2:1) ;
         */
        int count = 0;
        while (max != 0) {
            max = max / 10;
            count++;
        }
        return count;
    }
}

辅助的类：

class FirstLastList {
    private Link first; // ref to first link
    private Link last; // ref to last link
    // -------------------------------------------------------------

    public FirstLastList() // constructor
    {
        first = null; // no links on list yet
        last = null;
    }

    // -------------------------------------------------------------
    public boolean isEmpty() // true if no links
    {
        return first == null;
    }

    // -------------------------------------------------------------
    public void insertFirst(long dd) // insert at front of list
    {
        Link newLink = new Link(dd); // make new link

        if (isEmpty()) // if empty list,
            last = newLink; // newLink <-- last
        newLink.next = first; // newLink --> old first
        first = newLink; // first --> newLink
    }

    // -------------------------------------------------------------
    public void insertLast(long dd) // insert at end of list
    {
        Link newLink = new Link(dd); // make new link
        if (isEmpty()) // if empty list,
            first = newLink; // first --> newLink
        else
            last.next = newLink; // old last --> newLink
        last = newLink; // newLink <-- last
    }

    // -------------------------------------------------------------
    public long deleteFirst() // delete first link
    { // (assumes non-empty list)
        long temp = first.dData;
        if (first.next == null) // if only one item
            last = null; // null <-- last
        first = first.next; // first --> old next
        return temp;
    }

    // -------------------------------------------------------------
    public void displayList() {
        System.out.print("List (first-->last): ");
        Link current = first; // start at beginning
        while (current != null) // until end of list,
        {
            current.displayLink(); // print data
            current = current.next; // move to next link
        }
        System.out.println("");
    }
    // -------------------------------------------------------------
} // end class FirstLastList

class Link
{
public long dData;                 // data item
public Link next;                  // next link in list
//-------------------------------------------------------------
public Link(long d)                // constructor
   { dData = d; }
//-------------------------------------------------------------
public void displayLink()          // display this link
   { System.out.print(dData + " "); }
//-------------------------------------------------------------
}  // end class Link

测试类：

//测试程序
public class RadixSort3App
{
  public static void main(String[] agrs)
  {
      RadixSort3 test = new RadixSort3() ;
      long[] array = new long[10];
      //int[] array = {412,240,35,532,305,430,124,1000,1234,98423,12345} ;
      //插入十个随机数
      int value ;
      for(int i=0 ; i<10;i++)
      {
          value = (int)(Math.random()*100000) ;
          array[i] = value ;
      }
      System.out.println("排序前：") ;
      test.displayArray(array) ;
      test.radixSort(array) ;
      System.out.println("排序后：") ;
      test.displayArray(array) ;
  }
}

//测试大数据
import java.util.* ;
public class RadixSortApp2
{
  public static void main(String[] agrs)
  {
      RadixSort3 test = new RadixSort3() ;
      long[] array ;
      int value ;
      int maxSize = 10000 ;
      System.out.println("【基数排序】") ;
      System.out.println("数组大小——>时间(ms)") ;
      while(maxSize<=100000)
      {
          array = new long[maxSize] ;
          System.out.print(maxSize+"——>") ;
          for(int i=0 ; i<maxSize ;i++)
          {
             value = (int)(Math.random()*100000) ;
             array[i] = value ;
          }
          Date before = new Date() ;
          test.radixSort(array) ;
          Date after = new Date() ;
          long time = after.getTime() - before.getTime() ;
          System.out.println(time) ;
          maxSize += 10000 ;
      }
  }
}