排序

#include "stdafx.h"
#include <stdio.h>
#include "SortFun.h"
#include <stdlib.h>

void ShowArray(int aNum[],int N)
{
   int i = 0;

   for( i = 0; i < N ; i++)
   {
      printf("%d ",aNum[i]);
   }
   printf("\n");
}


void BubbleSort(int aNum[],int N)//冒泡排序
{
   int i = 0;
   int j = 0;
   int nTemp = 0;
   bool bFlag = 0;

   for( i = 0; i < N -1; i++)
   {   
	   bFlag = 0;
      for( j = 0; j < N - i -1; j++)
	  {    
	       if( aNum[j] > aNum[j+1])
		   {
		      nTemp = aNum[j+1];
			  aNum[j+1] = aNum[j];
			  aNum[j] = nTemp;
			  bFlag = 1;
		   }	   
	  }
	  if( 0 == bFlag)
	  {
	     break;
	  }	  
   }
}


void InsertSort(int aNum[],int N)//插入排序
{
     int i = 0;
	 int j = 0;
	 int nTemp = 0;

	 for( i = 1 ; i < N ; i++ )
	 {
	      nTemp = aNum[i];
		  j = i-1;

		  while( j >= 0 && nTemp < aNum[j])
		  {
		      aNum[j+1] = aNum[j];
			  j--;
		  }
		  aNum[j+1] = nTemp;
	 }
}

void ShellSort(int *pArray, int N)
{
    int i = 0;
    int j = 0;
    int nGroup = N / 2;
    int nTemp = 0;
    
    while (nGroup > 0)
    {
       for (i = nGroup; i < N; i++)
       {
           nTemp = pArray[i];
           j = i - nGroup;
           
           while (j >= 0 && nTemp >= pArray[j])
           {
              pArray[j + nGroup] = pArray[j];
              j = j - nGroup;
           }

           pArray[j + nGroup] = nTemp;
      }

     nGroup = nGroup / 2;
   }
}

void QuickSort(int aNum[],int Left,int Right)
{
     int i = Left;
	 int j = Right;
	 int nTemp = aNum[i];

	 while( i < j)
	 {
	    while( i < j && aNum[j] >= nTemp)
		{
		  j--;
		}
		if( i < j)
		{
		   aNum[i] = aNum[j];
		   i++;
		}
		while( i < j && aNum[i] < nTemp)
		{
		   i++;
		}
		if( i < j)
		{
		   aNum[j] = aNum[i];
		   j--;
		}	 
	 }
     aNum[i] = nTemp;
	 if( Left < i-1)
	 {
	   QuickSort(aNum,Left,i-1);
	 }
	 if( i+1 < Right)
	 {
	   QuickSort(aNum,i+1,Right);
	 }
}

void Merge( int aNum[],int low,int mid,int high)
{
   int i = low;
   int j = mid+1;
   int k = 0;

   int *NewArr = (int*)malloc(sizeof(int) * (high-low +1));
   if( NULL == NewArr)
   {
     return;
   }

   while( i <= mid && j <=high)
   {
      if( aNum[i] <= aNum[j])
	  {
	     NewArr[k++] = aNum[i++];
	  }
	  else
	  {
	    NewArr[k++] = aNum[j++];
	  }
   }
   while( i <= mid)
   {
      NewArr[k++] = aNum[i++];
   }
   while( j <= high)
   {
     NewArr[k++] = aNum[j++];
   }

   for( k = 0,i = low; i <= high; i++,k++)
   {
     aNum[i] = NewArr[k];
   }
   free(NewArr);

}

void MergeSort(int aNum[],int N)
{
   
   for( int Len = 1; Len < N-1 ; Len = Len*2)
   {
      for( int i = 0; i+ 2*Len-1 <= N-1; i = i+2*Len)
	  {
	     Merge(aNum,i,i+Len-1,i+2*Len-1);
	  }
      if( i+Len-1 <N-1)
	  {
	    Merge(aNum,i,i+Len-1,N-1);
	  }
   
   }
}


void HeapAdjust(int *pArray, int nIndex, int nEnd) //pArray[0 , .... , nEnd]
{
	int lChild = 2 * nIndex + 1;//堆从0开始计数
	int rChild = 2 * nIndex + 2;
	int nMaxIndex = nIndex;
	int nTemp = 0;

	if (nIndex <= nEnd / 2) //保证当前结点，有孩子结点
	{
		if (lChild <= nEnd && pArray[lChild] > pArray[nIndex])
		{
			nMaxIndex = lChild;
		}
		if (rChild <= nEnd && pArray[rChild] > pArray[nIndex])
		{
			nMaxIndex = rChild;
		}

		if (nMaxIndex != nIndex)
		{
			nTemp = pArray[nIndex];
			pArray[nIndex] = pArray[nMaxIndex];
			pArray[nMaxIndex] = nTemp;

			HeapAdjust(pArray, nMaxIndex, nEnd);
		}
	}
}

void HeapSort(int *pArray, int nEnd) // pArray[0...,nEnd]
{
	int i = 0;
	int nTemp = 0;

	for (i = nEnd / 2; i >= 0; i--)
	{
		HeapAdjust(pArray, i, nEnd);
	}

	for (i = nEnd; i > 0; i--) // n - 1 趟堆排序
	{
		nTemp = pArray[i];
		pArray[i] = pArray[0];
		pArray[0] = nTemp;

		HeapAdjust(pArray, 0, i - 1);
	}
}