七大排序算法

选择排序：选择一区域内的最大元素，把这个元素放置在区域的尾部

template<class T>
void mswap(T &first,T &second)//交换两值
{
T temp=NULL;
temp=first;
first=second;
second=temp;
};
template<class T>
T mmax(T a[],int size)// 找到最大值的下标
{
int vmax=a[0];
  int result1=0 ;
  for(int i=0;i<size;i++)
  {
  if(a[i]>vmax)
  {
     vmax=a[i];
 result1=i;
  }
  }
  return  result1;
};
template<class T>
void selecttionsort(T a[],int n)//选择排序
{
for(int size=n;size>1;size--)
{
int j=mmax(a,size);
mswap(a[j],a[size-1]);
}
}
冒泡排序：每次循环都把最大的数放在这次循环范围非尾部--可优化（优化已经排序好的情况 ）
template<class T>
void bubble(T a[],int size)
{
for(int i =0;i<size-1;i++)
{
if(a[i]>a[i+1])
{
mswap(a[i],a[i+1]);
}
}
}
template<class T>
void bubblesort(T a[],int size)
{
for(int i=size;i>1;i--)
{
bubble(a,i);
}
}

---

插入排序：重点在于插入这个步骤，我们以被插入数列已经排序好为前提，对这个已排数列进行插入

void insert(T a[],int n,T x)//对已排序数列进行插入
{
int i=n-1;
for(;i>=0&&x<a[i];i--)//现在是增序插入，如果改正for(;i>=0&&x>a[i];i--),则变成减序排列
{
a[i+1]=a[i];
}
a[i+1]=x;
}
template<class T>
void insertsort(T a[],int n)
{
for(int i=0;i<n;i++)
{
insert(a,i,a[i]);
}
}

---

归并排序: 先将数组二分，然后递归这个过程，直到每个数组只有一个元素位置，实际的排序过程在合并的过程中，我们比较两个子序列中的第一个元素，把相对来说小的放在临时数组中，重复这个比较过程，重复这个赋值过程，。

template<class T>
void mergearray(T a[], int first, int mid, int last, int temp[])  //合并
{
int i = first, j = mid + 1;  
        int m = mid,   n = last;  
        int k = 0;
while(i<=m&&j<=n)
{
if(a[i]<a[j])
{
temp[k++]=a[i++];
}
else
{
temp[k++]=a[j++];
}
}
while(i<=m)
{
temp[k++]=a[i++];
}
while(j<=n)
{
temp[k++]=a[j++];
}
for (i = 0; i < k; i++)  
        a[first + i] = temp[i]; 
}
template<class T>
void mergesort(T a[],int first ,int last ,T temp[])//递归调用归并排序
{
int mid=(first+last)/2;
if(first<last)
{
mergesort(a,first,mid,temp);
mergesort(a,mid+1,last,temp);
mergearray(a,first,mid,last,temp);
}
}

一个改进的地方：

---

快速排序：一般选择第一个元素为主元素，然后通过与主元素的比较，比主元素小的放在主元素左边，与主元素大的放在主元素右边，最后把主元素放在“中间”（ps：如果主元素是排序时比较中间的元素，那么就应该放在比较靠中间的位置，当然也有特殊情况）

template<class T>
T Adjustarray(T a[],int l ,int r)//实现“小”元素放左边，“大”元素放右边，主元素放中间
{
int i=l;
int j=r;
T x=a[i];
while(i<j)
{
while(i<j&&a[j]>x)
{
j--;
}
if(i<j)
{
a[i]=a[j];
i++;
}
while(i<j&&a[i]<x)
{
i++;
}
if(i<j)
{
a[j]=a[i];
j--;
}
}
a[i]=x;
return i;    
}
template<class T>
void Quiksort(T a[],int l,int r)//实现递归调用
{
int mid=0;
if(l<r)
{
mid=Adjustarray(a,l,r);
Quiksort(a,l,mid-1);
Quiksort(a,mid+1,r);
}
}

---

计数排序：计数排序不是基于比较的排序，只有不基于比较的排序，才有可能创造线性时间的排序算法

A表示原始数据，C表示统计个数，B表示排序后的数据，k表示数值的最大范围，l表示数据个数。

（注意：K的值是说的最大范围，如果一个序列是（2,4,1,5，9）那么k的值为10，因为范围是0~9）

template<class T>
void CountSort(T A[],T B[],int k,int l) 
{
T *C=new T[k];
for(int i=0;i<k;i++)
{
C[i]=0;
}
for(int i=0;i<l;i++)
{
  C[A[i]]+=1;
}
for(int i=1;i<k;i++)
{
C[i]=C[i]+C[i-1];
}
cout<<endl; 
for(int i=l-1;i>=0;i--)
{
B[C[A[i]]-1]=A[i];
C[A[i]]=C[A[i]]-1; 
}
delete[]C; 
C=nullptr;
}

---

堆排序： 建立一个大顶堆，然后不断把堆顶和最后一个元素交换

template<class T>
void Swap(T &first,T &second)//交换两值
{
T temp=NULL;
temp=first;
first=second;
second=temp;
};
void HeapAdjust(int a[],int s,int m)
{
int temp,j;
temp=a[s];
for(j=2*s+1;j<m;j=j*2+1)
{
if(j+1<m&&a[j]<a[j+1])
{
++j;
}
if(temp>a[j])
{
break;
}
a[s]=a[j];
s=j;
}
a[s]=temp;
}
void HeapSort(int a[])
{
int i=(15-1)/2-1 ;
for(i;i>=0;i--)
{
HeapAdjust(a,i,15);
}
/*cout<<"the heap is ``"<<endl;
for(int i=0;i<15;i++)
{
cout<<a[i]<<"  ";
}*/
for(int j=15-1;j>0;j--)
{
Swap(a[0],a[j]);
HeapAdjust(a,0,j-1);
}
}
int main()
{
    int a[]={2,4,6,8,9,6,5,1,6,7,8,9,4,3,2};
//int b[sizeof(a)/sizeof(int)]={};
cout<<"the original:"<<endl;
for(int i=0;i<sizeof(a)/sizeof(int);i++)
{
cout<<a[i]<<"  ";
}
cout<<endl;
//int num=(sizeof(a)/sizeof(int));
HeapSort(a);
cout<<"the  alerted:  "<<endl;
for(int i=0;i<sizeof(a)/sizeof(int);i++)
{
cout<<a[i]<<"  ";
}
cout<<endl;
}