内部排序一

　　闲来无事，复习下数据结构的常用内部排序，利用下午的时间，随便写了选择、快速排序、内部排序的实现，虽然常用数据结构算法原理还是挺简单，可以完成写出来还是费了一些工夫。此处贴出代码，仅作自己的随手联系之用。

      

public class Program {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
          
           int[] array = CreateRandomArray(20);
           Display(array);
           SelectSortClass.Sort(array);
           Display(array);
           QuickSortClass.Sort(array);
           Display(array);
           HeapSortClass.Sort(array);
           Display(array);
    }
    
    
    private static int[] CreateRandomArray(int n)
    {
        int[] array = new int[n];
        Random rnd = new Random();
        for(int i = 0;i<n;i++)
        {
            array[i] = rnd.nextInt(n*10);
        }
        return array;
    }
    
    private static void Display(int[] array)
    {
        for(int i =0;i<array.length;i++)
        {
            System.out.print(array[i] + "  ");
        }
        System.out.println();
        
    }
    
}

选择排序的实现如下：

public class SelectSortClass
{
       public static void Sort(int[] array)
    {
        for(int i = 0;i < array.length;i++)
        {
            int minIndex = i;
            for(int j = i +1;j<array.length;j++)
            {
                 if(array[minIndex] > array[j])
                       minIndex = j ;
            }
            if(minIndex != i)
            Swap(array,minIndex,i);
        }
    }

    private static void Swap(int[] array,int m,int n)
    {
         int temp = array[m];
         array[m] = array[n];
         array[n] = temp;
    }

}

快速排序的实现如下：

public class QuickSortClass 
{

    /**
     * 快速排序
     * @param array
     * @param left
     * @param right
     */
    public static void Sort(int[] array)
    {
        QuickSort(array,0,array.length -1);
    }
    
    private static void QuickSort(int[] array,int left,int right)
    {
        if(left<right)
        {
            int partion = Division(array,left,right);
            QuickSort(array,left,partion-1);
            QuickSort(array,partion +1 ,right);
        }
        
    }
    
    private static int Division(int[] array,int left,int right)
    {
        int temp = array[left];
        while(left < right)
        {
            while(left < right && temp <= array[right])
                right--;
            array[left] = array[right];
            while(left < right && temp >= array[left])
                left++;
            array[right] = array[left];
        }
        array[left] = temp;
        return left;
    }
}

堆排序的实现如下：

public class HeapSortClass {

    /**
     * 堆排序
     * @param array
     */
    public static void Sort(int[] array)
    {
        BuildMaxHeap(array); //产生大顶堆
        for(int i = array.length - 1;i>=0;i--)
        {
            Swap(array,0,i);//交换大顶堆的元素，到数组最后一个
            MaxHeapUpdate(array,0,i);//前i个元素产生大顶堆
        }
    }
    
    private static void BuildMaxHeap(int[] array)
    {
           for(int i = (array.length / 2) -1; i >= 0; i--)
           {
               MaxHeapUpdate(array,i,array.length);
           }
    }
    
    private static void MaxHeapUpdate(int[] array ,int i,int heapSize)
    {
        int left = i* 2;
        int right = i* 2 +1;
        int max = i;
        if(right < heapSize)
        {
             if(array[left] >= array[right])
             {
                 if(array[left] > array[i])
                     max = left;
             }
             else
             {
                 if(array[right] > array[i])
                     max = right;
             }
        }
        if(max != i)
        {
            Swap(array,max,i);
            MaxHeapUpdate(array,max,heapSize);
        }
    }
    
    private static void Swap(int[] array,int m,int n)
    {
         int temp = array[m];
         array[m] = array[n];
         array[n] = temp;
    }
    
}