总结一下排序的各类算法,包括冒泡排序、插入排序、快速排序,关于堆排序见博客:堆及其算法。
1.冒泡排序
冒泡排序是效率很低(n^2)的排序,一般情况下都不会使用的,在小数据时还可以考虑,不过没有见过算法库使用冒泡排序的,一般的算法库在小数据情况下使用插入排序。
冒泡排序的思想很简单,逆序两两交换,两层循环。
源码:
void BubbleSort1(int a[], int len)
{
if(len<2) return;
int i,j;
for(i=0;i<len;i++) //这个循环只是为了计数的
for(j=1;j<len-i;j++)
if(a[j]<a[j-1]) //这个表达式可以设定排序顺序
swap(a[j],a[j-1]);
}
优化:可以将swap函数展开以牺牲代码的简洁性来优化效率。其实直接定义为宏或者inline就可以了。
#dedine swap(a,b) a^=b^=a^=b
void BubbleSort2(int a[], int len)
{
if(len<2) return;
int i,j;
data_type t;
for(i=0;i<len;i++) //这个循环只是为了计数的
for(j=1;j<len-i;j++)
if(a[j]<a[j-1])
{
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
2.插入排序
插入排序的时间复杂度为O(n^2),空间复杂度为O(1)。插入排序的思想就好比是整理扑克牌,前段是有序区,后段无序区,为无序区的每一个元素在有序区选择合适的插入位置,然后有序区插入位置之后的元素循环后移1位(这里有点类似冒泡,所以也是两层循环)。
源码:
void InsertSort1(int a[], int len)
{
if(len<2) return;
int i,j;
for(i=1;i<len;i++)
for(j=i;j>0&&a[j]<a[j-1];j--)
swap(a[j],a[j-1]);
}
优化:1、可以将swap展开
void InsertSort2(int a[], int len)
{
if(len<2) return;
int i,j;
data_type t;
for(i=1;i<len;i++)
for(j=i;j>0&&a[j]<a[j-1];j--)
{
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
继续优化:如果t在循环内部的话,是冒泡的效果,如果将t的复制提到循环外部的话,那么就是循环移位最后进行一次赋值就可以了。
void InsertSort3(int a[], int len)
{
if(len<2) return;
int i,j;
data_type t;
for(i=1;i<len;i++)
{
t=a[i];
for(j=i;j>0&&a[j-1]>t;j--) //注意这里的判定条件,与InsertSort2进行比较
a[j]=a[j-1];
a[j]=t;
}
}
继续优化:先比较首尾元素,因为最小元素必须在首端,如果尾端元素小于首端元素,那么不如一次做完拉倒(这是STL中的方式)。
void InsertSort4(int a[], int len)
{
if(len<2) return;
int i,j;
data_type t;
if(a[0]>a[len-1]) //头比尾还小
swap(a[0],a[len-1]);
for(i=1;i<len;i++)
{
t=a[i];
for(j=i;j>0&&a[j]<a[j-1];j--)
a[j]=a[j-1];
a[j]=t;
}
}
3.快速排序
快速排序的基本思想是:首先先从数列中取出一个数作为基准数。然后进行分区,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。再对左右区间重复第二步,直到各区间只有一个数。
但是关于快速排序的实现有不同的方式,当然考虑越多效率越高。
首先来看单端遍历的快速排序版本:
//该版本将首端元素作为主元
void QuickSort1(int a[],int len)
{
if(len<2) return;
int i,m=0; //i用于遍历数组,m标记位置,指向最后一个小于key的值
data_type key=a[0];
for(i=1;i<=len;i++)
{
if(a[i]<key)
swap(a[++m],a[i]);
}
swap(a[m],a[0]);
QuickSort1(a,m);
QuickSort1(a+m+1,len-m-1);
}
优化:可以进行双端的搜寻,左端向右搜寻,直至所指元素值大于主元时停止,右端向左搜寻,直至所指元素值小于主元时停止,然后交换搜寻到的两值。搜寻过程中一直检测指针是否交叉。
void QuickSort2(int a[],int len)
{
if(len<2) return;
int i=0; //i,j分别为前后段搜索标号,注意这里i和j的初值
int j=len; //因为后面使用的是do-while语句
data_type key=a[0];
for(;;)
{
do i++; while(i<(len-1)&&a[i]<key);
do j--; while(j>0&&a[j]>key);
if(i>=j) break; //这里必须是>=相等的时候必须返回,如果不返回,开始另外的一轮循环,j的位置就不对了
swap(a[i],a[j]);
}
swap(a[0],a[j]);
QuickSort2(a,j);
QuickSort2(&a[j+1],len-j-1);
}
优化:接下来需要考虑的是主元的选择方式,如果主元选a[0]的话,那么算法的效率将与数据的排列方式有很大的关系,为了获得平均复杂度,需要引入随机性。有两种方式,一种随机性弱点的是三端法,选取首中尾端三个元素的中值作为主元;另外一种是引入一个随机函数randint来选择主元的标号。选好主元之后要将主元交换到首端。
最后的优化是对快速排序缺陷的避免,因为快速排序在小数据上的效果不太理想。而且经过快速排序数据将分为很多段逆序数小的小数据段。对这种小数据段,应用插入排序效果更好。所以引入一个阀值cutoff(STL标准定义为__stl_threshold=16),当数据段的长度小于等于该阀值的时候对该数据段进行插入排序。对于不同的机器,阀值的大小是不一样的,可以进行测定。
还能附加一点就是SGI版本的STL特有的优化,防止过多次数的分割,也就是迭代次数不能过多。
void Sort(int a[],int len)
{
if (len<8) //阀值选为8
InsertSort3(a,len);
else
{
int k=rand()%len;
swap(a[0],a[k]); //这里运用随机的方式选取主元
int i=0;
int j=len;
int key=a[0];
for(;;)
{
do i++; while(i<(len-1)&&a[i]<key);
do j--; while(a[j]>key);
if(i>j) break;
swap(a[i],a[j]);
}
swap(a[0],a[j]);
Sort(a,j);
Sort(a+j+1,len-j-1);
}
}
5.归并排序
归并排序是要开辟O(n)的空间的,每一次处理归和并都需要传入该空间(地址)。
注意下面代码的函数接口!!!!
void merge(int a[],int begin,int mid,int end,int temp[])
{
int i=begin,j=mid+1;
int k=0;
while(i<=mid&&j<=end)
{
if(a[i]<a[j])
temp[k++]=a[i++];
else
temp[k++]=a[j++];
}
if(i>mid)
while(j<=end)
temp[k++]=a[j++];
else
while(i<=mid)
temp[k++]=a[i++];
for(i=0;i<k;i++)
a[begin+i]=temp[i];
}
void mergesort(int a[],int begin,int end,int temp[])
{
if(end>begin)
{
int mid=begin+(end-begin)/2;
mergesort(a,begin,mid,temp);
mergesort(a,mid+1,end,temp);
merge(a,begin,mid,end,temp);
}
}
void MergeSort(int a[],int len)
{
if(a==NULL||len<1)
return;
int *p=new int[len];
mergesort(a,0,len-1,p);
delete [] p;
}
5.1单链表的排序
一般数组排序用快速排序,而链表排序用归并排序。因为因为无法向前寻找节点,所以插入排序不适用,冒泡排序需要稍微的修改,但是O(n^2)的复杂度不佳。快速排序只能用单端的模式。如果使用归并排序的话,链表还可以避免归并排序开辟O(n)空间的缺点,并且是对数时间完成排序!
而单链表的归并排序中一般归的步骤使用递归的,而并的步骤可以选用递归也可以选用非递归。当然选非递归的更加好。其实链表的归并排序依然是归并的思想,对于链表而言,特殊性在于参数为链表头结点。所以需要寻找到链表的中间结点,故用快慢指针!!并且中间结点在归的过程中需要将right设置为NULL,这样才能将两个链表分开!
typedef struct LNode
{
int data;
struct LNode *next;
}LNode;
typedef LNode* LinkList;
// 对两个有序的链表进行递归的归并
LinkList MergeList_recursive(LinkList head1 , LinkList head2)
{
LinkList result;
if(head1 == NULL)
return head2;
if(head2 == NULL)
return head1;
if(head1->data < head2->data)
{
result = head1;
result->next = MergeList_recursive(head1->next , head2);
}
else
{
result = head2;
result->next = MergeList_recursive(head1 , head2->next);
}
return result;
}
// 对两个有序的链表进行非递归的归并
LinkList MergeList(LinkList head1 , LinkList head2)
{
LinkList head , result = NULL;
if(head1 == NULL)
return head2;
if(head2 == NULL)
return head1;
while(head1 && head2)
{
if(head1->data < head2->data)
{
if(result == NULL)
{
head = result = head1;
head1 = head1->next;
}
else
{
result->next = head1;
result = head1;
head1 = head1->next;
}
}
else
{
if(result == NULL)
{
head = result = head2;
head2 = head2->next;
}
else
{
result->next = head2;
result = head2;
head2 = head2->next;
}
}
}
if(head1)
result->next = head1;
if(head2)
result->next = head2;
return head;
}
// 归并排序,参数为要排序的链表的头结点,函数返回值为排序后的链表的头结点
LinkList MergeSort(LinkList head)
{
if(head == NULL)
return NULL;
LinkList r_head , slow , fast;
r_head = slow = fast = head;
while(fast->next != NULL && fast->next->next != NULL)
{
slow = slow->next;
fast = fast->next->next;
}
if(slow->next == NULL) // 链表中只有一个节点
return r_head;
fast = slow->next;
slow->next = NULL;
slow = head;
// 函数MergeList是对两个有序链表进行归并,返回值是归并后的链表的头结点
//r_head = MergeList_recursive(MergeSort(slow) , MergeSort(fast));
r_head = MergeList(MergeSort(slow) , MergeSort(fast));
return r_head;
}