数据结构课堂笔记

template<class T>
void SeqList<T>::reSize(int newsize)
{
    if(newSize!=maxSize)
    {
        T *newarray=new T[newSize];
       /*
        开辟大小为newSize的内存空间
        数据类型为T        
        */
       if(newarray==NULL)
       {
        cerr<<"分配存储失败！"<<endl;
        exit(1); 
       }
    }
    int n=last+1;
    T *scrptr=data;
    T *destptr=newarray;
    while(n--) *destptr++=*srcptr++;
    delete []data;
    data=newarray;
    maxSize=newSize; 
}


template<class T>
int SeqList<T>::search(T &x) const
{
    for(int i=0;i<=last;i++)
    {
        if(data[i]==x) return i+1;
    }
}

/*
在第i个位置插入x 
插入前：a1,....,ai-1,ai,...,an
插入后：a1,...,ai-1,x,ai,...,an
ai-1和ai之间的逻辑发生了变化
表满：last>=MaxSize-1
last是最后一个元素数组下标
1<=i<=last+2
插入元素时移动的越少效率越高
移动元素的个数不仅和表长有关而且与插入位置有关 
最好情况(i=n+1)基本语句执行0次，时间复杂度O(1) 
*/

/*
顺序表的实现——删除
每个往前移一位 相当于覆盖掉了
首先要判断删除位置是否合法 
1<=i<=last+1 
*/
template<class T>
bool SeqList<T>::Remove(int i,T &x)
{
    if(last==-1||i<1||i>last+1) return false;
    x=data[i-1];//第i个元素数组下标是i-1
    for(int j=i;j<=last;j++)
    {
        data[j-1]=data[j];//后面覆盖前面 
    }
    last--; //表长-1 
} 


//顺序表的输入算法
template<class T>
void SeqList<T>::input()
{
    cout<<"输入元素个数";
    while(1)
    {
        cin>>last;
        if(last<=maxSize-1) break;
        cout<<"个数输入有误"; 
    }
    for(int i=0;i<=last;i++)
    {
        cin>data[i];
        cout<<i+1<<endl; 
    } 
}
 
//顺序表的输出算法
template<class T>
void SeqList<T>::output()
{
    cout<<"当前元素的最后位置为"<<last<<endl;
    for(int i=0;i<=last;i++)
    {
        cout<<"#"<<i+1<<":"<<data[i]<<endl;
    }
}

//顺序表的应用

//并运算 
void Union(SeqList<int>&A,SeqList<int>& B)
{
    int n=A.length(),x;
    int m=B.length();
    for(int i=1;i<=m;i++)
    {
        B.getData(i,x);//在B中取一个元素 
        int k=A.Search(x);//在A中搜索它 
        if(k==0)     //若未找到插入到A的最后 把并的结果放入A中(若重新开空间则浪费) 
        {A.Insert(n,x);n++;} 
    }
} 

//交运算
void Intersection(SeqList<int>&A,SeqList<int>&B)
{
    int n=A.Length();
    int m=B.Length();int i=1,x;
    while(i<=n)
    {
        A.getData(i,x);
        int k=B.search(x);
        if(k==0) A.Remove(i,x),n--;
        else i++;
    }
} 

//顺序表的优点：
/*
无需为表示表中元素之间的逻辑关系而增加额外的存储空间
随机存取 可以快速地存取表中任一位置的元素
顺序表的缺点：
(1)插入和删除操作需要移动大量元素
(2)表的容量难以确定，表的容量难以扩充
(3)造成存储空间的碎片

链表非常适合频繁地插入或删除、存储空间需求变化很大地情形 
*/ 


/*
单链表是最简单地链表，也叫线性链表，它用指针表示节点间地逻辑关系
Node 存有数据域和指针域
线性结构first为头指针
结点可以连续可以不连续存储  99.99%不连续存储 
节点的逻辑顺序和物理顺序可以不一致
表扩充很方便 
*/ 

/*
顺序表 容量是固定
单链表  不固定  
*/ 

/*
多个类表达一个概念（单链表）
链表节点（ListNode)类 
链表(List)类 
*/ 

// 1.复合类1 
class List;//链表类定义(复合方式)
class LinkNode
{
    friend class List;//链表类为其友元类
    private:
        int data;
        LinkNode *link; 
};
class List
{
    private:
        LinNode *first;
};
//友元类不具有对称性？？
//复合类2：用struct定义linkNode类
struct LinkNode
{
    int data:
    LinkNode *link;
};
class List
{
    private:
        LinkNode *first;
    public:
};
/*
虽然结构使List失去了封装性
但是所有属于LIst对象地LinkNode结点只能用first进行访问。 
*/ 
//2、嵌套类
class List
{
    
}  
 
 //3、继承方式  
class LinkNode
{
     protected:
         int data;
         LinkNode *link;
};
class List
{
    
}
//写不完了  自己去看PPT吧。
数据结构课堂笔记

猜你喜欢
