链表+排序

template <typename Type>


class Node{
        
    

private:
    Node(Type &dataValue):data(dataValue),next(nullptr){}
    Node(){}

    Type data;
        Node* next;
}

class MyList{
    MyList();
    ~MyList();

    void insertFront(Type &data);        //在首位置插入元素
    void remove(int index);                //删掉第几个元素
    void remove(Type &data);               //删掉所有值是data的元素
    void insert(const Type&data,int index);         //在第几个位置前插入元素

    bool isEmpty();
    
    void sort();                         //有多种排序，比如冒泡 选择 插入 快速
    void concatenate(MyList<Type>& myList );
    
private:
    Node<Type>* first;
};
MyList(){
    first=new Node<Type>();
    first->next=nullptr;
    }
~MyList(){
    while(first){                           //从第一个元素逐个往后删
        Node<Type>* deleteNode=first;
        first=first->next;
        delete deleteNode;
    }

}

void insertFront(Type &data){
    Node<Type>* newNode=new Node<>(data);
    newNode->next=first->next;
    first->next=newNode;
    
}
void remove(int index){
    if(isEmpty())
        return;
    int i=0;
    removeNode=first;
    while(i!=index-1){
        removeNode=removeNode->next;
        i++;
    }
    delete removeNode;
}
void remove(Type &data){
    if(isEmpty())
        return;
    deleteNode=first;
    while(deleteNode->data!=data){
        deleteNode=deleteNode->next;
    
    }
    delete deleteNode;

    
    
}
void insert(const Type&data,int index){


}

bool isEmpty();
    //冒泡
template <typename Type>  
void bubbleSort(Type *begin, Type *end)  
{  
    if ((begin == end) || (begin == NULL) || (end == NULL))  
        return ;  
 
    int length = end - begin;  
    //注意点(1):保证一旦数组有序, 则会直接停止排序, 不会在继续进行无用的循环  
    bool isOrder = false;  
 
    //外层循环控制扫描次数(length-1)  
    //注意点(2):N个元素其实只需N-1次扫描  
    for (int i = 0; !isOrder && i < length-1; ++i)  
    {  
        //首先假定这次数组已经有序  
        isOrder = true;  
        //注意点(3):确保能够从0扫描到最后一个未排序的元素  
        for (Type *iter = begin; iter < end-i-1; ++iter)  
        {  
            //如果前面的左边的元素>右边的元素  
            if ((Type *)*iter->data > (Type*)*(iter+1)->data)  
            {  
                //交换  
                std::swap(*iter, *(iter+1));  
                isOrder = false;  
            }  
        }  
    }  
}  
//选择排序， 选择一个比要比较的那个小的，交换
template <typename Type>  
void selectSort(Type *begin, Type *end)  
{  
    if ((begin == end) || (begin == NULL) || (end == NULL))  
        return ;  
 
    //只要循环到最后一个元素的前一个就行了,因为剩下的那个肯定是最大的  
    for (Type *outer = begin; outer < end-1; ++outer)  
    {  
        //注意:是从尚未排序的序列中查找(miner = outer, inner = outer+1)  
        Type *miner = outer;  
        //从miner+1开始遍历数组, 寻找一个元素值小于*miner的  
        for (Type *inner = outer+1; inner < end; ++inner)  
        {  
            if (*inner < *miner)  
                miner = inner;  
        }  
 
        if (miner != outer)  
            std::swap(*miner, *outer);  
    }  
}  

//实现:迭代二分  
template <typename Type>  
Type *binarySearch(Type *begin, Type *end, const Type &searchValue)  
throw(std::range_error)  
{  
    if ((begin == end) || (begin == NULL) || (end == NULL))  
        throw std::range_error("pointer unavailable");  
    Type *low = begin, *high = end-1;  
    while (low <= high)  
    {  
        //计算中间元素  
        Type *mid = low + (high-low)/2;  
        //如果中间元素的值==要找的数值, 则直接返回  
        if (*mid == searchValue)  
            return mid;  
        //如果要找的数比中间元素大, 则在数组的后半部分查找  
        else if (searchValue > *mid)  
            low = mid + 1;  
        //如果要找的数比中间元素小, 则在数组的前半部分查找  
        else  
            high = mid - 1;  
    }  
 
    return end;  
}
template <typename Type>  
Type *binarySearch(Type *array, int length, const Type &searchValue)  
throw(std::range_error)  
{  
    return binarySearch(array, array+length, searchValue);  
}