基础排序算法

1.冒泡排序

public void BubbleSort(int[] num)
{
      for(int i=0;i<num.Length;i++)
      {
          for(int j=0;j<num.Length-1;j++)
          {
              if(num[j]>num[j+1])
              {
                  Swap(num, j, j + 1);
              }
          }
      }
  }

2.选择排序

public void SelectionSort(int [] num)
{
    for(int i=0;i<num.Length-1;i++)
    {
        int min = i;
        for(int j=i+1;j<num.Length;j++)
        {
            if(num[j]<num[min])
            {
                min = j;
            }
        }

        if(min!=i)
        {
            Swap(num, i, min);
        }
    }
}

3.插入排序

public void InsertSort(int[] num)
{
     for(int i=1;i<num.Length;i++)
     {
         int get = num[i];
         int j = i - 1;
         while(j>=0 && num[j]>get)
         {
             num[j+1] = num[j];
             j--;
         }

         num[j + 1] = get;
     }
 }

4.希尔排序

public void ShellSort(int[] num)
{
    int h = 0;
    while(h<num.Length)
    {
        h = 3 * h + 1;
    }

    while(h>=1)
    {
        for(int i=h;i<num.Length;i++)
        {
            int get = num[i];
            int j = i - h;

            while(j>=0 && num[j]>get)
            {
                num[j + h] = num[j];
                j -= h;
            }

            num[j + h] = get;
        }
        h = (h - 1) / 3;
    }
}

5.快速排序
递归方式本质是二叉树的前序遍历

public void QuickSort(int[] num,int left,int right)
{
   if(left>right)
   {
       return;
   }

   int index = GetIndex(num, left, right);

   QuickSort(num, left, index - 1);
   QuickSort(num, index + 1, right);
}


public int GetIndex(int[] num,int left,int right)
{
   int index = num[left];

   while(left<right)
   {
       while(left<right && num[right]>=index)
       {
           right--;
       }
       num[left] = num[right];

       while(left<right && num[left]<=index)
       {
           left++;
       }

       num[right] = num[left];
   }

   num[left] = index;

   return left;
}

6.归并排序
递归的方式本质是二叉树的后续遍历

public void Merge(int[] num, int left, int mid, int right)
{
     int len = right - left + 1;
     int[] temp = new int[len];
     int index = 0;
     int i = left;
     int j = mid + 1;
     while (i <= mid && j <= right)
     {
         temp[index++] = num[i] <= num[j] ? num[i++] : num[j++];
     }

     while (i <= mid)
     {
         temp[index++] = num[i++];
     }

     while (j <= right)
     {
         temp[index++] = num[j++];
     }

     Array.Copy(temp, 0, num, left, len);
 }

 public void MergeSort(int[] num, int left, int right)
 {
     if (left == right)
     {
         return;
     }

     int mid = ((right - left) >> 1) + left;
     MergeSort(num, left, mid);
     MergeSort(num, mid + 1, right);

     Merge(num, left, mid, right);

 }

7.堆排序

public void Heapify(int[] num, int i, int size)
{
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    int max = i;

    if(left<size && num[left]>num[max])
    {
        max = left;
    }

    if(right<size && num[right]>num[max])
    {
        max = right;
    }

    if(max!=i)
    {
        Swap(num, i, max);
        Heapify(num, max, size);
    }
}

public int BuildHeap(int[] num)
{
    int len = num.Length;
    for(int i=len/2-1;i>=0;i--)
    {
        Heapify(num, i, len);
    }
    return len;
}

public void HeapSort(int[] num)
{
    int size = BuildHeap(num);
    while(size>1)
    {
        Swap(num, 0,--size);
        Heapify(num, 0, size);
    }
}
public void Swap(int[] num, int i, int j)
{
    int temp = num[i];
    num[i] = num[j];
    num[j] = temp;
}

8.计数排序

public void CountingSort(int[] num, int maxValue)
{
    int[] res = new int[maxValue];

    int sortedIndex = 0;

    int arrLength = num.Length;

    int bucketLength = maxValue;

    for (int i = 0; i < arrLength; i++)
    {
        res[num[i]]++;

    }

    for (int j = 0; j < bucketLength; j++)
    {
        while (res[j] > 0)
        {
            num[sortedIndex++] = j;
            res[j]--;
        }
    }
}

9.基数排序

public int MaxBit(int[] data, int n)
{
    int max_num = 1;
    int num = 10;
    for (int i = 0; i < n; i++)
    {
        while (data[i] >= num)
        {
            num *= 10;
            max_num++;
        }
    }
    return max_num;
}

public void RadixSort(int[] data, int n)
{
    int d = MaxBit(data, n);
    int radix = 1;
    int[] count = new int[1000];
    int[] temp = new int[1000];

    for (int i = 0; i < d; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            count[j] = 0;
        }

        for (int j = 0; j < n; j++)
        {
            int k = (data[j] / radix) % 10;
            count[k]++;
        }

        for (int j = 1; j < 10; j++)
        {
            count[j] += count[j - 1];
        }

        for (int j = n - 1; j >= 0; j--)
        {
            int k = (data[j] / radix) % 10;
            temp[count[k] - 1] = data[j];
            count[k]--;
        }

        Array.Copy(temp, 0, data, 0, n);
        radix *= 10;
    }
}

10.桶排序

public void BucketSort(int[] num)
{
    int max = num.Max();
    int min = num.Min();

    int bucketNum = (max - min) / num.Length + 1;
    List<List<int>> list = new List<List<int>>(bucketNum);

    for (int i = 0; i < bucketNum; i++)
    {
        list.Add(new List<int>());
    }


    foreach (var i in num)
    {
        int arr = (i - min) / num.Length;
        list[arr].Add(i);
    }

    for (int i = 0; i < list.Count; i++)
    {
        list[i].Sort();
    }

    int index = 0;

    for (int i = 0; i < list.Count; i++)
    {
        for (int j = 0; j < list[i].Count; j++)
        {
            num[index++] = list[i][j];
        }
    }
}