排序算法

冒泡排序

选择排序

插入排序

希尔排序

快速排序

非递归的快速排序 qsrot

堆排

基数排序

以下算法所需要的一些信息

 #define  N 10
 #define SWAP(a,b){int tmp;tmp=a;a=b;b=tmp;}

冒泡排序

  void arrMP(int* arr)
  {
     int i,j;                                                                                                                    
      for (i=0;i<N-1;++i)
      {   
          for (j=0;j<N-i-1;++j)
          {   
              if(arr[j] > arr[j+1])
                  SWAP(arr[j],arr[j+1]);
          }   
      }   
  }

选择排序

  void  arrSelect(int* arr){
      int i,j,maxPos;
      for (i=N;i>0;--i)
      {   
          maxPos = 0;                                                                                                             
          for (j=1;j<i;++j)
              if(arr[maxPos] < arr[j])
                  maxPos = j;
          SWAP(arr[maxPos],arr[i-1]);
      }   
  }

插入排序

• 认为0号元素自然有序，从1号元素开始插入，存储插入元素的值，从后往前，一次拿有序序列元素值，于插入元素值进行比较，如果有序序列值大于插入元素值，
  有序序列值后移一位，找到插入元素值的位置，将其插入对应位置

void sortInsert(int* arr) {
	int i, j, insertVal;
	for ( i = 1; i < N; i++)
	{
		insertVal = arr[i];
		for ( j = i-1; j >= 0; --j)
		{
			if (arr[j] > insertVal)
			{
				arr[j + 1] = arr[j];
			}
			else {
				break;
			}
		}
		arr[j + 1] = insertVal;
	}
}

希尔排序

• 效率最佳

  void arrInsertPlus(int* arr)
  {
      int i,j,insertVal,gap;
      for (gap=N>>1;gap>0;gap>>=1)
      {   
       for (i=gap;i<N;++i)
       {   
        insertVal = arr[i];
        for (j=i-gap;j>=0&&arr[j]>insertVal;j=j-gap)
        {   
         arr[j+gap] = arr[j];
        }   
        arr[j+gap]=insertVal;
       }   
      }   
  } 

快速排序

• 一开始进行分割划分，选择最后一个元素作为分割值，将比分割值小的放在分割值左边，比分割值大的放在分割值的右边，返回分割值的下标，此时数组依照分割值划分一分为二，
  对前半部分继续进行分割，对后半部分进行分割，递归，实现最终有序
• 在windows下 单个函数的栈空间只有1M，所以快速排序在50w个数的时候会报，Stack overflow 1M大概可以放20W左右个数

  int partition(int *arr,int l,int r)
  {
      int i,k;
      for (i=l,k=l;i<r;++i)
      {   
       if(arr[r] > arr[i])   
       {   
          SWAP(arr[k],arr[i]);
          ++k;
       }   
      }   
      SWAP(arr[k],arr[r]);
      return k;
  }
  void arrQuick(int* arr,int left,int right){
      int pivot;
      if(left < right)
      {   
          pivot = partition(arr,left,right);
          arrQuick(arr,left,pivot-1);
          arrQuick(arr,pivot+1,right);
      }   
  } 

非递归的快速排序 qsrot

头文件：stdlib.h
用法：  void qsort(void* base,size_t num,size_t width,int(__cdecl*compare)(const void*,const void*)); 
参数： 1 待排序数组，排序之后的结果仍放在这个数组中
　　　 2 数组中待排序元素数量
　　　 3 各元素的占用空间大小（单位为字节）
　　    4 指向函数的指针，用于确定排序的顺序（需要用户自定义一个比较函数）
返回值：返回值只能是>0、==0、<0

int compare(const void* left,const void* right)
  {
      int* p1 = (int*)left;
      int* p2 = (int*)right;
      return *p1-*p2;                                                                                                      
  }  
qsort(arr,N,sizeof(int),compare);

堆排

  void adjustMaxHeap(int *arr,int adjustPos,int arrLen)
  {
      int dad=adjustPos;
      int son=2*dad+1;
      while(son < arrLen)
      {   
      if(son+1<arrLen && arr[son]<arr[son+1])
      {   
          ++son;
      }   
      if(arr[dad]<arr[son])
      {   
          SWAP(arr[dad],arr[son]);
          dad=son;
          son=2*dad+1;
      }else{
          break;
      }   
      }   
  }
  void arrHeadp(int* arr)
  {
      int i;
      // 调整为大根堆
      for (i=N/2-1;i>=0;--i)
      {   
       adjustMaxHeap(arr,i,N);
      }   
      SWAP(arr[0],arr[N-1]);
      for (i=N-1;i>1;--i) {
       adjustMaxHeap(arr,0,i);
       SWAP(arr[0],arr[i-1]);
      }   
  }   

基数排序

  void arrCount(int *arr)
  {
      int i,j,k;
      int count[M]={0}; // M代表随机数取值的一个范围
      for (i=0;i<N;++i)
      {   
          count[arr[i]]++;
      }   
      k=0;
      for (j=0;j<M;++j) // 要填入的值的范围
      {   
          for (i=0;i<count[j];++i) // 每一个要填入值的数量
          {   
              arr[k]=j;
              k++;
          }   
      }   
  }