数据结构 冒泡&快排&堆代码

冒泡排序和快速排序。

#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;
	}
}
void swap(ElemType& a, ElemType& b)
{
	ElemType temp;
	temp = a;
	a = b;
	b = temp;
}
void BubbleSort(ElemType A[], int n)
{
	int i, j;
	for (i = 0; i < n-1; i++) {
		{
			for (j = n - 1; j > i; j--)
			{
				if (A[j - 1] > A[j])
				{
					swap(A[j - 1], A[j]);
				}
			}
		}
	}
	
}
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);
	}
}
void InsertSort(ElemType 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];
		}
	}
}
void MidInsertSort(ElemType A[], int n)//考得很少
{
	
}

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
	/*strcpy是到0就结束了，而memcpy是你让它拷贝多少空间就多少（sizeof），不看0*/
	BubbleSort(ST.elem, 10);
	QuickSort(ST.elem, 0, 9);
}

堆排序代码。

/跟王道（第0个不参与排序）不一样，这个是所有元素参与排序
void AdjustDown(ElemType A[], int k, int len)
{
	int dad = k;
	int son = 2 * dad + 1;//左孩子下标
	while (son<=len)
	{
		if (son + 1 <= len && A[son] < A[son + 1])//看看有没有右孩子
		{
			son++;
		}
		if (A[son] > A[dad])
		{
			swap(A[son], A[dad]);
			dad = son;
			son = 2 * dad + 1;
		}
		else {
			break;
		}
	}
}

void HeapSort(ElemType A[], int len)
{
	int i;
	//建立大根堆
	for (i = len / 2; i >= 0; i--)
	{
		AdjustDown(A, 1, len);
	}
	swap(A[0], A[len]);//交换顶部和数组最后一个元素
	for (i = len - 1; i > 0; i--)
	{
		AdjustDown(A, 1, len);//调整剩下元素为大根堆
		swap(A[0], A[i]);
	}
}