Algorithm: 插入排序

2019独角兽企业重金招聘Python工程师标准>>>

#include <iostream>
#include <type_traits>
#include <stdexcept>
#include <memory>
#include <new>

template<typename T, typename Ty =
                     typename std::enable_if<std::is_integral<T>::value, void>::type>
class Container{
	private:
		
		class Deleter{
			public:
				Deleter()=default;
				~Deleter()=default;
				
				template<typename Type, typename =
				                        typename std::enable_if<std::is_pointer<Type>::value, void>::type>
				void operator()(Type pointer)
				{
					if(pointer != nullptr){
						delete[] pointer;
					}
				}
		};
		
		template<typename Type>
		void initializer(T* ptr, Type&& value);
		
		template<typename Type, typename ...Types>
		void initializer(T* ptr, Type&& value, Types&&... values);
		
		std::unique_ptr<T[], Deleter> array_; 
		unsigned int number;
		
		public:
			template<typename ...Args>
			Container(Args&&... parameters);
			
			Container():array_(nullptr){}
			
			template<unsigned int N>
			Container(T (&array)[N]);
			
			void sort();
			
			void print()const;
			
			~Container()=default;
};


template<typename T, typename Ty>
template<unsigned int N>
Container<T, Ty>::Container(T (&array)[N])try
                 :array_(std::unique_ptr<T[], Deleter>(nullptr, Deleter())),
                  number(N)
{
	if(N == 0){
		throw std::string("Must be something in the array!");
	}
	
	this->array_=std::unique_ptr<T[], Deleter>(new T[N], Deleter());
	
	std::uninitialized_copy_n(array, N, (this->array_).get());
	
}catch(const std::string& error){
	std::cout<< error <<std::endl;
}

template<typename T, typename Ty>
template<typename ...Args>
Container<T, Ty>::Container(Args&&... parameters)
                 :array_(std::unique_ptr<T[], Deleter>(new T[sizeof...(Args)], Deleter())),
                  number(sizeof...(Args))
{
	this->initializer((this->array_).get(), std::forward<Args>(parameters)...);
}


template<typename T, typename Ty>
template<typename Type, typename ...Types>
void Container<T, Ty>::initializer(T* ptr, Type&& value, Types&&... values)
{
	this->initializer(ptr++, value);
	this->initializer(ptr, std::forward<Types>(values)...);
}

template<typename T, typename Ty>
template<typename Type>
void Container<T, Ty>::initializer(T* ptr, Type&& value)
{
	if(ptr == nullptr){
		return;
	}
	
	new(ptr) T(value);
}

template<typename T, typename Ty>
void Container<T, Ty>::sort()
{
	T value;
	int i=0;
	
	for(int index = 1; index<this->number; ++index){
		value = (this->array_)[index];  //从数组中的第二个元素开始. 

		
		i = index-1;      //从第一个下标开始. 
		
		while(i >=0 && (this->array_)[i] > value){  //如果i>0, 且前一个元素大于后一个元素. 
			(this->array_)[i+1] = (this->array_)[i];  //把前一个元素的值赋值给后一个元素. 
			--i;
		}
		
		(this->array_)[i+1] = value; 
	}
	
}

template<typename T, typename Ty>
void Container<T, Ty>::print()const
{
	std::cout<< this->number <<std::endl;
	for(int index=0; index<this->number; ++index){
		std::cout<< (this->array_)[index] <<std::endl;
	}
}

int main()
{
	Container<int> container{5, 2, 4, 6, 1, 3};
	
	container.sort();
	container.print();
	
	return 0;
}

 

转载于:https://my.oschina.net/SHIHUAMarryMe/blog/600427