c#排序算法

c#排序算法 

一、冒泡排序 

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，依此类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。 

优点：稳定，比较次数已知； 

缺点：慢，每次只能移动相邻两个数据，移动数据的次数多。 


二、选择排序 

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，依此类推，最后比较a[1]与a[n]的值。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。 

优点：稳定，比较次数与冒泡排序一样，数据移动次数比冒泡排序少； 

缺点：相对之下还是慢。 

三、插入排序 

已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插入。（若无数组a，可将b[1]当作n=1的数组a） 

优点：稳定，快； 

缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。 

四、缩小增量排序 

由希尔在1959年提出，又称希尔排序。 

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n不大是，插入排序的效果很好。首先取一增量d(d <n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组依此类推，在各组内用插入排序，然后取d' <d，重复上述操作，直到d=1。 

优点：快，数据移动少； 

缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。 

五、快速排序 

快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。 

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]作为基准。比较a[x]与其它数据并排序，使a[x]排在数据的第k位，并且使a[1]~a[k-1]中的每一个数据 <a[x]，a[k+1]~a[n]中的每一个数据>a[x]，然后采用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n]两组数据进行快速排序。 

优点：极快，数据移动少； 

缺点：不稳定。 

经过一段时间的学习和编程，我已对上述几种排序方法熟练掌握或有所了解。在此基础上，经过我的思考和实践，我研究出了一种新的排序算法：分段插入排序。 

分段插入排序 

已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。先将数组a分成x等份（x < <n)，每等份有n/x个数据。将每一段的第一个数据先储存在数组c中：c[1]、c[2]、……c[x]。运用插入排序处理数组b中的数据。插入时b先与c比较，确定了b在a中的哪一段之后，再到a中相应的段中插入b。随着数据的插入，a中每一段的长度会有变化，所以在每次插入后，都要检测一下每段数据的量的标准差s，当其大于某一值时，将a重新分段。在数据量特别巨大时，可在a中的每一段中分子段，b先和主段的首数据比较，再和子段的首数据比较，可提高速度。 

优点：快，比较次数少； 

缺点：不适用于较少数据的排序，s的临界值无法确切获知，只能凭经验取。 

我设计的算法或许优于某些算法，但它也有它的优点、缺点和适用范围。不仅排序算法如此，任何算法都一样。没有任何一个人干说自己的算法是最好的。设计新算法的过程其实就是增加其优点，减少其缺点和拓宽其适用范围的过程。我最崇尚的一句话就是：“没有最好，只有更好。” 

1、冒泡法

 private int[] ArraySort(int[] array)

        {
            int temp;
            bool noSwap = true;
            for (int i = 0; i < array.Length; i++)
            {
                for (int j = i + 1; j < array.Length; j++)  //也可以写为 for (int j = 0; j < array.Length-i-1; j++)
                {
                    if (array[i] > array[j])
                    {
                        temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                        noSwap = false;
                    }
                }
                if (noSwap) return array;//没有再发生交换，排序结束
                else noSwap = true;
            }
            return array;
        }
2、shell 排序
 private static void Shell_Sort(int[] b)
        {
            int[] a = new int[b.Length];
            b.CopyTo(a, 0);
            int key;
            Console.WriteLine("Shell排序");
            int gap=5,k;
            for(;gap>0;gap/=2)
                for (int j = gap; j < 10; j++)
                {
                    if (a[j] < a[j - gap])
                    {
                        key = a[j];
                        for (k = j - gap; k >= 0 ; k -= gap)
                        {
                            if (key < a[k])
                            {
                                a[k + gap] = a[k];
                            }
                            else
                                break;
                        }
                        a[k + gap] = key;

                    }
                }

            Print(a);
        }

3、插入

 /** 

* 插入排序数组 
* @author Edwin 
* @version 1.1 
*/ 
public class InsertionArray { 
/** 
  * 插入排序数组 
  * @param lngArr为要排序的数组 
  */ 
    public void insertionSort(long[]lngArr) 
      { 
    int intOut=0,intIn=0,intElems=lngArr.length; 
      for(intOut=1; intOut <intElems; intOut++) 
          { 
          long temp = lngArr[intOut]; 
          intIn = intOut; 
          while(intIn>0 && lngArr[intIn-1] >= temp) 
            { 
          lngArr[intIn] = lngArr[intIn-1]; 
              --intIn; 
            } 
          lngArr[intIn] = temp; 
          }  // end for 
      }    // end insertionSort() 

} 

3、折半

  private int[] ArraySort(int[] array)

        {
            int i, low, high, mid, j, temp;
            for (i = 1; i < array.Length; ++i)
            {
                temp = array[i];
                low = 0;
                high = i - 1;
                while (low <= high)
                {
                    mid = (low + high) / 2;//折半
                    if (temp < array[mid])
                        high = mid - 1;//插入低半区
                    else low = mid + 1;//插入高半区
                }
                for (j = i - 1; j >= high + 1; --j)//记录后移
                    array[j + 1] = array[j];//插入
                array[high + 1] = temp;
            }
            return array;
        }
4、选择排序
 private static void Select_Sort(int[] b)
           {
            int[] a = new int[b.Length];
            b.CopyTo(a, 0);
            Console.WriteLine("选择排序");
            int min,temp;
            for(int i=0;i<9;i++)
            {
                min=i;
                for (int j = i + 1; j < 10; j++)
                {
                    if (a[min] > a[j])
                        min = j;
                }
                if(min!=i)                      
                           {

                    temp=a[i];
                    a[i]=a[min];
                    a[min]=temp;
                }
            }
            Print(a);
        }
5、快速排序
 private int[] m_arrValue = new int[100];
 /// <summary>
/// 进行快速排序
/// </summary>
/// <param name="nLow">排序起始元素索引</param>
/// <param name="nHigh">排序结束元素索引</param>
private void QuickSort(int nLow, int nHigh)
{
    int nPivotPos = 0;
    if (nLow < nHigh)
    {
        nPivotPos = this.Partition(nLow, nHigh);
        this.QuickSort(nLow, nPivotPos - 1);
        this.QuickSort(nPivotPos + 1, nHigh);
    }
}

/// <summary>
/// 执行一趟快速排序过程
/// </summary>
/// <param name="nLow">一趟快速排序的起始元素索引</param>
/// <param name="nHigh">一趟快速排序的结束元素索引</param>
/// <returns>枢轴元素索引</returns>
private int Partition(int nLow, int nHigh)
{
    int pivotValue = this.m_arrValue[nLow];
    while (nLow < nHigh)
    {
        while (nLow < nHigh && this.m_arrValue[nHigh] >= pivotValue)
            nHigh--;
        if (nLow < nHigh)
            this.m_arrValue[nLow++] = this.m_arrValue[nHigh];
        while (nLow < nHigh && this.m_arrValue[nLow] <= pivotValue)
            nLow++;
        if (nLow < nHigh)
            this.m_arrValue[nHigh--] = this.m_arrValue[nLow];
    }
    this.m_arrValue[nLow] = pivotValue;
    return nLow;
}

6、

C/C++ code
 void quickSort(char* arr,int startPos, int endPos) 
{ 
int i,j; 
char ch; 
ch=arr[startPos]; 
i=startPos; 
j=endPos; 
while(i<j) 
{ 
  while(arr[j>=ch && i<j)--j; 
    arr=arr[j]; 
  while(arr<[i]=ch && i<j)++i; 
    arr[j]=arr[i];   
} 
arr[i]=ch; 
if(i-1>startPos) quickSort(arr,startPos,i-1); 
if(endPos>i+1) quickSort(arr,i+1,endPos); 
} 

7、

选择排序 
using System； 

namespace SelectionSorter 
{ 
public class SelectionSorter 
{ 
private int min； 
public void Sort（int [] list） 
{ 
for（int i=0；i＜list.Length-1；i++） 
{ 
min=i； 
for（int j=i+1；j＜list.Length；j++） 
{ 
if（list[j]＜list[min]） 
min=j； 
} 
int t=list[min]； 
list[min]=list[i]； 
list[i]=t； 
} 

} 
} 
public class MainClass 
{ 
public static void Main（） 
{ 
int[] iArrary=new int[]{1,5,3,6,10,55,9,2,87,12,34,75,33,47}； 
SelectionSorter ss=new SelectionSorter（）； 
ss.Sort（iArrary）； 
for（int m=0；m＜iArrary.Length；m++） 
Console.Write（"{0} ",iArrary[m]）； 
Console.WriteLine（）； 

} 
} 
} 


插入排序 
using System； 

namespace InsertionSorter 
{ 
public class InsertionSorter 
{ 
public void Sort（int [] list） 
{ 
for（int i=1；i＜list.Length；i++） 
{ 
int t=list[i]； 
int j=i； 
while（（j＞0）&&（list[j-1]＞t）） 
{ 
list[j]=list[j-1]； 
--j； 
} 
list[j]=t； 
} 

} 
} 
public class MainClass 
{ 
public static void Main（） 
{ 
int[] iArrary=new int[]{1,13,3,6,10,55,98,2,87,12,34,75,33,47}； 
InsertionSorter ii=new InsertionSorter（）； 
ii.Sort（iArrary）； 
for（int m=0；m＜iArrary.Length；m++） 
Console.Write（"{0}",iArrary[m]）； 
Console.WriteLine（）； 
} 
} 
} 


8、
再来一个选择排序：
        private int[] ArraySort(int[] array)
        {
            int min, temp;
            for (int i = 0; i < array.Length; i++)
            {
                min = i;
                for (int j = i; j < array.Length; j++)
                {
                    if (array[min] > array[j])
                        min = j;
                }
                temp = array[min];
                array[min] = array[i];
                array[i] = temp;
            }
            return array;
        }
9、
来个C++的快排 
C/C++ code
//qsort
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<time.h>
#define N 5000
using namespace std;

template <class T>
void qsort(T *l,T *r){
    T *i,*j,*k;
    int t;

    i=l;j=r-1;k=i+rand()%(r-l);
    t=*k;
    while(i<j){
        while(i<k && *i<=t)i++;
        *k=*i;k=i;
        while(k<j && *j>=t)j--;
        *k=*j;k=j;
    }
    *k=t;
    if(k-l>1)qsort<T>(l,k);
    if(r-k>1)qsort<T>(k,r);
}

void main(){
    srand(time(0));
    int a[N];
    for(int i=0;i<N;++i)
        a[i]=rand()%(N*5);
    qsort<int>(a,a+N-1);
    /*for(i=0;i<N;++i)
        cout<<setw(5)<<a[i];
    cout<<endl;
    */
    for(i=1;i<N;++i)
        if(a[i-1]>a[i]){cout<<false<<endl;return;}
    cout<<true<<endl;
}