排序（二）

五、快速排序
//时间复杂度：O（nlogn）
//空间复杂度：O（nlogn）
//稳定性：不稳定

int Partion(int* arr,int low,int high)
{
	int tmp=arr[low];
	while(low<high)
	{
		while(low<high&&arr[high]>tmp)
			high--;
		if(low>=high)
			break;
		else
			arr[low]=arr[high];
		while(low<high&&arr[low]<tmp)
			low++;
		if(low>=high)
			break;
		else
			arr[high]=arr[low];
	}
	arr[low]=tmp;
	return low;
}
void Quick(int* arr,int start,int end)
{
	int par= Partion(arr,start,end);
	if(par>start+1)
	{
		Quick(arr,start,par-1);
	}
	if(par<end-1)
	{
		Quick(arr,par+1,end);
	}
}

六、堆排
//时间复杂度：O(nlogn)
//空间复杂度：O(1)
//稳定性：不稳定

void HeapAdjust(int a[],int i,int n)
{
	if(i>=n)
		return;
	int left=i*2+1;
	int right=i*2+2;
	int min=i;
	if(right<=n&&a[min]>a[right])
	{
		min=right;
	}
	if(left<=n&&a[min]>a[left])
	{
		min=left;
	}
	if(min!=i)
	{
		int tmp=a[i];
		a[i]=a[min];
		a[min]=tmp;
		HeapAdjust(a,min,n);
	}
}
void HeapSort(int a[],int n)
{
	int last_parent=(n-1)/2;
	for(last_parent;last_parent>=0;last_parent--)
	{
		HeapAdjust(a,last_parent,n);
	}
	if(n>0)
	{
		int tmp=a[0];
		a[0]=a[n];
		a[n]=tmp;
		n--;
		HeapSort(a,n);
	}
	else
		return;
}

七、归并排序
//时间复杂度：O(nlogn)
//空间复杂度：O(nlogn)
//稳定性：稳定

void Merge(int arr1[], int arr2[], int start, int mid, int end)
{
	int p = start;
	int ps = start;
	int pm = mid+1;
	while (ps != mid + 1 && pm != end + 1)
	{
		if (arr1[ps] > arr1[pm])
		{
			arr2[p++] = arr1[pm++];
		}
		else
			arr2[p++] = arr1[ps++];
	}
	while (ps != mid + 1)
	{
		arr2[p++] = arr1[ps++];
	}
	while (pm != end + 1)
	{
		arr2[p++] = arr1[pm++];
	}
	for (ps = start; ps <= end; ps++)
		arr1[ps] = arr2[ps];
}
void MergeSort(int arr1[], int arr2[], int start, int end)
{
	if (start < end)
	{
		int mid = start + (end - start) / 2;
		MergeSort(arr1, arr2, start, mid);
		MergeSort(arr1, arr2, mid+1, end);
		Merge(arr1, arr2, start, mid, end);
	}
}

八、基数排序
//时间复杂度：O(d(r+n))
//空间复杂度：O(rd+n)
//稳定性：稳定

typedef struct Node
{
	int data;
	Node* next;
}Node,*List;

void InitList(List &plist)//单链表初始化
{
	plist = (List)malloc(sizeof(Node));
	assert(plist != NULL);
	if (plist == NULL)
	{
		return;
	}
	plist->next = NULL;
}
static Node* GetNode(int val)
{
	Node* pGet = (Node*)malloc(sizeof(Node));
	assert(pGet != NULL);
	pGet->data = val;
	pGet->next = NULL;
	return pGet;
}
bool Insert_tail(List plist, int val)//尾插
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return false;
	}
	Node* pGet = GetNode(val);
	Node* p = plist;
	while (p->next != NULL)
	{
		p = p->next;
	}
	p->next = pGet;
	return true;
}
bool IsEmpty(List plist)//判空
{
	if (plist->next == NULL)
	{
		return true;
	}
	return false;
}
Node* Search_pre(List plist, int key)//查找key的前驱
{
	Node* p = plist;
	for (; p->next != NULL; p = p->next)
	{
		if (p->next->data == key)
		{
			return p;
		}
	}
	return false;
}
bool Delete(List plist, int key)//删除
{
	Node* p = Search_pre(plist, key);
	if (p == NULL)
	{
		return false;
	}
	Node* pDel = p->next;
	p->next = pDel->next;
	free(pDel);
	pDel = NULL;
	return true;
}
int max(int arr[],int n)
{
	int max = 0;
	for (int i = 0; i < n; i++)
	{
		int count = 1;
		int tmp = arr[i];
		while (tmp / 10 > 0)
		{
			tmp /= 10;
			count++;
		}
		if (count > max)
		{
			max = count;
		}
	}
	return max;
}
void baseSort(int arr[], int n)
{
	int x;
	int k = 0;
	int num = 0;
	List L[10];
	for ( x = 0; x < 10; x++)
	{
		InitList(L[x]);
	}
	int maxlen = max(arr, n);
	for (int j = 0; j < maxlen; j++)
	{
		if (j == 0)
			num = 1;
		else
			num *= 10;
		for (int i = 0; i < n; i++)
		{
			int k = (arr[i] / num) % 10;
			Insert_tail(L[k], arr[i]);
		}
		for (int i = 0; i < 10; i++)
		{
			
			while (!IsEmpty(L[i]))
			{
				arr[k++] = L[i]->next->data;
				Delete(L[i], L[i]->next->data);
			}
		}
	}
}