C语言：单链表的递归逆置和插入排序

1.递归逆置

ListNode* RevList(ListNode* pre, ListNode* p)
{
	ListNode* tail = nullptr;
	if (p != nullptr)
	{
		tail = RevList(p, p->next);
		p->next = pre;
	}
	else
	{
		tail = pre;
	}
	return tail;
}
void ListResver(LinkList* plist)//单链表的逆置（不带头结点）
{
	assert(plist != nullptr);
	plist->head->next = RevList(nullptr, plist->head->next);
}

2.插入排序

void InsertSort(int* ar, int n)//插入排序
{
	assert(ar != nullptr);
	for (int i = 1; i < n; ++i)
	{
		if (ar[i] < ar[i - 1])
		{
			int tmp = ar[i];
			int j = i - 1;
			do
			{
				ar[j + 1] = ar[j];
				--j;
			} while (j >= 0 && ar[j] > tmp);
			ar[j + 1] = tmp;
		}
	}
}

3.数组的划分排序

int Parition(int* ar, int left, int right)//划分函数
{
	int tmp = ar[left];
	while (left < right)
	{
		while (left < right && ar[right] > tmp) --right;
		if (left < right) ar[left] = ar[right];
		while (left < right && ar[left] <= tmp) ++left;
		if (left < right) ar[right] = ar[left];
	}
	ar[left] = tmp;
	return left;//返回下标
}
void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int Parition(int* ar, int left, int right)//数组的划分排序
{
	assert(ar != nullptr);
	int i = left;
	int j = i - 1;
	int tmp = ar[i];
	while (i <= right)
	{
		if (ar[i] <= tmp)
		{
			j = j + 1;
			Swap(ar[i], ar[j]);
		}
		++i;
	}
	Swap(ar[left], ar[i]);
	return i;
}

4.链表的划分

ListNode* Parition(ListNode* left, ListNode* right)
{
	ListNode* i = left->next;
	ListNode* j = left;
	int tmp = i->data;
	while (i != right)
	{
		if (i->data <= tmp)
		{
			j = j->next;

		}
		i = i->next;
	}
}

//简单的动态字符串
#include<stdio.h>
#include<stdlib.h>//malloc calloc
#include<string.h>//函数库 strcpy strcmp strlen memset memcpy

void* calloc(size_t count, size_t size)
{
	void* p = malloc(count * size);
	if (nullptr != p)
	{
		memset(p, 0, count * size);
	}
	return p;
}

int main()
{
	int* p = nullptr;
	int n = 0;
	scanf_s("%d", &n);
	p = (int*)malloc(sizeof(int)*n);
	free(p);
	p = (int*)calloc(n, sizeof(int));
}