排序

Sort

Insertation 直接插入排序

//直接插入排序
template<class T>
void InsertionSort(T Data[],int n){//利用直接插入排序对于n个数据元素进行不减序排序 
 int p,i;
 for(p = 1;p < n;p++){//循环，p表示插入趟数，共进行n-1趟插入 
  T temp = Data[p];//把待插入元素赋给temp
  i = p-1;
  while(i>=0 && Data[i]>temp){//把比temp大的元素都向后移动 
   Data[i+1] = Data[i];
   i--;
  } 
  Data[i+1] = temp;//i+1为temp的位置，将temp插入到这个位置 
 }
}

BinaryInsert 折半插入排序

//折半插入排序
template<class T>
void BinaryInsertionSort(T Data[],int n){//参数：待排序数据和待排序元素个数 
 int left,mid,right,p;//声明一些变量
 for(p = 1;p < n;p++){//共进行n-1次插入 
  T temp = Data[p];//保存待插入数据 
  left = 0;right = p-1;//初始化left和right的值
  while(left <= right){//执行折半查找 
   mid = (left+right)/2;//求出中心点
   if(Data[mid] > temp)//中心点元素值比待插入数据大
    right = mid-1;//更新右区间值
   else
    left = mid+1;//更新左区间值 
  } 
  for(int i = p-1;i >= left;i--)//执行移动操作
    Data[i+1] = Data[i];
  Data[left] = temp;//将待插入元素插入到有序表中 
 } 
}

Selection 选择排序

//选择排序
template<class T>
void SelectionSort(T Data[],int n){
 for(int i = 1;i < n;i++){//共进行n-1趟选择，第i趟时的待排序列为Data[i-1],...,Data[n-1] 
  int k = i-1;//记录当前待排序列的第一个元素
  for(int j = i;j < n;j++){//找到待排序列中最小元素的下标 
   if(Data[j] < Data[k])
     k=j;
  } 
    if(k != i-1){//交换最小元素到当前待排序列的第一个位置 
     T t = Data[k];
     Data[k] = Data[i-1];
     Data[i-1] = t;
    }
   }
}

Bubble 冒泡排序

//冒泡排序
template<class T>
void BubbleSort(T Data[],int n){
 for(int i = 0;i < n;i++){//外层循环控制排序的每一趟 
  for(int j = i+1;j < n;j++){//内层循环控制本趟中的冒泡操作 
   if(Data[j] < Data[j-1]){//如果是逆序的，则交换这两个元素 
    T t = Data[j];
    Data[j] = Data[j-1];
    Data[j-1] = t;
   }
  }
 }
}

Merge 归并排序

//归并排序
template<class T>//函数Merge,参数Data是待归并数组，其中对Data[start,mid]和Data[mid+1,end]之间的数据进行归并
void Merge(T Data[],int start,int mid,int end){
 int len1 = mid-start+1,len2 = end-mid;//分别表示两个归并间的长度
 int i,j,k;
 T* left = new T[len1];//临时数组用来存放Data[start,mid]数据
 T* right = new T[len2];//临时数组用来存放Data[mid+1,end]
 for(i = 0;i < len1;i++)//执行数据复制操作
   left[i] = Data[i+start];
 for(i = 0;i < len2;i++)//执行数据复制操作
   right[i] = Data[i+mid+1];
 i = 0;j = 0;
 for(k = start;k < end;k++){//执行归并 
  if(i==len1 || j==len2)
    break;
  if(left[i] <= right[j])
    Data[k] = left[i++];
  else
    Data[k] = right[j++];
 }
 while(i < len1)//若Data[start,mid]还有待归并数据，则放到Data后面
   Data[k++] = left[i++];
 while(j < len2)//对Data[mid+1,end]间的数据执行同样的操作
   Data[k++] = right[j++];
 delete []left;//释放内存
 delete []right; 
}


template<class T>
void MergeSort(T Data[],int start,int end){//对Data[start]-Data[end]之间的序列进行归并排序 
 if(start < end){
  int mid = (start+end)/2;//计算中间位置
  MergeSort(Data,start,mid);//对左边子序列归并排序
  MergeSort(Data,mid+1,end);//对右边子序列归并排序
  Merge(Data,start,mid,end);//归并左、右两边的有序序列 
 }
}

Heap 堆排序

template<class T>
void HeapSort(T Data[], int n){
  BuildHeap(Data,n);//建立一个最大堆
  for(int i = n-1; i > 0;i--){//进行循环
    T t = Data[0];//每次取出最大元素后不断调整最大堆
    Data[0] = Data[i];
    Data[i] = t;
    MaxHeap(Data,0,i);
  }
}

**Quick 快速排序

//快速排序
template<class T>
int Partition(T Data[],int left,int right){//实现对data[left]到data[right]的分割操作，并返回划分后轴元素对应的位//置 
 T pivot = Data[left];//选择最左边的为轴元素
 while(left < right){//外层循环控制遍历数组 
  while(left<right && Data[right]>pivot)//控制right指针的移动
   right--;
  Data[left] = Data[right];//将right指向的数据移动到left位置
  while(left<right && Data[left]<=pivot)//控制left指针移动
   left++;
  Data[right] = Data[left];//将left指向的数据移动到right位置 
 } 
 Data[left] = pivot;//将轴元素放到left位置
 return left;//返回轴元素的新位置，实现分治 
}


template<class T>
void QuickSort(T Data[],int left,int right){//用分治法实现快速排序算法 
 if(left < right){//控制分治的结束条件 
  int p = Partition(Data,left,right);//实现分割并找到分离的位置 
  QuickSort(Data,left,p-1);//对左边的子序列进行快速排序
  QuickSort(Data,p+1,right);//对右边的子序列进行快速排序 
 }