数据结构重要排序算法总结

插入排序

排序思想:

将待排序的记录Ri;,插入到已排好序的记录表R1，
R2,····Ri-1中，得到一个新的、记录数增加1的有序表。
直到所有的记录都插入完为止。
设待排序的记录顺序存放在数组R[1···n]中，在排
序的某一时刻，将记录序列分成两部分:
R[1···i-1]:已排好序的有序部分;
R[1···n]:未排好序的无序部分。
显然，在刚开始排序时，R[1]是 已经排好序的。

void straight_insert_sort(Sqlist *L){
	int i,j;
	for(i=2;i<=L->length;i++){
		L->R[0] = L->R[i];	//设置哨兵
		j= i-1;
		while(L->R[0].key<L->R[j].key){
			L->R[j+1] = L->[j];
			j--;
		}
		L->R[j+1]=L->R[0]; //插入到相应位置
	}
}

---

折半插入排序

当将待排序的记录R[i]插入到已排好序的记录子
表R[1···i-1]中时，由于R1，R2，···Ri-1已排好序，
则查找插入位置可以用“折半查找”实现，则直接插入
排序就变成为折半插入排序。

void Binary_insert_sort(Sqlist *L){
	int i,j,low,high,mid;
	for(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(L->R[0].key<L->R[mid].key){
				high=mid -1;				
			}else{
				low = mid+1;
			}		//查找位置
			for(j= i-1; j>=high+1;j--){
				L->R[j+1]= L->R[j];
			
			}
			L->R[high+1] = L->R[0]	//插入到相应位置
		}
	}
}

---

希尔排序

希尔排序(Shell Sort,又称缩小增量法)是一种分组插入排序方法。
1排序思想
①先取一个正整数d1(d1<n)作为第一个增量，将全部
n个记录分成d1组，把所有相隔d1的记录放在一组中，
即对于每个k(k=1, 2,···d1),R[k],R[d1+k],R[2d1+k],
…分在同一组中，在各组内进行直接插入
排序。一次分组和排序过程称为一趟希尔排序;
②取新的增量d2<d1,重复①的分组和排序操作;直至
所取的增量di=1为止，即所有记录放进一个组中排序
为止。
先给出一趟希尔排序的算法，类似直接插入排序。

int main(void)
{
    int i, len, * a;
    printf("请输入要排的数的个数：");
    scanf("%d",&len);
    a = (int *)malloc(len * sizeof(int)); // 动态定义数组
    printf("请输入要排的数：\n");
    for (i = 0; i < len; i++) { // 数组值的输入
        scanf("%d",&a[i]);
    }   
    shellSort(a, len); // 调用希尔排序函数
    printf("希尔升序排列后结果为：\n");
    for (i = 0; i < len; i++) { // 排序后的结果的输出
        printf("%d\t",a[i]);
    }
    printf("\n");

    return 0;
}

void shellSort(int *a, int len)
{
    int i, j, k, tmp, gap;  // gap 为步长
    for (gap = len / 2; gap > 0; gap /= 2) {  // 步长初始化为数组长度的一半，每次遍历后步长减半,
    	for (i = 0; i < gap; ++i) { // 变量 i 为每次分组的第一个元素下标 
	        for (j = i + gap; j < len; j += gap) { //对步长为gap的元素进行直插排序，当gap为1时，就是直插排序
	            tmp = a[j];  // 备份a[i]的值
	            k = j - gap;  // j初始化为i的前一个元素（与i相差gap长度）
	            while (k >= 0 && a[k] > tmp) {
	                a[k + gap] = a[k]; // 将在a[i]前且比tmp的值大的元素向后移动一位
	                k -= gap;
	            }
	            a[k + gap] = tmp; 
	        }
	    }
    }
}

---

冒泡排序

void Bubble_Sort(Sqlist *L){
	int j,k,flag;
	for(j=1;k<=L->length;k++){
		flag=TRUE;			//加被个标志，判断是否有序
		for(k=1;k<=L->length-j;k++){
			if(L->R[k+1].key<L->R[k].key){
				flag = FALSE;
				L->R[0] = R[k];
				L->R[k] = R[k+1];
				L->R[k+1] = L->R[0];
			}
		}
		if(flag == TRUE){	//如果没有发生交换，则数组有序，无需再进行循环
			break;
		}
	}
}

---

快速排序

#include<stdio.h>
void Swap(int arr[], int low, int high)
{
    int temp;
    temp = arr[low];
    arr[low] = arr[high];
    arr[high] = temp;
}
 
int Partition(int arr[], int low, int high)
{
    int base = arr[low];
    while(low < high)
    {
        while(low < high && arr[high] >= base)
        {
            high --;
        }
        Swap(arr, low, high);
        while(low < high && arr[low] <= base)
        {
            low ++;
        }
        Swap(arr, low, high);
    }
    return low>=base?low:low+1;
}
 
void QuickSort(int arr[], int low, int high)
{
    if(low < high)
    {
        int base = Partition(arr, low, high);
        QuickSort(arr, low, base - 1);
        QuickSort(arr, base, high);
    }
}
 
int main()
{
    int n;
    scanf("%d\n",&n);
    int arr[n];
    int i , j;
    for(i = 0; i < n; i ++)
    {
        scanf("%d",&arr[i]);
    }
    printf("\n");
    QuickSort(arr, 0, n-1);
    for(j = 0; j < n; j ++)
    {
        printf("%4d",arr[j]);
    }
    return 0;
}

---

归并排序

/* 将SR[s..t]归并排序为TR1[s..t] */
void MSort(int SR[], int TR1[], int s, int t){
	int m;
	int TR2[MAXSIZE+1];
	if(s == t)
		TR1[s] = SR[s];
	else{
		m = (s+t)/2;		//将SR[s..t]平分为SR[s..m]和SR[m+1..t]
		MSort(SR, TR2, s, m);	//递归将SR[s..m]归并为有序的TR2[s..m]
		MSort(SR, TR2, m+1, t);		//递归将SR[m+1..t]归并为有序TR2[m+1..t]
		Merge(TR2, TR1, s, m, t);	//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
	}
}


/* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */
void Merge(int SR[], int TR[], int i, int m, int n){
	int j, k, l;
	for(j=m+1,k=i;i<=m && j<=n;k++){	//将SR中记录由小到大归并入TR
		if(SR[i] <SR[j])
			TR[k] = SR[i++];
		else
			TR[k] = SR[j++];
	}
	if(i<m){
		for(l=0;l<=m-i;l++)
			TR[k+l] = SR[i+l];		//将剩余的SR[i..m]复制到TR
	}
	if(j<=n){
		for(l=0;l<=n-j;l++)
			TR[k+l] = SR[j+l];		//将剩余的SR[J..N]复制到TR
	}
}

/* 对顺序表L作归并排序 */
void MergeSort(SqList *L){
	MSort(L->r, L->r, 1, L->length);
}

---

堆排序

void heapify(int tree[], int n, int i) {	//每个节点进行判断
	if(i>=n){		//大于数组长度n时return
		return;
	}
		int c1= 2* i+1;		//左孩子
		int c2=2*i+2;		//右孩子
		int max=i;
	if (c1 < n && tree[c1] > tree [max]) {	//右孩子大于parent
		max = c1;
	}
	if (c2 < n && tree[c2] > tree[max]) {	//左孩子大于parent
		max = c2;
	}
	if(max != i){
		swap(tree,max,i);	//交换
		heapify(tree,n,max);//递归
	}

}

void swap(int arr[],int i,int j){	//交换
	int temp = arr[i];
	arr[i] =arr[i];
	arr[j] =temp;
}

int main(){		//主函数
	int tree[]={4,10,3,6,1,7};
	int n = 6;
	heapify(tree,n,0);		
	for(i =0;i<n;i++){		//遍历输入
		printf("%d",tree[i]);
	}
}

算法复杂度