常见排序算法--实现（归类）

插入排序   O(n^2)

static void insertion_sort(int[] unsorted)        {            for (int i = 1; i < unsorted.Length; i++)            {                if (unsorted[i - 1] > unsorted[i])                {                    int temp = unsorted[i];                    int j = i;                    while (j > 0 && unsorted[j - 1] > temp)                    {                        unsorted[j] = unsorted[j - 1];                        j--;                    }                    unsorted[j] = temp;                }            }        }

起泡排序 O(n^2)

static void bubble_sort(int[] unsorted)        {            for (int i = 0; i < unsorted.Length; i++)            {                for (int j = i; j < unsorted.Length; j++)                {                    if (unsorted[i] > unsorted[j])                    {                        int temp = unsorted[i];                        unsorted[i] = unsorted[j];                        unsorted[j] = temp;                    }                }            }        }

选择排序 O(n^2)

static void selection_sort(int[] unsorted)        {            for (int i = 0; i < unsorted.Length; i++)            {                int min = unsorted[i], min_index = i;                for (int j = i; j < unsorted.Length; j++)                {                    if (unsorted[j] < min)                    {                        min = unsorted[j];                        min_index = j;                    }                }                if (min_index != i)                {                    int temp = unsorted[i];                    unsorted[i] = unsorted[min_index];                    unsorted[min_index] = temp;                }            }        }

希尔排序：O(log2(n))

static void shell_sort(int[] unsorted, int len)        {            int group, i, j, temp;            for (group = len / 2; group > 0; group /= 2)            {                for (i = group; i < len; i++)                {                    for (j = i - group; j >= 0; j -= group)                    {                        if (unsorted[j] > unsorted[j + group])                        {                            temp = unsorted[j];                            unsorted[j] = unsorted[j + group];                            unsorted[j + group] = temp;                        }                    }                }            }        }

快速排序：O(log2(n))

static int partition(int[] unsorted, int low, int high)        {            int pivot = unsorted[low];            while (low < high)            {                while (low < high && unsorted[high] > pivot) high--;                unsorted[low] = unsorted[high];                while (low < high && unsorted[low] <= pivot) low++;                unsorted[high] = unsorted[low];            }            unsorted[low] = pivot;            return low;        }        static void quick_sort(int[] unsorted, int low, int high)        {            int loc = 0;            if (low < high)            {                loc = partition(unsorted, low, high);                quick_sort(unsorted, low, loc - 1);                quick_sort(unsorted, loc + 1, high);            }        }

堆排序：O(log2(n))

//array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度

//本函数功能是：根据数组array构建大根堆

void HeapAdjust(int array[],int i,int nLength)

{

    int nChild;

    int nTemp;

    for(;2*i+1<nLength;i=nChild)

    {

        //子结点的位置=2*（父结点位置）+1

        nChild=2*i+1;

        //得到子结点中较大的结点

        if(nChild<nLength-1&&array[nChild+1]>array[nChild])++nChild;

        //如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点

        if(array[i]<array[nChild])

        {

            nTemp=array[i];

            array[i]=array[nChild];

            array[nChild]=nTemp; 

        }

        else break; //否则退出循环

    }

}

//堆排序算法

void HeapSort(int array[],int length)

{

    int i;

    //调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素

    //length/2-1是最后一个非叶节点，此处"/"为整除

    for(i=length/2-1;i>=0;--i)

    HeapAdjust(array,i,length);

    //从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素

    for(i=length-1;i>0;--i)

    {

        //把第一个元素和当前的最后一个元素交换，

        //保证当前的最后一个位置的元素都是在现在的这个序列之中最大的

        array[i]=array[0]^array[i];

        array[0]=array[0]^array[i];

        array[i]=array[0]^array[i];

        //不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值

        HeapAdjust(array,0,i);

    }

}




归并排序：

static void merge(int[] unsorted, int first, int mid, int last, int[] sorted)        {            int i = first, j = mid;            int k = 0;            while (i < mid && j < last)                if (unsorted[i] < unsorted[j])                    sorted[k++] = unsorted[i++];                else                    sorted[k++] = unsorted[j++];            while (i < mid)                sorted[k++] = unsorted[i++];            while (j < last)                sorted[k++] = unsorted[j++];            for (int v = 0; v < k; v++)                unsorted[first + v] = sorted[v];        }        static void merge_sort(int[] unsorted, int first, int last, int[] sorted)        {            if (first + 1 < last)            {                int mid = (first + last) / 2;                Console.WriteLine("{0}-{1}-{2}", first, mid, last);                merge_sort(unsorted, first, mid, sorted);                merge_sort(unsorted, mid, last, sorted);                merge(unsorted, first, mid, last, sorted);            }        }

 基数排序：

/// <summary>        /// 基数排序        /// 约定:待排数字中没有0,如果某桶内数字为0则表示该桶未被使用,输出时跳过即可/// </summary>        /// <param name="unsorted">待排数组</param>        /// <param name="array_x">桶数组第一维长度</param>        /// <param name="array_y">桶数组第二维长度</param>        static void radix_sort(int[] unsorted, int array_x = 10, int array_y = 100)        {            for (int i = 0; i < array_x/* 最大数字不超过999999999...(array_x个9) */; i++)            {                int[,] bucket = new int[array_x, array_y];                foreach (var item in unsorted)                {                    int temp = (item / (int)Math.Pow(10, i)) % 10;                    for (int l = 0; l < array_y; l++)                    {                        if (bucket[temp, l] == 0)                        {                            bucket[temp, l] = item;                            break;                        }                    }                }                for (int o = 0, x = 0; x < array_x; x++)                {                    for (int y = 0; y < array_y; y++)                    {                        if (bucket[x, y] == 0) continue;                        unsorted[o++] = bucket[x, y];                    }                }            }        }

引用参考博客：http://www.cnblogs.com/kkun/archive/2011/11/23/2260312.html

有个网址有动态图片：http://www.guqiankun.com/sortalgorithm（有意思）