code练习

#include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
#include <algorithm>

// 每轮找到最大的放在后面
void BubbleSort(int *numArray, int numLen)
{
	int tmp = 0;
	for (int i = 0; i < numLen; ++i)
	{
		for (int j = 0; j < numLen - i - 1; ++j)
		{
			if (numArray[j] > numArray[j + 1])
			{
				tmp = numArray[j];
				numArray[j] = numArray[j + 1];
				numArray[j + 1] = tmp;
			}
		}
	}
}

// 每轮找到最小的房前前面
void SelectSort(int *array, int len)
{
	int minIndex = 0;
	int tmp = 0;
	for (int i = 0; i < len; ++i)
	{
		minIndex = i;
		for (int j = i; j < len; ++j)
		{
			if (array[j] < array[minIndex])
			{
				minIndex = j;
			}
		}
		tmp = array[i];
		array[i] = array[minIndex];
		array[minIndex] = tmp;
	}
}

// 1个数字即为有序，后面小了就向后移动，cur插入
void InsertSort(int *array, int len)
{
	int preIndex, curData;
	for (int i = 1; i < len; ++i)
	{
		preIndex = i - 1;
		curData = array[i];
		while (preIndex >= 0 && array[preIndex] > curData)
		{
			array[preIndex + 1] = array[preIndex];
			--preIndex;
		}
		array[preIndex + 1] = curData;
	}
}

// 相隔gap的两个数做比较，前面的大就交换
void ShellSort(int *array, int len)
{
	for (int gap = len >> 1; gap > 0; gap >>= 1)
	{
		for (int i = gap; i < len; i++)
		{
			int curData = array[i];
			int j = i;
			for (; j >= gap && curData < array[j - gap]; j -= gap)
			{
				array[j] = array[j - gap];
			}
			array[j] = curData;
		}
	}
}

void merge(int *array, int start, int mid, int end)
{
	int *tmp = (int *)malloc((end - start + 1) * sizeof(int));
	int i = start;
	int j = mid + 1;
	int k = 0;
	while (i <= mid && j <= end)
	{
		if (array[i] <= array[i])
		{
			tmp[k++] = array[i++];
		}
		else
		{
			tmp[k++] = array[j++];
		}
	}
	while (i <= mid)
	{
		tmp[k++] = array[i++];
	}
	while (j <= end)
	{
		tmp[k++] = array[j++];
	}
	for (i = 0; i < k; i++)
	{
		array[start + i] = tmp[i];
	}
	free(tmp);
}

void MergeSort(int *array, int start, int end)
{
	if (array == NULL || start >= end)
	{
		return;
	}
	int mid = end - start + 1;
	MergeSort(array, start, mid);
	MergeSort(array, mid + 1, end);
	merge(array, start, mid, end);
}

void QuickSort(int *array, int low, int high)
{
	int i = low;
	int j = high;
	if (i >= j)
		return;
	int tmp = array[low];
	while (i != j)
	{
		while (array[j] >= tmp && i < j)
		{
			--j;
		}
		while (array[i] <= tmp && i < j)
		{
			++i;
		}
		if (i < j)
		{
			std::swap(array[i], array[j]);
		}
	}
	std::swap(array[low], array[i]);
	QuickSort(array, low, i - 1);
	QuickSort(array, i + 1, high);
}

int printSort(int *array, int len, void (*pFunc)(int *, int))
{
	pFunc(array, len);
	for (int i = 0; i < len; ++i)
	{
		std::cout << array[i] << " ";
	}
	std::cout << std::endl;
	return 0;
}

int printQuickSort(int *array, int low, int high, void (*pFunc)(int *, int, int))
{
	pFunc(array, low, high);
	for (int i = 0; i <= high; ++i)
	{
		std::cout << array[i] << " ";
	}
	std::cout << std::endl;
	return 0;
}

struct Node
{
	int value;
	struct Node *next;
	Node(int val) : value(val), next(NULL){};
};

struct Node *crateNoteList(int *array, int num)
{
	// 鍒涘缓澶磋妭鐐�
	struct Node *head = (struct Node *)malloc(sizeof(struct Node));
	if (head == NULL)
		return NULL;
	struct Node *p = head;
	for (int i = 0; i < num; ++i)
	{
		struct Node *tmp = (struct Node *)malloc(sizeof(struct Node));
		tmp->value = array[i];
		// 閾炬帴
		p->next = tmp;
		// 鎸囬拡鍚庣Щ
		p = p->next;
	}
	p->next = NULL;
	return head;
}

bool deleteNode(struct Node *head, int value)
{
	if (head == NULL)
		return false;
	struct Node *p;
	for (p = head; p->next; p = p->next)
	{
		if (p->next->value == value)
			break;
	}
	if (p->next == NULL)
		return false;
	struct Node *tmp = p->next;
	p->next = tmp->next;
	free(tmp);
}

struct Node *removeElements(struct Node *head, int s)
{
	while (head != NULL && head->value == s)
	{
		struct Node *tmp = head;
		head = head->next;
		free(tmp);
	}
	struct Node *cur = head;
	while (cur != NULL && cur->next != NULL)
	{
		if (cur->next->value == s)
		{
			struct Node *tmp = cur->next;
			head = cur->next->next;
			free(tmp);
		}
		else
		{
			cur = cur->next;
		}
	}
	return head;
}

struct Node *reverseList(struct Node *head)
{
	struct Node *tmp;
	struct Node *cur = head;
	struct Node *pre = NULL;
	while (cur)
	{
		tmp = cur->next; // 涓存椂淇濆瓨
		cur->next = pre; // 鍙嶈浆

		pre = cur;
		cur = tmp;
	}
	return pre;
}


// 二分查找
int binarySearch(int *array, int len, int targrt)
{
	int left = 0;
	int right = len - 1;
	int mid = left + (left + right) >> 2;
	while (left <= right)
	{
		mid = left + (left + right) >> 2;
		if (targrt > array[mid])
		{
			left = mid + 1;
		}
		else if (targrt < array[mid])
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

// 删除元素
int deleteElement(int *array, int len, int val)
{
	int slowIndex = 0;
	for (int fastIndex = 0; fastIndex < len; fastIndex++)
	{
		if (val != array[fastIndex])
		{
			array[slowIndex++] = array[fastIndex];
		}
	}
	return slowIndex;
}

// 平方数排序
int *sortSquares(int *array, int len)
{
	int index = len - 1;
	int *result = (int *)malloc(sizeof(int) * 10);
	for (int i = 0, j = len - 1; i <= j;)
	{
		if (array[i] * array[i] < array[j] * array[j])
		{
			result[index--] = array[j] * array[j];
			j--;
		}
		else
		{
			result[index--] = array[i] * array[i];
			i++;
		}
	}
	return result;
}

int minSubArrayLen(int *array, int len, int s)
{
	int res = INT32_MAX;
	int sum = 0;
	int subLen = 0;
	int j = 0;
	for (int i = 0; i < len; i++)
	{
		sum += array[i];
		while (sum >= s)
		{
			subLen = j - i + 1;
			res = res < subLen ? res : subLen;
			sum -= array[j++];
		}
	}
	return res == INT32_MAX ? 0 : res;
}

// 链表翻转
struct Node *reverseList(struct Node *head)
{
	struct Node *tmp;
	struct Node *cur = head;
	struct Node *pre = NULL;
	while (cur)
	{
		tmp = cur->next;
		cur->next = pre;
		pre = cur;
		cur = tmp;
	}
}