常见排序

http://c.chinaitlab.com/special/cpxsf/index.html

1. 插入排序（Insertion Sort） 

 算法的复杂度也是简单的，排序第一个需要1的复杂度，排序第二个需要2的复杂度，因此整个的复杂度就是

    1 + 2 + 3 + …… + N = O（N ^ 2）的复杂度。

//  插入排序
void InsertSort( int array[],  int length)
{
　　　  int i, j, key;

　　　  for (i =  1; i < length; i++)
　　　 {
　　　　　　　 key = array[i];
　　　　　　　  //  把i之前大于array[i]的数据向后移动
　　　　　　　  for (j = i -  1; j >=  0 && array[j] > key; j--)
　　　　　　　 {
　　　　　　　　　　　 array[j +  1] = array[j];
　　　　　　　 }
　　　　　　　  //  在合适位置安放当前元素
　　　　　　　 array[j +  1] = key;
　　　 }
}

 

 

static void InsertSort( int[] array, int length)
        {
            for ( int i = 1; i < length; i++)
            {
                int temp = array[i];
                int tempIndex = i;

                for ( int j = i - 1; j >= 0 && array[j] > temp; j--)
                {

                    array[j + 1] = array[j];
                    tempIndex = j;
                }
                array[tempIndex] = temp;
            }
        }

 

2. 冒泡排序 （bubble sort）

 

将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
（1）初始
　    R[1..n]为无序区。

（2）第一趟扫描
　   
从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。
   
　第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。

（3）第二趟扫描
　   
扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上……
    　最后，经过n-1 趟扫描可得到有序区R[1..n]
  注意：
　   
第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R[i]上，结果是R[1..i]变为新的有序区。

 

  static  void Main( string[] args)
        {
             int[] array = {  23,  45,  16,  7,  42 };
             int length = array.Length -  1;
             bool isExchanged =  false;

             for ( int i =  0; i < length; i++)
            {
                isExchanged =  false;

                 for ( int j = length; j > i; j--)
                {
                     if (array[j] > array[j -  1])
                    {
                         int temp = array[j];
                        array[j] = array[j -  1];
                        array[j -  1] = temp;
                        isExchanged =  true;
                    }
                }

                 if (!isExchanged) // 一遍比较过后如果没有进行交换则退出循环 
                {
                     break;
                }
            }

             foreach ( int i  in array)
            {
                Console.WriteLine(i);
            } Console.Read();
        }

 3.快速排序 （Quick Sort) 

 

  private  static  void Sort( int[] numbers,  int left,  int right)
        { 
             // 左边索引小于右边，则还未排序完成 　
             if (left < right) 　
            { 　　 // 取中间的元素作为比较基准，小于他的往左边移，大于他的往右边移 　　
                 int middle = numbers[(left + right) /  2];
                 // int i = left - 1;
                 // int j = right + 1;
                 int i = left;
                 int j = right;

                 while ( true)
                {
                     while (i < right && numbers[i] < middle)
                    {
                        i++;
                    };

                     while (j >  0 && numbers[j] > middle  )
                    {
                        j--;
                    };

                     if (i >= j)
                    {
                         break;
                    }

                    Swap(numbers, i, j);
                }

                Sort(numbers, left, i -  1);
                Sort(numbers, j +  1, right);
            }
        } 　
　
         ///   <summary>  　　
         ///  交换元素值 　
         ///   </summary>  　　
         ///   <param name="numbers"> ；数组 </param>  　　
         ///   <param name="i"> ；当前左边索引 </param>  　　
         ///   <param name="j"> ；当前右边索引 </param>  　
         ///  
         private  static  void Swap( int[] numbers,  int i,  int j)
        {
             int number = numbers[i];
            numbers[i] = numbers[j];
            numbers[j] = number;
        }
    }

 4. 直接选择排序 (Straight Selection Sort)

 

  private  static  void QuitSort( int[] numbers,  int length)
        {
             for ( int i =  0; i < length -  1; i++)
            {
                 int temp = i;

                 for ( int j = i +  1; j < length; j++)
                {
                     if (numbers[j] < numbers[temp])
                    {
                        temp = j;
                    }
                }

                 if (temp != i)
                {
                    Swap(numbers, i, temp);
                }
            }
        }

 

5. 堆排序 (Heap Sort)

 1）。用迭代实现堆排序

    ///   <summary>
         ///  建立最大堆
         ///   </summary>
         ///   <param name="arr"></param>
         ///   <param name="i"></param>
         ///   <param name="length"></param>
         static  void HeapAdjust( int[] arr,  int i,  int length)
        {
             int child =  2 * i +  1;    // 左节点 　　
             int temp = arr[i];
             // 中间变量保存当前根节点 　

             while (child < length)
            {
                 // 如果有右节点，判断是否大于左节点 　
                 if (child < length -  1 && arr[child] < arr[child +  1])
                    child++; 　　 // 双亲节点大于子节点 
　　
                 if (temp >= arr[child])
                     break;  // 不需调整，结束调整 　
　
                arr[i] = arr[child];  // 双亲结点值设置为大的子节点值,将节点子付给父节点。 　
                i = child;
                child =  2 * i +  1; // 如果这个节点本身还有子节点，继续往下调整。类似于递归的原理。
            }

            arr[i] = temp;  // 找到最后一个交换点，赋值。如果没有交换，付给开始的父节点。否则，赋值给最后一个进行交换的子节点。
        }

         public  static  void Heap( int[] arr)
        {
             // 第一次创建大堆 　　
             for ( int i = arr.Length /  2 -  1; i >=  0; i--)
            {
                 // 从后面的subtree开始保证每个tree都是堆
                HeapAdjust(arr, i, arr.Length);
            }

             // 元素位置调换 　
             for ( int i = arr.Length -  1; i >  0; i--)
            {
                 // 堆顶与当前堆的最后一个堆元素交换位置，把最大的值放到最后。 　　
                 int tmp = arr[ 0];
                arr[ 0] = arr[i];
                arr[i] = tmp;              

                 // 将剩下的无序堆部分重新建堆处理 　
                HeapAdjust(arr,  0, i);

                 foreach ( int v  in arr)
                {
                    Console.Write(v.ToString() +  "   ");
                }

                Console.WriteLine( "");
            }
        }

2）.利用递归实现堆排序

 

   ///   <summary>
         ///  建立最大堆
         ///   </summary>
         ///   <param name="arr"></param>
         ///   <param name="i"></param>
         ///   <param name="length"></param>
         static  void HeapAdjust( int[] arr,  int i,  int length)
        {
             if ( 2 * i +  1 < length)
            {
                 int child =  2 * i +  1;    // 左节点 　

                 int temp = arr[i];

                 if (child < length -  1 && arr[child] < arr[child +  1])
                    child++; 　　 // 双亲节点大于子节点 

                 if (temp >= arr[child])
                     return; // 不需调整，结束调整 　

                arr[i] = arr[child];  // 双亲结点值设置为大的子节点值,将节点子付给父节点。 　
                i = child;

                HeapAdjust(arr,  2 * child +  1, length);

                arr[i] = temp;

            }

             // 找到最后一个交换点，赋值。如果没有交换，付给开始的父节点。否则，赋值给最后一个进行交换的子节点。
        }

         public  static  void Heap( int[] arr)
        {
             // 第一次创建大堆 　　
             for ( int i = arr.Length /  2 -  1; i >=  0; i--)
            {
                 // 从后面的subtree开始保证每个tree都是堆
                HeapAdjust(arr, i, arr.Length);
            }

             // 元素位置调换 　
             for ( int i = arr.Length -  1; i >  0; i--)
            {
                 // 堆顶与当前堆的最后一个堆元素交换位置，把最大的值放到最后。 　　
                 int tmp = arr[ 0];
                arr[ 0] = arr[i];
                arr[i] = tmp;              

                 // 将剩下的无序堆部分重新建堆处理 　
                HeapAdjust(arr,  0, i);

                 foreach ( int v  in arr)
                {
                    Console.Write(v.ToString() +  "   ");
                }

                Console.WriteLine( "");
            }
        }

6. 归并排序（Merge Sort)

 

static  void Merge( int[] a,  int low,  int mid,  int high)
        {
             int k =  0;
             int begin1 = low;
             int end1 = mid;
             int begin2 = mid +  1;
             int end2 = high;

             int[] b =  new  int[high - low +  1];

             while (begin1 <= end1 && begin2 <= end2)
            {
                 if (a[begin1] <= a[begin2])
                {
                    b[k++] = a[begin1++];
                }
                 else
                {
                    b[k++] = a[begin2++];
                }
            }

             if (begin1 <= end1)
            {
                 for ( int q = begin1; q <= end1; q++)
                {
                    b[k++] = a[q];
                }
            }
             else
            {
                 for ( int q = begin2; q <= end2; q++)
                {
                    b[k++] = a[q];
                }
            }

             for ( int i =  0; i < b.Length; i++)
            {
                a[low++] = b[i];
            }   // 此步骤相当于在数组a内进行了局部排序。        
        }

         static  void MergeSort( int[] R,  int low,  int high)
        {
             // 用分治法对R[low..high]进行二路归并排序
             int mid;

             if (low < high)
            {
                 // 区间长度大于1
                mid = (low + high) /  2;  // 分解
                MergeSort(R, low, mid);  // 递归地对R[low..mid]排序
                MergeSort(R, mid +  1, high);  // 递归地对R[mid+1..high]排序
                Merge(R, low, mid, high);  // 组合，将两个有序区归并为一个有序区
            }
        }

 

7. 箱排序 （Bin Sort）

 

8. 桶排序 （Bucket Sort）