考研系列之数据结构——冒泡排序与快速排序

爱打篮球的程序员@

已于 2022-10-23 20:38:03 修改

阅读量114

点赞数

分类专栏：考研数据结构文章标签： c语言

于 2022-03-21 19:24:06 首次发布

本文链接：https://blog.csdn.net/weixin_45945300/article/details/123643645

版权

考研数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文介绍了一种使用C语言实现的冒泡排序和改进版快速排序算法，并通过实例演示如何初始化一个动态数组并应用这两种排序方法。首先，我们通过`SSTable`结构实现了简单的存储和打印操作。随后，作者对比了冒泡排序与快速排序的性能，重点讲解了快速排序的递归实现以及分区过程。最后，展示了完整的代码执行结果，包括对原始数组的排序前后变化。

摘要由CSDN通过智能技术生成

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
typedef int ElemType;
typedef struct{
	ElemType *elem;//存储元素的起始地址
	int TableLen;//元素个数
}SSTable;

void ST_Init(SSTable &ST,int len)
{
	ST.TableLen=len;
	ST.elem=(ElemType *)malloc(sizeof(ElemType)*ST.TableLen);
	int i;
	srand(time(NULL));//随机数生成，每一次执行代码就会得到随机的10个元素
	for(i=0;i<ST.TableLen;i++)
	{
		ST.elem[i]=rand()%100;//生成的是0-99之间
	}
}
void ST_print(SSTable ST)
{
	for(int i=0;i<ST.TableLen;i++)
	{
		printf("%3d",ST.elem[i]);
	}
	printf("\n");
}
void swap(ElemType &a,ElemType &b)
{
	ElemType tmp;
	tmp=a;
	a=b;
	b=tmp;
}
// 64 94 95 79 69 84 18 22 12 78
// 12 64 94 95 79 69 84 18 22 78
void BubbleSort(ElemType A[],int n)
{
	int i,j;
	bool flag;
	for(i=0;i<n-1;i++)//i最多访问到8
	{
		flag=false;
		for(j=n-1;j>i;j--)//把最小值就放在最前面
		{
			if(A[j-1]>A[j])
			{
				swap(A[j-1],A[j]);
				flag=true;
			}
		}
		if(false==flag)
			return;
	}
}

void BubbleSort1(ElemType A[], int n)
{
	int i, j,flag;
	for (i=0;i<n-1;i++)//i是控制有多少个有序了
	{
		flag = 0;
		for (j = n-1; j>i;j--)//内层控制比较，交换
		{
			if (A[j - 1] > A[j])
			{
				swap(A[j - 1], A[j]);
				flag = 1;
			}
		}
		if (0 == flag)
		{
			break;
		}
	}
}
// 64 94 95 79 69 84 18 22 12 78
//比64小的放在左边，比64大的放在右边
//int Partition(ElemType A[],int low,int high)
//{
//	ElemType 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[low]=pivot;
//	return low;
//}

int Partition1(int* arr, int left, int right)
{
	int k, i;//k记录要放入比分割值小的数据的位置
	for (i = left, k = left; i < right; i++)
	{
		if (arr[i] < arr[right])
		{
			swap(arr[k], arr[i]);
			k++;
		}
	}
	swap(arr[k], arr[right]);
	return k;
}

int Partition(int* arr, int left, int right)
{
	int k, i;
	for (k = i = left;i<right;i++)
	{
		if (arr[i] < arr[right])
		{
			swap(arr[i], arr[k]);
			k++;
		}
	}
	swap(arr[k], arr[right]);
	return k;
}
//递归实现
void QuickSort(ElemType A[],int low,int high)
{
	if(low<high)
	{
		int pivotpos=Partition(A,low,high);//分割点左边的元素都比分割点要小，右边的比分割点大
		QuickSort(A,low,pivotpos-1);
		QuickSort(A,pivotpos+1,high);
	}
}
//《王道C督学营》课程
//冒泡排序与快速排序
int main()
{
	SSTable ST;
	ElemType A[10]={ 64, 94, 95, 79, 69, 84, 18, 22, 12 ,78};
	ST_Init(ST,10);//初始化
	//memcpy(ST.elem,A,sizeof(A));//内存copy接口，当你copy整型数组，或者浮点型时，要用memcpy
	ST_print(ST);
	//BubbleSort1(ST.elem,10);//冒泡排序
	QuickSort(ST.elem,0,9);
	ST_print(ST);
	system("pause");
}