2021-04-16 数据结构

学习目标：

排序的操作

学习内容：

1.插入排序：
a：直接插入
b：折半插入排序
2:.选择排序：
a:简单选择排序
b:堆排序
3.交换排序：
a:起泡排序
b:快速排序
4.二路归并排序
5.基数排序
6.外部排序

学习时间：

2021.04.13到2021.4.16 上午

学习产出：

1.插入排序：
a：直接插入

void InsertSort(int R[], int n)
{
	int i, j;
	int temp;
	for (i = 1; i < n; ++i)
	{
		temp = R[i];
		j = i - 1;
		while (j >= && temp < R[j])
		{
			R[j + 1] = R[j];
			--j;
		}
		R[j + 1] = temp;
	}
}

b：折半插入排序
c：希尔排序

2:.选择排序：
a:简单选择排序

//简单选择排序
void SelectSort(int R[], int n)
{
	int j, i, k;
	int temp;
	for (i = 0; i < n; ++i)
	{
		k = i;
		for (j = i + 1; j < n; ++i)
			if (R[k] > R[j])
				k = j;
		temp = R[i];
		R[i] = R[k];
		R[k] = temp;
	}
}

b:堆排序

//堆排序
void Sift(int R[], int low, int high)
{
	int i = low.j = 2 * i;                     //R【j】是R【i】的左孩子结点
	int temp;
	while (j <= high)
	{
		if (j < high && R[j] < R[j + 1])      //若有孩子比较大，则j指向右孩子
			++j;
		if (temp < R[j])
		{
			R[i] = R[j];                      //将R【j】调整到双亲结点的位置
			i = j;
			j = 2 * i;
		}
		else
			break;
	}
	R[i] = temp;                              //将被调整结点的值放入最终位置
}
//堆排序函数
void headSort(int R[], int n)
{
	int i;
	int temp;
	for (in = n / 2; i >= 1; --i)            //建立初始堆
		Sift(R, i, n);
	for (i = n; i >= 2; --i)                //建立n-1循环，完成堆排序
	{
		temp = R[1];
		R[1] = R[i];
		R[i] = temp;
		Sift(R, i, n - 1);                  //在关键词-1的无序序列进行调整
	}

}

//二路归并排序
void mergeSort(int A[], int low, int high)
{
	if (low < high)
	{
		int mid = (low + high) / 2;
		mergeSort(A, low, mid);            //归并前半段
		mergeSort(A, mid + 1, high);       //归并后半段
		merge(A, low, mid, high);
	}
}

3.交换排序：
a:起泡排序

//起泡排序（冒泡排序）
void BubbleSort(int R[], int n)
{
	int i, j, flag;
	int temp;
	for (i =n- 1; i >=1; ++i)
	{
		flag = 0;                       //变量flag标记是否发生了交换
		for(j=1;j<=1;++j)
		{
			if (R[j - 1] > R[j])
			{
				temp = R[j];
				R[j] = R[j - 1];
				R[j - 1] = temp;
				flag = 1;               //如果没有发生交换，为0；发生后为1
			}
			if (flag == 0)              //都排完了，flag全部都是0
				return;
	}
}

b:快速排序

//快速排序
void QuickSort(int R[], int low, int high)
{
	int temp;
	int i = low, j = high;
	if (low < high)
	{
		temp = R[low];
		while (i < j)
		{
			while (j > i && R[j] >= temp)
				--j;
			if (i < j)
			{
				R[i] = R[j];
				++i;
			}
			while (i < j && R[i] < temp)
				++i;
			if (i < j)
			{
				R[j] = R[i];
				--j;
			}
		}
		R[i] = temp;
		QuickSort(R, low, i - 1);
		QuickSort(R, i + 1, high);
	}
}

4.二路归并排序

void mergeSort(int A[], int low, int high)
{
	if (low < high)
	{
		int mid = (low + high) / 2;
		mergeSort(A, low, mid);            //归并前半段
		mergeSort(A, mid + 1, high);       //归并后半段
		merge(A, low, mid, high);
	}
}

5.基数排序
6.外部排序