class Program
  {
  static void Main(string[] args)
  {
  int[] a = new int[] { 34, 25, 634, 234, 32, 9, 42 };
  RadixSort(a);
  foreach (int n in a)
  {
  Console.WriteLine(n);
  }
  Console.ReadKey();
  }
  /// <summary>
  /// 1.插入排序（按顺序遍历数组中的数，把他和前面的数比较，如果比他大就放到他前面，直到遇到比他小的数）
  /// </summary>
  public static void InsertSort(int[] array)
  {
  for (int i = 1; i < array.Length; i++)
  {
  if (array[i] < array[i - 1])
  {
  int temp = array[i];
  int j;
  for (j = i - 1; j >= 0 && temp < array[j]; j--)
  {
  array[j + 1] = array[j];
  }
  array[j + 1] = temp;
  }
  }
  }
  /// <summary>
  /// 2.冒泡排序（每次循环把最大的数放到最后一个）
  /// </summary>
  public static void BubbleSort(int[] array)
  {
  for (int i = 0; i < array.Length; i++)
  {
  for (int j = 0; j < array.Length - 1 - i; j++)
  {
  if (array[j] > array[j + 1])
  {
  int temp = array[j];
  array[j] = array[j + 1];
  array[j + 1] = temp;
  }
  }

  }
  }
  /// <summary>
  /// 3.快速排序（以中间数为基准，比他小的放左边，比他大的放右边，在对左边右边递归）
  /// </summary>
  public static void QuickSort(int[] array, int left, int right)
  {
  if (left < right)
  {
  int middle = array[(left + right) / 2];
  int i = left - 1;
  int j = right + 1;
  while (true)
  {
  while (array[++i] < middle && i < right) ;
  while (array[--j] > middle && j > left) ;
  if (i >= j)
  break;
  int temp = array[i];
  array[i] = array[j];
  array[j] = temp;
  }
  QuickSort(array, left, i - 1);//递归
  QuickSort(array, j + 1, right);
  }
  }
  /// <summary>
  /// 4.希尔排序（分组的插入排序）
  /// </summary>
  public static void ShellSort(int[] array)
  {
  int length = array.Length;
  for (int h = length / 2; h > 0; h = h / 2)
  {
  for (int i = h; i < length; i++)
  {
  int temp = array[i];
  if (temp < array[i - h])
  {
  for (int j = 0; j < i; j += h)
  {
  if (temp < array[j])
  {
  temp = array[j];
  array[j] = array[i];
  array[i] = temp;
  }
  }
  }
  }
  }
  }
  /// <summary>
  /// 5.简单选择排序（选出最小的数放在依次放在数组中）
  /// </summary>
  public static void SimpleSelectSort(int[] array)
  {
  int tmp = 0;
  int t = 0;
  for (int i = 0; i < array.Length; i++)
  {
  t = i;
  for (int j = i + 1; j < array.Length; j++)
  {
  if (array[t] > array[j])
  {
  t = j;
  }
  }
  tmp = array[i];
  array[i] = array[t];
  array[t] = tmp;
  }
  }
  /// <summary>
  /// 6.堆排序(排序把最大的数移到堆首，堆首堆尾交换，重新排序)
  /// </summary>
  public static void HeapSort(int[] array, int top)
  {
  List<int> topNode = new List<int>();
  for (int i = array.Length / 2 - 1; i >= 0; i--)
  {
  HeapAdjust(array, i, array.Length);
  }
  for (int i = array.Length - 1; i >= array.Length - top; i--)
  {
  int temp = array[0];
  array[0] = array[i];
  array[i] = temp;
  HeapAdjust(array, 0, i);
  }
  }
  /// <summary>
  /// 构建堆（大根堆，每次根节点和子节点交换，该子节点的大根堆结构会发生变化）
  /// </summary>
  private static void HeapAdjust(int[] array, int parent, int length)
  {
  int temp = array[parent];
  int child = 2 * parent + 1;
  while (child < length)
  {
  if (child + 1 < length && array[child] < array[child + 1])
  {
  child++;
  }
  if (temp >= array[child])
  {
  break;
  }
  array[parent] = array[child];
  parent = child;
  child = 2 * parent + 1;
  }
  array[parent] = temp;
  }
  /// <summary>
  /// 7.归并排序（递归二分成最小树，比较左子树和右子树，较小的加入数组）
  /// </summary>
  public static void MergeSort(int[] array, int first, int last)
  {
  if (first + 1 < last)
  {
  int mid = (first + last) / 2;
  MergeSort(array, first, mid);
  MergeSort(array, mid, last);
  Merger(array, first, mid, last);
  }
  }
  /// <summary>
  /// 归并
  /// </summary>
  private static void Merger(int[] array, int first, int mid, int last)
  {
  Queue<int> tempV = new Queue<int>();
  int indexA, indexB;
  indexA = first;
  indexB = mid;
  while (indexA < mid && indexB < last)
  {
  if (array[indexA] < array[indexB])
  {
  tempV.Enqueue(array[indexA]);
  indexA++;
  }
  else
  {
  tempV.Enqueue(array[indexB]);
  indexB++;
  }
  }
  while (indexA < mid)
  {
  tempV.Enqueue(array[indexA]);
  indexA++;
  }
  while (indexB < last)
  {
  tempV.Enqueue(array[indexB]);
  indexB++;
  }
  int index = 0;
  while (tempV.Count > 0)
  {
  array[first + index] = tempV.Dequeue();
  index++;
  }
  }
  /// <summary>
  /// 8.基数排序（个位余数筛选，十位余数筛选。。）
  /// </summary>
  public static void RadixSort(int[] array, int array_x = 10, int array_y = 100)
  {
  for (int i = 0; i < array_x; i++)
  {
  int[,] bucket = new int[array_x, array_y];
  foreach (var item in array)
  {
  int temp = (item / (int)Math.Pow(10, i)) % 10;
  for (int j = 0; j < array_y; j++)
  {
  if (bucket[temp, j] == 0)
  {
  bucket[temp, j] = item;
  break;
  }
  }
  }
  for (int o = 0, x = 0; x < array_x; x++)
  {
  for (int y = 0; y < array_y; y++)
  {
  if (bucket[x, y] == 0) continue;
  array[o++] = bucket[x, y];
  }
  }
  }
  }```