各种内部排序算法，C#实现

     1、首先是插入排序，插入排序也有很多种，比如直接插入排序，二分插入排序等。但原理都基本差不多：在一个已经排好序的数列中插入新的信息。这样依次插入之后，整个数列就是一个有序的数列了。

 

//插入排序

        publicstaticint[] insertSort(int[] array)
        {
            for (int i =1; i < array.Length; i++)       //遍历需要排序的数组
            {
                int j =0;
                while (j < i && array[j] < array[i])     //找到满足条件的待插入数
                {
                    j++;
                }

                int temp = array[i];                    //保存待插入的数
int Last = i;

                while (Last > j)                        //数组往后移动
                {
                    array[Last] = array[Last -1];
                    Last--;
                }
                array[j] = temp;                        //把需要插入的数，插入到第j个位置
            }
            return array;
        }

//插入排序

publicstaticint[] insertSort(int[] array)
{
for (int i =1; i < array.Length; i++) //遍历需要排序的数组
{
int j =0;
while (j < i && array[j] < array[i]) //找到满足条件的待插入数
{
j++;
}

int temp = array[i]; //保存待插入的数
int Last = i;

while (Last > j) //数组往后移动
{
array[Last] = array[Last -1];
Last--;
}
array[j] = temp; //把需要插入的数，插入到第j个位置
}
return array;
}

   

   2、冒泡排序，冒泡排序的基本原理是。比较旁边两个数字，（如果按升序排列）然后前面的数字比后面的数字大，则两个进行交换。

 

//冒泡排序
publicstaticint[] bubbleSort(int[] array)
        {
            for (int j =1; j < array.Length; j++)     //排N次序
            {
                for (int i =1; i < array.Length; i++) //遍历一遍，第一次排序
                {
                    if (array[i] < array[i -1])      //如果前面的比后面的大，则两者进行交换
                    {
                        int temp = array[i];
                        array[i] = array[i -1];
                        array[i -1] = temp;
                    }
                }
            }
            return array;
        }

   

   3、希尔排序，方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行冒泡排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

 

//希尔排序
publicstaticint[] shellSort(int[] array) 
        {
            ArrayList list = getDalt(array);
            Int32[] dalt = (Int32[])list.ToArray(typeof(Int32));    //转换为数组
for (int i =0; i <dalt.Length; i++) 
            {
                array = shellAdjust(array,dalt[i]);                            
            }
                return array;
        }
        //获得dalt数组,保存比较的增量表
publicstatic ArrayList getDalt(int[] array) {
            ArrayList dalt =new ArrayList();
            int i = (array.Length+1) /2;
            while (i >1)
            {
                dalt.Add(i);
                i =(i+1)/2;
            }
            dalt.Add(i);
            return dalt;
        }
        //一趟排序
publicstaticint[] shellAdjust(int[] array, int add)   //进行排序
        {
            int i=0;
            while (i + add < array.Length) 
            {
                if (array[i] > array[i + add])                 //如果前面的比后面的大，则交换
                {
                    int temp = array[i + add];
                    array[i+add]=array[i];
                    array[i] = temp;
                }
                i ++;
            }
            return array;
        }

 

 

    4、快速排序。快速排序是对冒泡排序的一种改进。主要是通过把整个数列分成若干个小的数列再排序。 首先随便在数组中找到一个目标数，然后移动数组中的元素，使大于改数的移动右边，小于的则移动左边。这样就分成了两部分，一部分比该数大，一部分比该数小。然后通过递归的方式。进行全部排列。

   快速排序算法，最核心的就是中间的划分过程。但是上次这个过程并不能正确的划分出来。特此改正，造成误解，一并道歉。特此订正。

   

public static int paration(Integer[] arrayList,int begin,int end){
        int temp=arrayList[begin];
        while (begin<end) {
            while (begin<end&&arrayList[end]>temp) {
                end--;
            }
            if (begin<end) {
                arrayList[begin]=arrayList[end];
                begin++;
            }
            while (begin<end&&arrayList[begin]<temp) {
                begin++;
            }
            if (begin<end) {
                arrayList[end]=arrayList[begin];
                end--;
            }
        }
        arrayList[begin]=temp;
        return begin;
    }
    public static void quickSort(Integer[] arrayList,int begin,int end){
        if(begin>=end)
            return;
        int par=paration(arrayList, begin, end);
        if(begin<par-1)
            quickSort(arrayList, begin, par-1);
        if (par+1<end) 
            quickSort(arrayList, par+1, end);
        
    }

 

 

 

 

    5、堆排序。堆排序首先需要建立一个堆。可以是大堆（父结点比子结点的元素都要大），也可以是小堆（父节点比子结点都要小）；本例建成大堆。

 

//堆排序
publicstaticint[] heapSort(int[] array) 
        {
            for (int i = (array.Length-1)/2; i>=0;i--)
            {
                //首先整个序列进行堆调整，
                heapAdjust(array,i, array.Length);
            }
            for (int i = array.Length-1; i >=0; i--) 
            {
                //交换第一个和最后一个数据，形成排序
int temp=array[0];
                array[0]=array[i];
                array[i] = temp;
                //堆重新调整
                heapAdjust(array,0,i-1);
            }
                return array;
        }

 

///<summary>
        /// 堆调整，建成一个大堆
        ///</summary>
        ///<param name="array"></param>
        ///<param name="i">开始调整</param>
        ///<param name="n">调整的长度</param>
        ///<returns>返回调整后的数组</returns>
publicstaticint[] heapAdjust(int[] array,int j,int n)       
        {
            int temp = array[j];                                   //此次需要调整的数
for (int i = j*2+1; i < n; i=2*j+1) 
            {
                if (i+1<n&&array[i] < array[i +1]) 
                    i++;
                if (temp <array[i])                    //如果孩子的结点更大，则交换
                {
                    array[j] = array[i];
                    j = i;
                }
                else
                    break;
            }
            array[j] = temp;                           //需要调整的结点保存在适当位置
            putOutArray(array);
            return array;
        }

  附录1：输出数组

 

//输出数组
publicstaticvoid putOutArray(int[] array)
        {
            for (int i =0; i < array.Length; i++)
            {
                Console.Write(array[i] +"");
            }
            Console.Write("\n");
        }

  附录2：测试数组

 

staticvoid Main(string[] args)
        {
            int[] array = { 72, 45, 3, 64, 78, 12, 56, 76, 23, 46 };
            Console.WriteLine("这是插入排序的结果");
            putOutArray(insertSort(array));
            Console.WriteLine("这是冒泡排序的结果");
            putOutArray(bubbleSort(array));
            Console.WriteLine("这是希尔排序的结果：");
            putOutArray(shellSort(array));
            Console.WriteLine("这是快速排序：");
            putOutArray(quickSort(array,0,array.Length-1));
        }

//快速排序
publicstaticint[] quickSort(int[] array,int low,int high)
{
int at;
if (low < high)
{
array = quick(array, low, high, out at); //把数组分成两个部分，
quickSort(array,low,at-1); //左边的排序
quickSort(array,at,high); //右边的排序
}
return array;
}
publicstaticint[] quick(int[] array, int first, int end,outint at) {
int mid = array[first]; //同第一个数比较
while (first <= end)
{
while (array[first] < mid) //向右移动，直到找到比mid大或相等的那个数
first++;
while (array[end] > mid) //向左移动，直到找到比Mid小的那个数
end--;
if (first <= end)
{
int temp = array[first]; //交换两个数
array[first] = array[end];
array[end] = temp;
first++;
end--;
}
}
at = first;
return array;
}

 

     版权所有，欢迎转载，但是转载请注明出处：潇一