王道数据结构第八章排序（笔记及代码）

插入排序

直接插入排序

1.一个指针记录待插入元素1~n-1
2.另一指针用来遍历左边元素i-1~0
3.如果比待插入元素大，往右移
4.比待插入元素小，则插在后面
void InsertSort(int A[],int n){
	int i,j,temp;
	for(i = 1;i < n;i++){
		if(A[i] < A[i-1]){
			temp = A[i];
			for(j = i - 1;j >= 0 && temp < A[j];j--){
					A[j+1] = A[j];
			}
			A[j+1] = temp;
		}
	}
}

直接插入排序(哨兵)

1.从第二个元素开始
2.先将待插入元素作为哨兵
3.遍历左边元素
4.如果比哨兵大，往右移
5.比哨兵小，则插在后面
void InsertSort(int A[],int n){
	int i,j;
	for(i = 2;i < n;i++){
		if(A[i] < A[i-1]){
			A[0] = A[i];
			for(j = i-1;A[0] < A[j];j--){
				A[j+1] = A[j];	
			}
			A[j+1] = A[0];
		}	
	}
}

折半插入排序

1.从第二个元素开始
2.先将待插入元素作为哨兵
3.折半方式遍历左边元素
4.low > high时折半查找停止，将low右边元素全部右移，将哨兵插入(mid>哨兵：high ＝ mid - 1；mid<哨兵：low ＝ mid + 1)
5.注意：当mid ＝哨兵时，继续在mid右边找
void InsertSort(inr A[],int n){
	int i,j,high,low,mid;
	for(i = 2;i <= n;i++){
		if(A[i] < A[i-1]){
			A[0] = A[i];
			low = 1;
			high = i-1;
			while(low <= high){
				mid = (low + high) / 2;
				if(A[mid] <= A[0])
					low = mid + 1;
				else
					high = mid - 1;
			}
			for(j = i-1; j >= low;j--)
				A[j+1] = A[j];
			A[low] = A[0];
		}
	}
}

希尔排序

• 不稳定
• 仅适用于顺序表，不适用于链表

1.趟数遍历（条件：d:(n/2)~1，每次除2）
2.对各个子表遍历（条件：d+1～n）
3.对遍历的每个子表进行排序
4.对遍历的每个子表进行直接插入排序
5.注意：插入排序时注意间隔（条件：0～j-d，每次减d）
void InsertSort(int A[],int n){
	int d,i.j;
	for(d = n/2;d >= 1;d = d/2){
		for(i = d + 1;i < n;i++){
			if(A[i] < A[i-d]){
				A[0] = A[i];
				for(j = i-d;j > 0 && A[0] < A[j];j -= d)
					A[j+d] = A[j];
				A[j+d] = A[0];	
			}	
		}	
	}
}

冒泡排序

• 区分交换次数和移动次数
• 交换次数：调用swap次数
• 移动次数：每次交换移动三次

void swap(int &a,int &b){
	int temp = a;
	a = b;
	b = temp;
}
//递增
void BubbleSort(int A[],int n){
	for(int i = 0;i < n - 1;i++){
		bool flag = false;
		for(int j = n-1;j > i;j--){
			if(A[j] < A[j-1]){
				swap(A[j-1],A[j]);
				flag = true;	
			}
		}
		if(flag = false)	//一趟下来没有一次交换说明已经有序
			return;
	}
}
//递减
void BubbleSort(int A[],int n){
	for(int i = 0;i < n-1;i++){
		bool flag = false;
		for(int j = n-1;j > i;j--){
			if(A[j] > A[j-1]){
				swap(A[j-1],A[j]);
				flag = true;	
			}	
		}
		if(flag = false)	//一趟下来没有一次交换说明已经有序
			return;
	}
}

快速排序

• 时间复杂度=O(n*递归层数)：最好O(nlog2n);最坏O(n^2)
• 空间复杂度=O(递归层数)：最好O(log2n);最坏O(n)
• 不稳定

快速排序
1.划分并获取划分元素的位置
	<1>.选第一个元素为基准
	<2>.前提：low < high(等于时停止)
	<3>.high大于等于基准元素时继续-1左找，直至小于基准元素时，将high指向元素放左边(即low指向位置)
	<4>.low小于等于基准元素时继续+1右找，直至大于基准元素时，将low指向元素放右边(即high指向位置)
	<5>.最后将基准元素插入low＝high位置，并返回该元素位置
2.划分左子表
3.划分右子表
void QuickSort(int A[],int low,int high){
	if(low < high){
		int pivot = Partition(A,low,high);
		QuickSort(A,low,pivot - 1);
		QuickSort(A,pivot + 1,high);
	}
}
int Partition(int A[],int low,int high){
	int pivot = A[low];
	while(low < high){
		while(low < high && A[high] >= pivot)
			high--;	
		A[low] = A[high];
		while(low < high && A[low] <= pivot)
			low++;
		A[high] = A[low];
	}
	A[high] = pivot;
	return high;
}

选择排序

简单选择排序

• 时间复杂度O(n^2)
• 空间复杂度O(1)
• 不稳定
• 关键字对比次数一定是n(n-1)/2
• 无论是否乱序，一定需要n-1趟处理
• 元素交换次数＜n-1
• 既可以用于顺序表，也可以用于链表

1.遍历从0~n-1,最后一个元素会是确定的
2.预设最小值min = i
3.每遍历一个,就去后面找有没有更小的:有,则修改min
4.遍历完一个是后,若min不再等于i,交换i与min位置元素
void SeleteSort(int A[],int n){	//n为元素个数
	for(int i = 0;i <= n-2;i++){
		int min = i;	//预设最小值位置
		for(int j = i + 1;i <= n-1;i++){
			if(A[j] < A[min])
				min = j;	
		}
		if(min != i)
			swap(A[i],A[min]);
	}
}

堆排序