C#各种数组排序方法介绍

1、冒泡排序

双层for循环,数组内部元素不断比较交换,最终排序。
时间复杂度为O(n²)

private void bubbleSort(int[] array)
{
  int median=0;
  for(int i=0;iarray[j])
            {
              median=array[i];
              array[i]=array[j];
              array[j]=median;
            }
       }
   }
}

2、交换排序

双层for循环,相邻位不断比较,每一轮筛选出最大数元素,在下了一轮将其排除在外,再进行新一轮的的筛选(冒泡排序是最简单的交换排序)。
时间复杂度为O(n²)

private void exchangeSort(int[]array)
{
  int demian=0;
  for(int i=1;iarray[j+1])
             {
               demian=array[j];
               array[j]=array[j+1];
               array[j+1]=demian;
             }
         }
    }
}

可以将其优化一下

private void exchangeSort(int[]array)
{
  int  demian=0;
  bool isChange=true;
  for(int i=1;iarray[j+1])
        {
          demian=array[j];
          array[j]=array[j+1];
          array[j+1]=demian;
          isChange=true;
        }
     }
  }
}

3、选择排序

选择排序的原理是:在未排序的数组中寻找到最小的(最大的)数,将其放在数组的首位,然后剩下没排序的数组中再次寻找最小(最大的)数,将其放在上一轮的数后面,以此类推,直到没有剩余没排序的。
相比较于冒泡排序,选择排序的比较次数与冒泡排序相等,但是选择排序的交换次数要少于冒泡排序,至多交换数组长度减一次。

private void selectSort(int[]array)
{
  int demian=0;
  for(int i=0;iarray[j])
         {
           minValue=array[j];//将发现的最小值赋值给原定的最小值
           minIndex=j;//下标也赋值
         }
      }
      //将最小值的数的位置与原来假设的最小值的位置进行交换
      demian=array[i];
      array[i]=array[minIndex];
      array[minIndex]=demian;
      
   }
}

4、插入排序

排序思想:1.是将数组的首位元素作为已经排序好的数组
2.取出下一个元素,将其在排好序的从后往前进行扫描
3.找到比这个数小或等于这个数的,将这个数插在下个位置
4.重复2,3两个步骤,直到结束。

private void insertSort(int[]array)
{
   for(int i=1;ilength;i++)
   {
     int insertValue=array[i];//要准备插入的数
     int insertIndex=i-1;//前一个数的下标
     //条件满足说明还要继续寻找合适的位置
     while(insertIndex>=0 &&insertValue

5、希尔排序

每隔整数(sp)个数进行排序,即组内有序,当sp为1时,进行类似于插入排序,最终构造成有序数组。
核心算法:
for(int i=0;i {
for(int j=i;j {
if(array[j]>array[j+sp])
{
demian=array[j];
array[j]=array[j+sp];
array[j+sp]=demian;
}
}
}

private void spSort(int[] array,int[]sp)
{
  for(int i=0;iarray[j+sp])
      {
        demian=array[j];
        array[j]=array[j+sp];
        array[j+sp]=demian;
      }
    }
  }
}

6、归并排序

归并思想:将若干个有序的数组合并成一个有序的数组,有两种合并思想
1.自下向上进行合并
2.自顶向下进行合并
(做法有点难讲,可百度)

private void mergeSort(int[] array,int first,int last)
{
try{
//first为表格的初始位置,last为表格的末尾位置
 if(firstarray[indexB])
   {
     coreArray[coreIndex++]=array[indexB++]
   }
 }
 //剩余没有遍历完的填在coreArray后面
 while(indexA<=mid)
 {
   coreArray[coreIndex++]=array[indexA++];
 }
 while(indexB<=last)
 {
   coreArray[coreIndex++]=array[indexB++];
 }
 //将coreArray数组写入原数组
 for(int i=0;i

7、快速排序

快速排序的做法:在无序的数组中选择一个基准元素,使得在基准元素的左边都比基准元素小,右边都比基准元素大,基准元素不参加排序。
过程:
1.在无序数组中选择一个基准元素,命名为keyValue,数组的起始和末尾分别加一个指针i,j。
2.将i逐渐增大,直到找到大于keyValue的数为止。
3.将j逐渐增大,直到找到小于keyValue的数为止。
4.如果i

//快速排序
/// 
        /// 快速排序
        /// 
        /// 
        /// 
        /// 
        public static void QuickSort(int[] array,int low,int high)
        {
            //基线条件
            if (low >= high)
            {
                return;
            }

            //得到基准值
            int pivotIndex = QuickSortIndex(array, low, high);

            //进行递归
            QuickSort(array, low, pivotIndex - 1);
            QuickSort(array, pivotIndex + 1, high);
        }
        #endregion

        #region 快速排序的核心代码写法
        public static int QuickSortIndex(int[] array,int low, int high)
        {
            //设置一个基准值
            int pivote = array[low]; //9

            int left = low;//左指针  0
            int right = high;//右指针 8

            try//由于快速排序是一个不稳定的排序算法,这里用异常处理机制来预防代码出现异常
            {
                while (left < right)
                {
                    /*这里需要注意的是指针先从后往前进行一个移动 
                     * 这里的指针的移动顺序非常重要,指针的移动一定是要从后往前进行移动的,再进行从前往后移动的
                     在两个指针相碰的人位置退出while循环,同时将这个位置记录下来作为一个预先设定基准值的位置*/
                    while (left < right && array[right] >= pivote)
                    {
                        right--;
                    }
                    array[left] = array[right];

                    while (left < right && array[left] <= pivote)
                    {
                        left++;
                    }
                    array[right] = array[left];
                }
                //此处的left=right;
                //将此时的左右指针共同指向的位置赋予所设定的基准值
                array[left] = pivote;

                
            }
            catch
            {

            }
           return left;
        }
        #endregion 

备注:快速排序时不稳定排序。

你可能感兴趣的:(编程语言)