快排,堆排 C#实现

        /// <summary>
        
/// 堆排序
        
/// </summary>
        
/// <param name="R"></param>
        public static void HEAPSORT(int[] R)
        {
            
//建初始大根堆
            for (int i = R.Length / 2 + Convert.ToInt32(Math.IEEERemainder(R.Length, 2)); i > 0; i--)
            {
                SIFT(R, i 
- 1, R.Length - 1);
            }
            
//循环进行交换并重建大根堆
            for (int j = R.Length - 1; j > 0; j--)
            {
                
//交换根和无序区最后一个数
                int t = R[0]; R[0= R[j]; R[j] = t;
                SIFT(R, 
0, j - 1);
            }
        }
        
public static void SIFT(int[] R, int iFrom, int iTo)
        {
            
int i = iFrom;            //根结点下标
            int j = 2 * iFrom + 1;    //左孩子下标
            int temp = R[i];          //要调整的根结点,假定左右子树已为大根堆
            while (j <= iTo)
            {
                
if ((j < iTo) && ((R[j] < R[j + 1])))
                {
                    j
++;//如果右孩子大于左孩子,将j指向右孩子,以便接下来统一处理
                }
                
if ((R[j] > temp))
                {
                    
//比根结点大的孩子上移
                    R[i] = R[j];
                    
//指向下一个子树
                    i = j;
                    j 
= 2 * i + 1;
                }
                
else
                {
                    
break;
                }
            }
            
//定位要当初的根结点到正确的位置
            R[i] = temp;
        }


        
//---------------------------------------------------------------------------------

        
/// <summary>
        
/// 快速排序算法
        
/// </summary>
        
/// 快速排序为不稳定排序,时间复杂度O(nlog2n),为同数量级中最快的排序方法
        
/// <param name="arr">划分的数组</param>
        
/// <param name="low">数组低端上标</param>
        
/// <param name="high">数组高端下标</param>
        
/// <returns></returns>
        static int Partition(int[] arr, int low, int high)
        {
            
//进行一趟快速排序,返回中心轴记录位置
            
// arr[0] = arr[low];
            int pivot = arr[low];//把中心轴置于arr[0]
            while (low < high)
            {
                
while (low < high && arr[high] >= pivot)
                {
                    
--high;
                }
                Swap(
ref arr[high], ref arr[low]);//将比中心轴记录小的移到低端
                while (low < high && arr[low] <= pivot)
                {
                    
++low;
                }
                Swap(
ref arr[high], ref arr[low]);//将比中心轴记录大的移到高端
                
            }
            arr[low] 
= pivot; //中心轴移到正确位置
            return low;  //返回中心轴位置
        }
        
static void Swap(ref int i, ref int j)
        {
            
int t;
            t 
= i;
            i 
= j;
            j 
= t;
        }
        
static void QuickSort(int[] arr, int low, int high)
        {
            
if (low < high - 1)//当 arr[low,high]为空或只一个记录无需排序
            {
                
int pivot = Partition(arr, low, high);
                QuickSort(arr, low, pivot 
- 1);
                QuickSort(arr, pivot 
+ 1, high);

            }
        }
posted @ 2009-06-10 15:11 TONYBINLJ 阅读(...) 评论(...) 编辑 收藏