排序算法

排序算法

在排序算法前，先写一个交换函数

 template <typename T>
    static void Swap(T& t1,T& t2 )
    {
        T temp = t1;
        t1 = t2;
        t2 = temp;
    }

1.插入法排序

插入排序算法的精髓在于，在一个已知的序列里面插入一个对象（数），插入时，这个对象需要与有序的这个序列里面的每一个数进行对比，条件满足后进行交换。

我写了三种，但是不知道是那一种会更好些，只是记住自己喜欢的就好，只是一种方法而已，不会太过于纠结。
以下算法是用第i个数与前面的序列进行对比，对比从第0位开始，j的条件直到i结束。

 template <typename T>
		static void Insert5(T* m_array,int len,bool min2max = true)
		{
			for(int i = 1;i < len ; i++)
			{
				int k = i;
				T temp = m_array[i];
				
				for(int j = i - 1 ; (j >= 0) && (min2max?(m_array[j] > temp) : (m_array[j] < temp));j--)
				{
					m_array[j+1] = m_array[j];
					k = j;
				}
				
				if(k != i)
				{
					m_array[k] = temp;
				}
			}
		}

下面说说我的第二种想法，就是从有序序列的的第i-1位进行对比，也就是从序列的后面，向前面进行对比。但是呢，我发现了一个问题，那就是其实这个算法的第一重循环是插入排序法，第二重循环就变成冒泡的方法了。罪过！在这里提前说清楚，不能误认子弟，害人害己！

   template <typename T>
    static void Insert2(T array[],int len,bool min2max = true)
    {
        for(int i = 1; i < len ; i++)
        {
            for(int j = i;(j>0) && (min2max?(array[j]>array[j-1]):(array[j] < array[j-1]));j--)
            {
                Swap(array[j],array[j-1]);
            }
        }
    }

第三种排序的方法,与第二种是一样的，换汤不换药的玩意儿，咋说你呢。

//插入排序算法
    template <typename T>
    static void Insert(T array[],int len,bool min2max = true)
    {
        for(int i = 1; i < len;i++)
        {
            for(int j = i; j >0  ; j--)
            {
                if(min2max ? (array[j] > array[j-1]) : (array[j] < array[j-1]))
                {
                    Swap(array[j],array[j-1]);
                }
            }
        }
    }

好了，以上都是插入排序方法。

2.选择法排序

这个算法的精髓在于记住下标
先上代码

    //选择排序重新实现(其实是记录下标的方法来实现的)
    template <typename T>
    static void Select(T array[],int len,bool min2max = true)
    {
        for(int i = 0; i < len ; i++)
        {
            int min = i;
            for(int j = i+1; j < len ;j++)
            {
                if(min2max ? (array[min] > array[j]) : (array[min] < array[j]))
                {
                    min = j;
                }
            }

            if(min != i)
            {
                Swap(array[i],array[min]);
            }
        }
    }

不得不说，这个算法是查一遍找到最小（或最大）的数，然后再查一遍，再找到最小（或最大）的数，一直查到最后一个数为止。当查第i遍的时候，也array[i]进行位置交换，把这个数字放到最前面。

int main()
{
    int array[7] = {10,3,5,1,8,0,4};
    Sort::Insert3(array,7,true);

    for(int i = 0;i < 7; i++)
    {
        cout << array[i] << endl;
    }
    return 0;
}

2.选择法排序

这个算法真心没有什么好说的，像泡泡一样，一直流到顶部

		//冒泡排序算法
		template <typename T>
		static void Bubble(T m_array[],int len,bool min2max = true)
		{
			bool exchange = true;
			for(int i = 0;(i < len) && exchange;i++)
			{
				exchange = false;
				for(int j = len-1 ;j > i;j--)
				{
					if(min2max?(m_array[j] > m_array[j-1]):(m_array[j] < m_array[j-1]))
					{
						Swap(m_array[j],m_array[j-1]);
						exchange = true;
					}
				}
			}
		}