排序算法insert sort

#define MAXSIZE 20
typedef struct{
    Keytype key;
    Infotype info;
}Redtype;
typedef struct{
    Redtype r[MAXSIZE+1];
    int length;
}Sqlist;

排序算法
insert sort
思想：
1.插入第i个位置时，前面i-1个位置的元素都已经排好序；
2.待插入元素保存至r[0],这样可以减少j<0的讨论；
3.第i个元素依次与前面i-1个元素比较，找到第j个位置插入，因为r[0]就是该元素本身，可以直接插入到r[1];
4.原来位置的记录向后移动

void insertsort(Sqlist &L){
    for(i=2;i<=L.length;++i)
       if(LT(L.r[i].key,L.r[i-1].key)){   //触发条件：递增排列中前一个元素比i大
        L.r[0]=L.r[i];
        for(j=i-1;LT(L.r[0].key,L.r[j].key);--j) //只有当r[i]元素值比前面小才移动
            L.r[j+1]=L.r[j];
        L.r[j+1]=L.r[0];
       }
}

折半插入排序 Binary insertsort
思想：插入第i个元素时，前面i-1个元素已经排列有序，则只需要比较值的大小就可知插入的位置

void Binsertsort(Sqlist &L){
    for(int i=2;i<=L.length;++i){
        L.r[0]=L.r[i];
        low=1;high=i-1;
        while(low<=high){
            mid=(low+high)/2;
            if(LT(L.r[mid].key,L.r[0].key))
                low=mid+1;
            else high=mid-1;}
        for(int j=i-1;j>=high+1;--j)
            L.r[j+1]=L.r[j];
        L.r[high+1]=L.r[0];
    }
}

希尔排序
一共有n个记录待排序
步骤：
1.选取一个int d作为间隔，将全部记录分为d个子序列，所有距离为d的记录放置在同一个子序列中；
2.对每一个子序列进行insertsort；
3.缩小d，重复上述过程，直到d=1，所有记录都在用一个序列中；

void Shellsort(int *arr,int size)
{
	for(int step=size/2;step>=1;step/=2)	//设计步长，初始值定为size的一半，每次分解，直至为1
	{
		for(int i=step;i<size;++i)
		{
			if(arr[i-step]>arr[i])	//插入排序的触发条件，后一个数比前面小
			{
				int temp=arr[i];
				for(int j=i-step;j>=0 && arr[j]>temp;j-=step)
					arr[j+step]=arr[j];
				arr[j+step]=temp;
			}
		}
	}
}

交换排序：
Bubblesort
依次比较前后两个的大小关系，若有逆序则交换，冒泡算法最多在n-1趟中，每趟比较n-1次大小。

Quicksort
将待排序记录中某个记录（选择第一个记录）作为基准，按照它的关键字大小，将整个记录划分为左右两个子序列。（左子序列小于基准关键字。。。）
再对子序列重复上述过程，直至每个子序列为空或只有一个记录。

int Partition(Sqlist &L,int low,int high){            //划分函数
    L.r[0]=L.r[low];                    //这里选择第一个函数作为划分标准，用r[0]来存储
    pivotkey=L.r[0].key;                    //pivotkey存储值以便后续比较
    while(low<high){
        while(low<high && L.r[high].key>pivotkey)
        --high;
        L.r[low]=L.r[high];                //若后面的值没有比基准大，则需要互换位置
        while(low<high && L.r[low].key<pivotkey)
        ++low;
        L.r[high]=L.r[low];
    }
    L.r[low]=L.r[0];                    //此时，low=high 确定了基准所在的位置，并返回
    return low;
}

void Qsort(Sqlist &L,int low,int high){
    if(low<high){
        pivotloc=Partition(L,low,high);
        Qsort(L,low,pivotloc-1);
        Qsort(L,pivotloc+1,high);
    }
}

改进后的快速排序算法

int Quicksort(Sqlist &L,int low,int high){
	L.r[0]=L.r[low];
	int i=low;
	int j=high;
	int pivotkey=L.r[i].key;
	while(i<j){
		while(i<j && (L.r[j].key>pivotkey)||(L.r[j].key == pivotkey && j>i))
             //如果出现相同的关键字，则可能进入无限循环，所以对相同关键字进行讨论
			--j;
		L.r[i]=L.r[j];
		while(i<j && (L.r[i].key<pivotkey)||(L.r[i].key == pivotkey && j>i))
			++i;
		L.r[j]=L.r[i];
    }
	L.r[i]=L.r[0];
	if(i-1>low)            //对基准值的左边进行递归，只要符合条件即可
		Quicksort(L,low,i-1);
	if(i+1<high)
		Quicksort(L,i+1,high);
	return 0;
}