常用的基本函數的實現

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdarg.h>
#include<ctime>
#include<cstring>
#include<cmath>
#include<vector>
#include<iostream>
#include<iomanip>
using namespace std;

//std::swap(a, b);
template <typename T>
void Swap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}



template <typename T>
void PrintData(T arr[], const int& len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

void GetRandomData(short arr[], int& len);
void GetRandomData(double arr[], int& len);
void GetRandomData(float arr[], int& len);
void GetRandomData(int arr[], int& len);

long long Sum(short numofindex, ...);
long long Sum(short arr[], int& len);
long long Sum(int arr[], int& len);

double Average(short numofindex, ...);
double Average(short arr[], int& len);

int Min(int arr[], int& len);
double Min(double arr[], int& len);
int Max(int arr[], int& len);

//階乘
long factorial(int n);

size_t bits(int integer);

void weed(char* str, char ch, char* dest);

double change(char* str);

void reverse(char* src,char* dest);

void space(char* src, char* dest);

void BubbleSortAscending(vector<int>& arr);
void BubbleSortAscending(vector<short>& arr);
//Ascending 升序
//Descending 降序


void GetRandomData(int arr[], int& len)
{
	srand(time(NULL));

	for (int i = 0; i < len; i++)
	{
		arr[i] = rand();
	}
}
void GetRandomData(short arr[], int& len)
{
	srand(time(NULL));

	for (int i = 0; i < len; i++)
	{
		arr[i] = rand();
	}
}

void PrintData(int arr[], const int& len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}



void GetRandomData(float arr[], int& len)
{
	srand(time(NULL));
	for (int i = 0; i < len; i++)
	{
	randNum:
		if (rand() > 100)
		{
			arr[i] = (float)rand() / 10.0;
		}
		else
			goto randNum;

	}
}
void GetRandomData(double arr[], int& len)
{
	srand(time(NULL));
	for (int i = 0; i < len; i++)
	{
	randNum:
		if (rand() > 100)
		{
			arr[i] = (double)rand() / 100.0;
		}
		else
			goto randNum;

	}
}


long long Sum(short numofindex, ...)
{
	long long sum = 0;
	va_list pArgs = NULL;
	va_start(pArgs, numofindex);
	for (int i = 0; i < numofindex; i++)
	{
		sum += va_arg(pArgs, short);
	}
	va_end(pArgs);

	return sum;
}


long long Sum(short arr[], int& len)
{
	long long sum = 0;
	for (int i = 0; i < len; i++)
	{
		sum += arr[i];
	}
	return sum;
}

long long Sum(int arr[], int& len)
{
	long long sum = 0;
	for (int i = 0; i < len; i++)
	{
		sum += arr[i];
	}
	return sum;
}

double Average(short numofindex, ...)
{
	long long sum = 0;
	va_list pArgs = NULL;
	va_start(pArgs, numofindex);
	for (int i = 0; i < numofindex; i++)
	{
		sum += va_arg(pArgs, short);
	}
	va_end(pArgs);
	return (double)sum / numofindex;
}

double Average(short arr[], int& len)
{
	long long sum = 0;
	for (int i = 0; i < len; i++)
	{
		sum += arr[i];
	}
	return (double)sum / len;
}

int Min(int arr[], int& len)
{
	int min = 0;
	for (int i = 0; i < len; i++)
	{
		if (arr[i] < min)
			min = arr[i];
	}
	return min;
}

double Min(double arr[], int& len)
{
	double min = 0;
	for (int i = 0; i < len; i++)
	{
		if (arr[i] < min)
			min = arr[i];
	}
	return min;
}

int Max(int arr[], int& len)
{
	int max = 0;
	for (int i = 0; i < len; i++)
	{
		if (arr[i] > max)
			max = arr[i];
	}
	return max;
}

double Max(double arr[], int& len)
{
	double max = 0;
	for (int i = 0; i < len; i++)
	{
		if (arr[i] > max)
			max = arr[i];
	}
	return max;
}

long factorial(int n)
{
	int r = 1;
	if (n == 0)
		r = 0;
	if (n > 0)
	{
		for (int i = n; i > 0; i--)
		{
			r *= i;
		}

	}
	return r;
}

size_t bits(int integer)
{
	size_t bit = 1;	//整數最少有1位


	while (integer /= 10)	//除10不爲0
	{
		++bit;
	}

	return bit;
}

void weed(char* str, char ch, char* dest)
{
	size_t len = strlen(str);
	bool flag = false;
	for (int i = 0; i < len; i++)
	{
		if (str[i] == ch)
		{
			flag = true;
			continue;
		}
		if (flag == true)
		{
			dest[i - 1] = str[i];
		}
		else
			dest[i] = str[i];
	}
	dest[len - 1] = '\0';
}

double change(char* str)
{
	//ASCII 0(char) 對應 48
	//1.有沒有小數點,小數點的位置在哪裏
	//如果有小數點,那麼有且只有一個
	//2.如果沒有小數點就直接組成整數
	//3.如果有小數點就分兩部分組成整數
	//3.1.去除小數點,計算整個數的值a
	//3.2.整數部分=a/pow(10.0,dot)
	//3.3.小數部分=a%pow(10.0,dot)
	//3.4.result=(double)a/pow(10.0,dot)
	//方案二:
	//3.1.str[0]~~str[dot-1]爲整數部分,轉換爲整數integer
	//3.2.str[dot]~~str[slen-1]爲小數部分,轉換成小數decimal
	//3.3.result=interger+decimal/(pow(10.0,bits(decimal)))

	double result = 0.0f;
	int slen = strlen(str);
	int dot = 0;
	double integer = 0;


	for (int i = 0; i < slen; i++)
	{
		++dot;
		if (str[i] == '.')
			break;
		if (dot == slen)
		{
			dot = 0;	//沒有小數點
			break;
		}
	}


	if (dot == 0)
	{
		for (int i = 0, j = slen - 1; i < slen; i++, j--)
		{
			result += (str[i] - 48) * pow(10.0, j);
		}

	}
	else
	{
		//第一種方案
		char* integerstr = (char*)malloc(sizeof(char) * slen);
		memset(integerstr, 0, slen);

		weed(str, '.', integerstr);

		for (int i = 0, j = slen - 2; i < slen - 1; i++, j--)
		{
			integer += (integerstr[i] - 48) * pow(10.0, j);
		}

		if (integerstr == NULL)
			free(integerstr);

		result = (double)integer / pow(10.0, slen - dot);
		//第二種方案

	}


	return (double)result;
}

void reverse(char* src, char* dest)
{
	size_t len = strlen(src);
	for (int i = 0, j = len - 1; i < len; i++, j--)
	{
		dest[i] = src[j];
	}
	dest[len] = '\0';
}

void space(char* src, char* dest)
{
	size_t len = strlen(src);
	bool flag = false;
	for (int i = 0, j = 0; i < len * 2 - 1; i++)
	{
		if (flag == false)
		{
			dest[i] = src[j];
			flag = true;
		}
		else
		{
			dest[i] = ' ';
			j++;
			flag = false;
		}

	}
	dest[len * 2 - 1] = '\0';
}


/****************************************************/
template<typename T>
void BubbleSortAscending(T src[], int& len)
{
	for (int i = len - 1; i > 0; i--)
	{
		for (int j = 0; j < i; j++)
		{
			if (src[j] > src[j + 1])
			{
				Swap<T>(src[j], src[j + 1]);
			}
		}
	}
}


template<typename T>
void BubbleSortDescending(T src[], int& len)
{
	for (int i = len - 1; i > 0; i--)
	{
		for (int j = 0; j < i; j++)
		{
			if (src[j] < src[j + 1])
			{
				Swap<T>(src[j], src[j + 1]);
			}
		}
	}
}

template<typename T>
void bubbleSortCend(T src[], int& len)
{
	for (int i = 0; i < len; i++)
	{
		for (int j = len - 1; j > i; j--)
		{
			if (src[i] < src[j])
				Swap<T>(src[i], src[j]);
		}
	}
}



template<typename A>
void BubbleSortAscending(vector<A>& arr)
{
	A tmp = 0;
	for (int j = arr.size(); j > 0; j--)
	{
		for (int i = 0; i < arr.size() - 1; i++)
		{
			if (arr.at(i) > arr.at(i + 1))
			{
				//cout << arr.at(i) << " " << arr.at(i + 1) << endl;
				arr[i] = arr[i + 1];
				arr[i + 1] = tmp;
			}
		}
	}
}

/****************************************************/