单链表C#中的基数排序

public class ListNode
{
    public int Value { get; set; }
    public ListNode Next { get; set; }

    public ListNode(int value)
    {
        Value = value;
        Next = null;
    }
}

public class LinkedList
{
    private ListNode head;

    public LinkedList()
    {
        head = null;
    }

    public void Add(int value)
    {
        ListNode newNode = new ListNode(value);
        if (head == null)
        {
            head = newNode;
        }
        else
        {
            ListNode current = head;
            while (current.Next != null)
            {
                current = current.Next;
            }
            current.Next = newNode;
        }
    }

    public void Print()
    {
        ListNode current = head;
        while (current != null)
        {
            Console.Write(current.Value + " ");
            current = current.Next;
        }
        Console.WriteLine();
    }

    // 基数排序
    public void RadixSort()
    {
        if (head == null || head.Next == null)
        {
            return;
        }

        int maxDigit = GetMaxDigit();
        for (int i = 1; i <= maxDigit; i++)
        {
            ListNode[] buckets = new ListNode[10];
            ListNode current = head;
            while (current != null)
            {
                int digit = GetDigit(current.Value, i);
                if (buckets[digit] == null)
                {
                    buckets[digit] = current;
                }
                else
                {
                    ListNode tail = buckets[digit];
                    while (tail.Next != null)
                    {
                        tail = tail.Next;
                    }
                    tail.Next = current;
                }
                current = current.Next;
            }

            head = null;
            ListNode last = null;
            for (int j = 0; j < 10; j++)
            {
                if (buckets[j] != null)
                {
                    if (head == null)
                    {
                        head = buckets[j];
                    }
                    else
                    {
                        last.Next = buckets[j];
                    }
                    last = GetTail(buckets[j]);
                }
            }
            last.Next = null;
        }
    }

    // 获取链表中的最大位数
    private int GetMaxDigit()
    {
        int maxDigit = 0;
        ListNode current = head;
        while (current != null)
        {
            int digit = GetDigitCount(current.Value);
            if (digit > maxDigit)
            {
                maxDigit = digit;
            }
            current = current.Next;
        }
        return maxDigit;
    }

    // 获取一个数的指定位数上的数字
    private int GetDigit(int number, int digit)
    {
        return (number / (int)Math.Pow(10, digit - 1)) % 10;
    }

    // 获取一个数的位数
    private int GetDigitCount(int number)
    {
        if (number == 0)
        {
            return 1;
        }
        return (int)Math.Floor(Math.Log10(Math.Abs(number)) + 1);
    }

    // 获取链表的尾节点
    private ListNode GetTail(ListNode node)
    {
        ListNode tail = node;
        while (tail.Next != null)
        {
            tail = tail.Next;
        }
        return tail;
    }
}

LinkedList list = new LinkedList();
list.Add(170);
list.Add(45);
list.Add(75);
list.Add(90);
list.Add(802);
list.Add(24);
list.Add(2);
list.Add(66);
list.Print(); // 输出：170 45 75 90 802 24 2 66
list.RadixSort();
list.Print(); // 输出：2 24 45 66 75 90 170 802