C#

随机数据生成

 public static void IntArrayGenerate (int[] data, int randomSeed)
      {
         Random r = new Random (randomSeed);
         for (int i=0; i < data.Length; i++)
            data [i] = r.Next ();
      }

IntArrayGenerate中的公共静态void（int[]数据，int randomSeed）
{
随机r=新随机（随机种子）；
for（int i=0；i

以下是一些算法，您可以按照这些算法以编程方式对列表进行排序

气泡排序

 public static void IntArrayBubbleSort (int[] data)
  {
     int i, j;
     int N = data.Length;

     for (j=N-1; j>0; j--) {
        for (i=0; i<j; i++) {
           if (data [i] > data [i + 1])
              exchange (data, i, i + 1);
        }
     }
  }

 public static int IntArrayMin (int[] data, int start)
      {
         int minPos = start; 
         for (int pos=start+1; pos < data.Length; pos++)
            if (data [pos] < data [minPos])
               minPos = pos;
         return minPos; 
      }

      public static void IntArraySelectionSort (int[] data)
      {
         int i;
         int N = data.Length;

         for (i=0; i < N-1; i++) {
            int k = IntArrayMin (data, i);
            if (i != k)
               exchange (data, i, k);
         }
      }

 public static void IntArrayInsertionSort (int[] data)
      {
         int i, j;
         int N = data.Length;

         for (j=1; j<N; j++) {
            for (i=j; i>0 && data[i] < data[i-1]; i--) {
               exchange (data, i, i - 1);
            }
         }
      }

   static int[] GenerateIntervals (int n)
  {
     if (n < 2) {  // no sorting will be needed
        return new int[0];
     }
     int t = Math.Max (1, (int)Math.Log (n, 3) - 1);
     int[] intervals = new int[t];       
     intervals [0] = 1;
     for (int i=1; i < t; i++)
        intervals [i] = 3 * intervals [i - 1] + 1;
     return intervals;
  }

  public static void IntArrayShellSortBetter (int[] data)
  {
     int[] intervals = GenerateIntervals (data.Length);
     IntArrayShellSort (data, intervals);
  }

  public static void IntArrayQuickSort (int[] data, int l, int r)
      {
         int i, j;
         int x;

         i = l;
         j = r;

         x = data [(l + r) / 2]; /* find pivot item */
         while (true) {
            while (data[i] < x)
               i++;
            while (x < data[j])
               j--;
            if (i <= j) {
               exchange (data, i, j);
               i++;
               j--;
            }
            if (i > j)
               break;
         }
         if (l < j)
            IntArrayQuickSort (data, l, j);
         if (i < r)
            IntArrayQuickSort (data, i, r);
      }

      public static void IntArrayQuickSort (int[] data)
      {
         IntArrayQuickSort (data, 0, data.Length - 1);
      }

公共静态无效IntArrayBubbleSort（int[]数据）
{
int i，j；
int N=数据长度；
对于（j=N-1；j>0；j--）{
对于（i=0；i数据[i+1]）
交换（数据，i，i+1）；
}
}
}

选择排序

 public static void IntArrayBubbleSort (int[] data)
  {
     int i, j;
     int N = data.Length;

     for (j=N-1; j>0; j--) {
        for (i=0; i<j; i++) {
           if (data [i] > data [i + 1])
              exchange (data, i, i + 1);
        }
     }
  }

 public static int IntArrayMin (int[] data, int start)
      {
         int minPos = start; 
         for (int pos=start+1; pos < data.Length; pos++)
            if (data [pos] < data [minPos])
               minPos = pos;
         return minPos; 
      }

      public static void IntArraySelectionSort (int[] data)
      {
         int i;
         int N = data.Length;

         for (i=0; i < N-1; i++) {
            int k = IntArrayMin (data, i);
            if (i != k)
               exchange (data, i, k);
         }
      }

 public static void IntArrayInsertionSort (int[] data)
      {
         int i, j;
         int N = data.Length;

         for (j=1; j<N; j++) {
            for (i=j; i>0 && data[i] < data[i-1]; i--) {
               exchange (data, i, i - 1);
            }
         }
      }

   static int[] GenerateIntervals (int n)
  {
     if (n < 2) {  // no sorting will be needed
        return new int[0];
     }
     int t = Math.Max (1, (int)Math.Log (n, 3) - 1);
     int[] intervals = new int[t];       
     intervals [0] = 1;
     for (int i=1; i < t; i++)
        intervals [i] = 3 * intervals [i - 1] + 1;
     return intervals;
  }

  public static void IntArrayShellSortBetter (int[] data)
  {
     int[] intervals = GenerateIntervals (data.Length);
     IntArrayShellSort (data, intervals);
  }

  public static void IntArrayQuickSort (int[] data, int l, int r)
      {
         int i, j;
         int x;

         i = l;
         j = r;

         x = data [(l + r) / 2]; /* find pivot item */
         while (true) {
            while (data[i] < x)
               i++;
            while (x < data[j])
               j--;
            if (i <= j) {
               exchange (data, i, j);
               i++;
               j--;
            }
            if (i > j)
               break;
         }
         if (l < j)
            IntArrayQuickSort (data, l, j);
         if (i < r)
            IntArrayQuickSort (data, i, r);
      }

      public static void IntArrayQuickSort (int[] data)
      {
         IntArrayQuickSort (data, 0, data.Length - 1);
      }

公共静态int IntArrayMin（int[]数据，int开始）
{
int minPos=开始；
用于（int pos=start+1；pos

插入排序

 public static void IntArrayBubbleSort (int[] data)
  {
     int i, j;
     int N = data.Length;

     for (j=N-1; j>0; j--) {
        for (i=0; i<j; i++) {
           if (data [i] > data [i + 1])
              exchange (data, i, i + 1);
        }
     }
  }

 public static int IntArrayMin (int[] data, int start)
      {
         int minPos = start; 
         for (int pos=start+1; pos < data.Length; pos++)
            if (data [pos] < data [minPos])
               minPos = pos;
         return minPos; 
      }

      public static void IntArraySelectionSort (int[] data)
      {
         int i;
         int N = data.Length;

         for (i=0; i < N-1; i++) {
            int k = IntArrayMin (data, i);
            if (i != k)
               exchange (data, i, k);
         }
      }

 public static void IntArrayInsertionSort (int[] data)
      {
         int i, j;
         int N = data.Length;

         for (j=1; j<N; j++) {
            for (i=j; i>0 && data[i] < data[i-1]; i--) {
               exchange (data, i, i - 1);
            }
         }
      }

   static int[] GenerateIntervals (int n)
  {
     if (n < 2) {  // no sorting will be needed
        return new int[0];
     }
     int t = Math.Max (1, (int)Math.Log (n, 3) - 1);
     int[] intervals = new int[t];       
     intervals [0] = 1;
     for (int i=1; i < t; i++)
        intervals [i] = 3 * intervals [i - 1] + 1;
     return intervals;
  }

  public static void IntArrayShellSortBetter (int[] data)
  {
     int[] intervals = GenerateIntervals (data.Length);
     IntArrayShellSort (data, intervals);
  }

  public static void IntArrayQuickSort (int[] data, int l, int r)
      {
         int i, j;
         int x;

         i = l;
         j = r;

         x = data [(l + r) / 2]; /* find pivot item */
         while (true) {
            while (data[i] < x)
               i++;
            while (x < data[j])
               j--;
            if (i <= j) {
               exchange (data, i, j);
               i++;
               j--;
            }
            if (i > j)
               break;
         }
         if (l < j)
            IntArrayQuickSort (data, l, j);
         if (i < r)
            IntArrayQuickSort (data, i, r);
      }

      public static void IntArrayQuickSort (int[] data)
      {
         IntArrayQuickSort (data, 0, data.Length - 1);
      }

IntArrayInsertionSort中的公共静态无效（int[]数据）
{
int i，j；
int N=数据长度；
对于（j=1；j0&&data[i]

Shell排序

 public static void IntArrayBubbleSort (int[] data)
  {
     int i, j;
     int N = data.Length;

     for (j=N-1; j>0; j--) {
        for (i=0; i<j; i++) {
           if (data [i] > data [i + 1])
              exchange (data, i, i + 1);
        }
     }
  }

 public static int IntArrayMin (int[] data, int start)
      {
         int minPos = start; 
         for (int pos=start+1; pos < data.Length; pos++)
            if (data [pos] < data [minPos])
               minPos = pos;
         return minPos; 
      }

      public static void IntArraySelectionSort (int[] data)
      {
         int i;
         int N = data.Length;

         for (i=0; i < N-1; i++) {
            int k = IntArrayMin (data, i);
            if (i != k)
               exchange (data, i, k);
         }
      }

 public static void IntArrayInsertionSort (int[] data)
      {
         int i, j;
         int N = data.Length;

         for (j=1; j<N; j++) {
            for (i=j; i>0 && data[i] < data[i-1]; i--) {
               exchange (data, i, i - 1);
            }
         }
      }

   static int[] GenerateIntervals (int n)
  {
     if (n < 2) {  // no sorting will be needed
        return new int[0];
     }
     int t = Math.Max (1, (int)Math.Log (n, 3) - 1);
     int[] intervals = new int[t];       
     intervals [0] = 1;
     for (int i=1; i < t; i++)
        intervals [i] = 3 * intervals [i - 1] + 1;
     return intervals;
  }

  public static void IntArrayShellSortBetter (int[] data)
  {
     int[] intervals = GenerateIntervals (data.Length);
     IntArrayShellSort (data, intervals);
  }

  public static void IntArrayQuickSort (int[] data, int l, int r)
      {
         int i, j;
         int x;

         i = l;
         j = r;

         x = data [(l + r) / 2]; /* find pivot item */
         while (true) {
            while (data[i] < x)
               i++;
            while (x < data[j])
               j--;
            if (i <= j) {
               exchange (data, i, j);
               i++;
               j--;
            }
            if (i > j)
               break;
         }
         if (l < j)
            IntArrayQuickSort (data, l, j);
         if (i < r)
            IntArrayQuickSort (data, i, r);
      }

      public static void IntArrayQuickSort (int[] data)
      {
         IntArrayQuickSort (data, 0, data.Length - 1);
      }

静态int[]生成间隔（int n）
{
如果（n<2）{//则不需要排序
返回新整数[0]；
}
int t=Math.Max（1，（int）Math.Log（n，3）-1）；
int[]间隔=新的int[t]；
区间[0]=1；
for（int i=1；i

快速排序也称为分区排序

 public static void IntArrayBubbleSort (int[] data)
  {
     int i, j;
     int N = data.Length;

     for (j=N-1; j>0; j--) {
        for (i=0; i<j; i++) {
           if (data [i] > data [i + 1])
              exchange (data, i, i + 1);
        }
     }
  }

 public static int IntArrayMin (int[] data, int start)
      {
         int minPos = start; 
         for (int pos=start+1; pos < data.Length; pos++)
            if (data [pos] < data [minPos])
               minPos = pos;
         return minPos; 
      }

      public static void IntArraySelectionSort (int[] data)
      {
         int i;
         int N = data.Length;

         for (i=0; i < N-1; i++) {
            int k = IntArrayMin (data, i);
            if (i != k)
               exchange (data, i, k);
         }
      }

 public static void IntArrayInsertionSort (int[] data)
      {
         int i, j;
         int N = data.Length;

         for (j=1; j<N; j++) {
            for (i=j; i>0 && data[i] < data[i-1]; i--) {
               exchange (data, i, i - 1);
            }
         }
      }

   static int[] GenerateIntervals (int n)
  {
     if (n < 2) {  // no sorting will be needed
        return new int[0];
     }
     int t = Math.Max (1, (int)Math.Log (n, 3) - 1);
     int[] intervals = new int[t];       
     intervals [0] = 1;
     for (int i=1; i < t; i++)
        intervals [i] = 3 * intervals [i - 1] + 1;
     return intervals;
  }

  public static void IntArrayShellSortBetter (int[] data)
  {
     int[] intervals = GenerateIntervals (data.Length);
     IntArrayShellSort (data, intervals);
  }

  public static void IntArrayQuickSort (int[] data, int l, int r)
      {
         int i, j;
         int x;

         i = l;
         j = r;

         x = data [(l + r) / 2]; /* find pivot item */
         while (true) {
            while (data[i] < x)
               i++;
            while (x < data[j])
               j--;
            if (i <= j) {
               exchange (data, i, j);
               i++;
               j--;
            }
            if (i > j)
               break;
         }
         if (l < j)
            IntArrayQuickSort (data, l, j);
         if (i < r)
            IntArrayQuickSort (data, i, r);
      }

      public static void IntArrayQuickSort (int[] data)
      {
         IntArrayQuickSort (data, 0, data.Length - 1);
      }

数组快速排序中的公共静态void（int[]数据，int l，int r）
{
int i，j；
int x；
i=l；
j=r；
x=数据[（l+r）/2]；/*查找轴项目*/
while（true）{
while（数据[i]

随机数据生成

 public static void IntArrayGenerate (int[] data, int randomSeed)
      {
         Random r = new Random (randomSeed);
         for (int i=0; i < data.Length; i++)
            data [i] = r.Next ();
      }

IntArrayGenerate中的公共静态void（int[]数据，int randomSeed）
{
随机r=新随机（随机种子）；
for（int i=0；i

试试这个！这种方法将按升序缩短列表

        List<int> lst = new List<int>() { 2, 3, 1, 0, 5 };

        int j=0;

        while (j < lst.Count)
        {
            for (int i = lst.Count - 1; i >= 0; i--)
            {
                if ((i - 1) >= 0 && lst[i] < lst[i - 1])
                {
                    int temp = lst[i];
                    lst[i] = lst[i - 1];
                    lst[i - 1] = temp;
                }

            }
            j++;
        }

List lst=newlist（）{2,3,1,0,5}；
int j=0；
而（j<1次计数）
{
对于（int i=l.Count-1；i>=0；i--）
{
如果（（i-1）>=0&&lst[i]

试试这个！这种方法将按升序缩短列表

        List<int> lst = new List<int>() { 2, 3, 1, 0, 5 };

        int j=0;

        while (j < lst.Count)
        {
            for (int i = lst.Count - 1; i >= 0; i--)
            {
                if ((i - 1) >= 0 && lst[i] < lst[i - 1])
                {
                    int temp = lst[i];
                    lst[i] = lst[i - 1];
                    lst[i - 1] = temp;
                }

            }
            j++;
        }

List lst=newlist（）{2,3,1,0,5}；
int j=0；
而（j<1次计数）
{
对于（int i=l.Count-1；i>=0；i--）
{
如果（（i-1）>=0&&lst[i]

在将问题提交stackoverflow之前，请使用谷歌。只需选择维基百科上最简单、易于使用的复制粘贴排序算法……如果这是家庭作业，那么你至少应该拥有开始学习所需的所有信息（教科书、课堂讲课等）。然后，当你在做什么时遇到一个特定的问题，回来问一个新问题。请在将你的问题放到stackoverflow上之前使用google。只需选择你在Wikipedia上找到的最简单且易于使用的复制粘贴排序算法……如果这是家庭作业，那么你应该拥有你需要的所有信息（课本、课堂讲座等）至少开始。然后，当你对你正在做的事情有具体问题时，回来问一个新问题。选择最佳答案是因为它最容易理解。选择最佳答案是因为它最容易理解。