3.0列表

列表的基本实现，含选择排序，插入排序，归并排序（有问题，未解决）

双链表实现归并排序，在测试案例中给出了错误的排序结果。看了好久代码觉得逻辑没错啊，而且代码也是照着书上敲的。头疼......

 

#include<iostream>
using namespace std;
struct ListNode{
    
    int data;
    ListNode *pred;
    ListNode *succ;
    ListNode(){    }//用于header和trailer初始化，如果没有这一句后面的init() 会报错 
    ListNode(int e,ListNode* p=NULL,ListNode *s=NULL):data(e),pred(p),succ(s){} 
};
class List{
    public:
        int size;
        ListNode *header;
        ListNode *trailer; 
        List(){
            header=new ListNode;
            trailer=new ListNode;
            header->succ=trailer;header->pred=NULL;
            trailer->succ=NULL;trailer->pred=header;
            size=0;
            
        }
            
        ListNode* find(int e,int n,ListNode *p){//在p的n个前缀中查找e，并返回指向e的指针 
            while(0<n--)
                if(e==(p=p->pred)->data) 
                return p;
                
            return NULL;
               }
               
        ListNode* insertAsPred(int e,ListNode* p){//e当作p的前缀插入 
            ListNode* x=new ListNode(e,p->pred,p);
            p->pred->succ=x;
            p->pred=x;//顺序不能改变 
            size++;
            return x;
        
        } 
        ListNode* insertAsSucc(int e,ListNode* p){//e作为p的后缀插入 
            ListNode *x=new ListNode(e,p,p->succ);
            p->succ->pred=x;
            p->succ=x;
            size++;
            return x;
        }
        int remove(ListNode* p){
            int e=p->data;
            p->pred->succ=p->succ;
            p->succ->pred=p->pred;
            
            delete p;
            p=NULL;
            size--;
            return e;
        }
        int clear(){
            int n=size;
            int oldsize=size;
            while(n--)//！！！！！！原来这里是size--，改变了size,这里应该是次数控制，不应该改变size! 
            remove(header->succ);//写成size--，析构函数没办法正常运行，返回一个奇怪的数，且运行时间较长 
            return oldsize;//debug技巧要学一些，找半天 ，课本也不是这么写的，果然自己敲容易出bug... 
        }
        ~List()
        {
        
            clear();
            delete header;
            header=NULL;
            delete trailer;
            trailer=NULL;
        }
        int deduplicate(){
            if(size<2)return 0;
            int oldsize=size;
            ListNode *p=header;
            int r=0;
            ListNode *q=NULL;
            while((p=p->succ)!=trailer)
            {q=find(p->data,r,p);
             q?remove(q):r++;
            }
            
            return oldsize-size;
        }
        
        int uniquify(){//有序列表唯一化 
            if(size<2)return 0;
            int oldsize=size;
            ListNode *p=header->succ;
            ListNode *q;
            while(trailer!=(q=p->succ))
            {if(p->data==q->data)
                remove(q);
            else
                p=q;
             } 
             return oldsize-size;
            }
        ListNode* search(int e,int n,ListNode *p){//有序列表查找 
            
            while(0<=n--)//条件为0<n--时出错 
            if(e>=((p=p->pred)->data)) 
              break;//找到不大于e的最大元素 
                  
            return p; 
        } 
        
        void insertionSort(ListNode *p,int n){//对起始于p的后n个元素排序 
            for(int i=0;i<n;i++){
                
                insertAsSucc(p->data,search(p->data,i,p));//找到p的前缀中（p的前缀假设已经排列好）不大于p->data的最大元素，将p作为后缀插入
                                                          // 列表将呈现升序排列
             
               p=p->succ;
               remove(p->pred);
            } 
        }
        
        void selectionSort(ListNode *p,int n){//对起始于p的后n个元素排序
             
            ListNode *temp=NULL,*max=NULL;
            ListNode *header=p->pred,*tail=p;
            for(int i=0;i<n;i++)
              tail=tail->succ;//待排序区间为(header,tail)
            while(n>1){//找到前缀中最大的元素，放到后缀 
               
                temp=max=header->succ;//注意为什么不用p而用header->succ，p随时可能因为是最大元素而被改变位置
                                      //用header->succ可一直间接访问首元素 
                for(int i=1;i<n;i++)//找到起始于位置p的后n个元素的最大元素的位置 
                {
                    temp=temp->succ;
                    if((temp->data)>=(max->data))
                    max=temp;    }
                    
                insertAsPred(remove(max),tail);
                tail=tail->pred;//更新无序向量末元素 
                n--; 
            }
        } 
        /*void mergeSort(ListNode* &p,int n){//对起始于p的后n个元素排序
            
            if(n<2)return;
            int m=n>>1;
            ListNode *q=p;
            for(int i=0;i<m;i++) q=q->succ;
            mergeSort(p,m);
            mergeSort(q,n-m);
            merge(p,m,q,n-m);
            
             }
        void merge(ListNode *&p,int n,ListNode *q,int m){
            ListNode *pp=p->pred;
            while(m>0)
             if((n>0)&&(p->data<=q->data))
               { if(q==(p=p->succ))//为什么这个判断条件是必要的 
                                         // if((p=p->succ)&&n==1)
                  break;//当p的最后一元素比较完毕，即可退出循环，因为已经归并完毕 
                  n--;
               }
            else//当p->data大于q->data 
             {
             insertAsPred(remove((q=q->succ)->pred),p) ;//事实上当p没有元素时已经退出循环 
               m--;
             } 
             p=pp->succ;
             
        }*/
        void print(){
            ListNode *p=NULL;
            p=header->succ;
            
            while(trailer!=p)
            {   
                cout<<p->data<<" ";
                p=p->succ;
            }
            cout<<endl<<"size:"<<size<<endl<<endl;
        
            
        }
};

int main(){
    List data;
    ListNode *p=data.header;
    int test[16]={9,9,25,3,71,45,62,71,20,21,25,86,55,125,1,21};
   for(int i=0;i<16;i++)
        {
        data.insertAsSucc(test[i],p); 
         p=p->succ;}
         
    data.print();
    
    p=data.header;
    
    //测试选择排序 ,通过 
    //data.selectionSort(p->succ,data.size);
    //测试插入排序，通过 
    data.insertionSort(p->succ,data.size);
    //测试归并排序，有问题 
   //data.mergeSort(p->succ,data.size);
    data.print();
    
    data.deduplicate();
    data.print();
    
    
    return 0;
}