数据结构--------课后题

最新推荐文章于 2022-05-15 21:59:26 发布
最新推荐文章于 2022-05-15 21:59:26 发布
阅读量4.1k 收藏 96
点赞数 18
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cure_myself/article/details/116117215
版权

线性表 P66

3.算法设计

（1）已知顺序表L中的元素递增有序排列，设计算法将元素x插入到表L中并保持表L仍递增有序。


#include <iostream>
const int max_length=100;
using namespace std;
template <typename T>
class SeqList{
public:
    SeqList();
    SeqList(T a[],int l);
    void XInsert(T a);
private:
    T data[max_length];
    int length;
};
template<typename T>
SeqList<T>::SeqList(){
    length=0;
}
template<typename T>
SeqList<T>::SeqList(T a[],int l){
    if(l>max_length) throw "overflow!!!";
    for(int i=0;i<l;i++)
        data[i]=a[i];
    length=l;
}
template<typename T>
void SeqList<T>::XInsert(T a){
    if(length==max_length) throw "overflow!!!";
    int t=-1;
    for(int i=0;i<length;i++)
        if(data[i]>=a) {t=i;break;}
    if(t==-1) t=length;
    for(int i=length;i>=t;i--)
        data[i]=data[i-1];
    data[t]=a;
    length+=1;
    cout<<"------------------"<<endl;
    for(int i=0;i<length;i++)
        cout<<data[i]<<endl;

}
int main()
{
    int x[5]={1,2,4,5,7};
    SeqList<int> a(x,5);
    a.XInsert(0);
    a.XInsert(3);
    a.XInsert(8);
    a.XInsert(6);

}

（2）在顺序表中删除所有元素值为x的元素，要求空间复杂度为O(1)。

#include <iostream>
const int max_length=100;
using namespace std;
template <typename T>
class SeqList{
public:
    SeqList();
    SeqList(T a[],int l);
    void DeleteAll(T x);
private:
    T data[max_length];
    int length;
};
template<typename T>
SeqList<T>::SeqList(){
    length=0;
}
template<typename T>
SeqList<T>::SeqList(T a[],int l){
    if(l>max_length) throw "overflow!!!";
    for(int i=0;i<l;i++)
        data[i]=a[i];
    length=l;
}
template<typename T>
void SeqList<T>::DeleteAll(T x){
    for(int i=0;i<length;i++){
        if(data[i]!=x) continue;
        for(int j=i;j<length-1;j++)
            data[j]=data[j+1];
        length--;
        i--;
    }
    if(length==0) throw "overflow!!!";
    for(int i=0;i<length;i++)
        cout<<data[i]<<endl;
}
int main()
{
    int x[5]={1,1,3,2,2};
    SeqList<int> a(x,5);
    a.DeleteAll(1);
    a.DeleteAll(2);
    a.DeleteAll(3);
}

（3）分别以顺序表和单链表作存储结构，各编写一个实现线性表就地逆置的算法

1.顺序表
#include <iostream>
const int max_length=100;
using namespace std;
template <typename T>
class SeqList{
public:
    SeqList();
    SeqList(T a[],int l);
    void ReverseList();
private:
    T data[max_length];
    int length;
};
template<typename T>
SeqList<T>::SeqList(){
    length=0;
}
template<typename T>
SeqList<T>::SeqList(T a[],int l){
    if(l>max_length) throw "overflow!!!";
    for(int i=0;i<l;i++)
        data[i]=a[i];
    length=l;
}
template<typename T>
void SeqList<T>::ReverseList(){
    T t;
    for(int i=0;i<length/2;i++){
        t=data[i];
        data[i]=data[length-i-1];
        data[length-i-1]=t;
    }
    for(int i=0;i<length;i++)
        cout<<data[i]<<endl;
}
int main()
{
    int x[6]={1,2,3,4,5,6};
    SeqList<int> a(x,6);
    a.ReverseList();
}
2.单链表（呕心沥血，太难了）
#include <iostream>
using namespace std;
template <typename T>
class Node{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkList{
public:
    LinkList();
    LinkList(T a[],int l,int flag);//flag==0时，头插法；flag==1时，尾插法
    void ReverseList();
    void PrintList();
private:
    Node<T> *first;
};
template<typename T>
LinkList<T>::LinkList(){
    first=new Node<T>;
    first->next=nullptr;
}
template<typename T>
LinkList<T>::LinkList(T a[],int l,int flag){
    if(flag==0){
    first=new Node<T>;
    first->next=nullptr;
    for(int i=0;i<l;i++)
    {
        Node<T> *p=new Node<T>;
        p->data=a[i];
        p->next=first->next;
        first->next=p;
    }
    }
    else {
    first=new Node<T>;
    Node<T> *r=first,*p=nullptr;
    for(int i=0;i<l;i++)
     {
        p=new Node<T>;
        p->data=a[i];
        r->next=p;
        r=p;
    }
    r->next=nullptr;
    }
}
template<typename T>
void LinkList<T>::PrintList(){
    Node<T> *p=first->next;
    while(p){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}
template<typename T>
void LinkList<T>::ReverseList(){
    Node<T> *newF=first->next;
    first->next=nullptr;
    while(newF){
        Node<T> *p=new Node<T>;
        Node<T> *q=newF;
        p->data=newF->data;
        p->next=first->next;
        first->next=p;
        newF=newF->next;
        delete q;
    }

}
int main()
{
    int x[5]={1,2,3,4,5};
    LinkList<int> a(x,5,1);
    a.PrintList();
    a.ReverseList();
    a.PrintList();

}

（4）设计算法判断非空单链表是否递增有序

#include <iostream>
using namespace std;
template <typename T>
class Node{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkList{
public:
    LinkList();
    LinkList(T a[],int l,int flag);//flag==0时，头插法；flag==1时，尾插法
    bool isAscOrder();
private:
    Node<T> *first;
};
template<typename T>
LinkList<T>::LinkList(){
    first=new Node<T>;
    first->next=nullptr;
}
template<typename T>
LinkList<T>::LinkList(T a[],int l,int flag){
    if(flag==0){
    first=new Node<T>;
    first->next=nullptr;
    for(int i=0;i<l;i++)
    {
        Node<T> *p=new Node<T>;
        p->data=a[i];
        p->next=first->next;
        first->next=p;
    }
    }
    else {
    first=new Node<T>;
    Node<T> *r=first,*p=nullptr;
    for(int i=0;i<l;i++)
     {
        p=new Node<T>;
        p->data=a[i];
        r->next=p;
        r=p;
    }
    r->next=nullptr;
    }
}
template<typename T>
bool LinkList<T>::isAscOrder(){
    Node<T> *p=first->next;
    while(p->next){
        if(p->data>p->next->data) return false;
        p=p->next;
    }
    return true;
}
int main()
{
    int x[6]={7,2,3,4,5,6};
    LinkList<int> a(x,6,1);
    cout<<a.isAscOrder();
}

（5）给定一个带头结点的单链表，设计算法按递增次序输出单链表中各结点的数据元素，并释放结点所占的存储空间。

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkList
{
public:
    LinkList();
    LinkList(T a[],int l,int flag);//flag==0时，头插法；flag==1时，尾插法
    void PrintAscOrder();
    void Print();
private:
    Node<T> *first;
};
template<typename T>
LinkList<T>::LinkList()
{
    first=new Node<T>;
    first->next=nullptr;
}
template<typename T>
LinkList<T>::LinkList(T a[],int l,int flag)
{
    if(flag==0)
    {
        first=new Node<T>;
        first->next=nullptr;
        for(int i=0; i<l; i++)
        {
            Node<T> *p=new Node<T>;
            p->data=a[i];
            p->next=first->next;
            first->next=p;
        }
    }
    else
    {
        first=new Node<T>;
        Node<T> *r=first,*p=nullptr;
        for(int i=0; i<l; i++)
        {
            p=new Node<T>;
            p->data=a[i];
            r->next=p;
            r=p;
        }
        r->next=nullptr;
    }
}
template <typename T>
void LinkList<T>::Print()
{
    Node<T> *p=first->next;
    while(p){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;

}
template<typename T>
void LinkList<T>::PrintAscOrder()
{
    while(first->next)
    {
        Node<T> *p=first;//遍历单链表
        Node<T> *q=first->next;//存最小结点
        Node<T> *s=first;//前一个
        while(p->next)
        {
            if(p->next->data<q->data) {q=p->next;s=p;}
            p=p->next;
        }
        cout<<q->data<<" ";
        s->next=q->next;
        delete q;
        p=first->next;
    }
    cout<<endl;
}
int main()
{
    int x[5]= {5,4,3,2,7};
    LinkList<int> a(x,5,1);
    a.Print();
    a.PrintAscOrder();
    a.Print();
}

（6）设单链表以非递归有序排列，设计算法实现在单链表中删除值相同的多余结点

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkList
{
public:
    LinkList();
    LinkList(T a[],int l,int flag);//flag==0时，头插法；flag==1时，尾插法
    void DeleteSame();
    void Print();
private:
    Node<T> *first;
};
template<typename T>
LinkList<T>::LinkList()
{
    first=new Node<T>;
    first->next=nullptr;
}
template<typename T>
LinkList<T>::LinkList(T a[],int l,int flag)
{
    if(flag==0)
    {
        first=new Node<T>;
        first->next=nullptr;
        for(int i=0; i<l; i++)
        {
            Node<T> *p=new Node<T>;
            p->data=a[i];
            p->next=first->next;
            first->next=p;
        }
    }
    else
    {
        first=new Node<T>;
        Node<T> *r=first,*p=nullptr;
        for(int i=0; i<l; i++)
        {
            p=new Node<T>;
            p->data=a[i];
            r->next=p;
            r=p;
        }
        r->next=nullptr;
    }
}
template <typename T>
void LinkList<T>::Print()
{
    Node<T> *p=first->next;
    while(p){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;

}
template<typename T>
void LinkList<T>::DeleteSame()
{
    Node<T> *p=first->next;
    while(p){
        if(p->next&&p->data==p->next->data) p->next=p->next->next;
        else p=p->next;
    }
}
int main()
{
    int x[13]= {1,3,3,3,4,4,5,6,7,8,8,8,8};
    LinkList<int> a(x,13,1);
    a.Print();
    a.DeleteSame();
    a.Print();
}

（7）已知单链表中各结点的元素值为整型且递增有序，设计算法删除链表中大于mink且小于maxk的所有元素，并释放被删结点的存储空间。

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkList
{
public:
    LinkList();
    LinkList(T a[],int l,int flag);//flag==0时，头插法；flag==1时，尾插法
    void DeleteNX(int mink,int maxk);
    void Print();
private:
    Node<T> *first;
};
template<typename T>
LinkList<T>::LinkList()
{
    first=new Node<T>;
    first->next=nullptr;
}
template<typename T>
LinkList<T>::LinkList(T a[],int l,int flag)
{
    if(flag==0)
    {
        first=new Node<T>;
        first->next=nullptr;
        for(int i=0; i<l; i++)
        {
            Node<T> *p=new Node<T>;
            p->data=a[i];
            p->next=first->next;
            first->next=p;
        }
    }
    else
    {
        first=new Node<T>;
        Node<T> *r=first,*p=nullptr;
        for(int i=0; i<l; i++)
        {
            p=new Node<T>;
            p->data=a[i];
            r->next=p;
            r=p;
        }
        r->next=nullptr;
    }
}
template <typename T>
void LinkList<T>::Print()
{
    Node<T> *p=first->next;
    while(p){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;

}
template<typename T>
void LinkList<T>::DeleteNX(int mink,int maxk)
{
    Node<T> *p=first;
    while(p->next){
        if(p->next->data>mink&&p->next->data<maxk){
            Node<T> *q=p->next;
            p->next=q->next;
            delete q;
        }
        else p=p->next;
    }
}
int main()
{
    int x[13]= {1,3,3,3,4,4,5,6,7,8,8,8,8};
    LinkList<int> a(x,13,1);
    a.Print();
    a.DeleteNX(0,7);
    a.Print();

}

（8）有两个整数序列A={a1,a2,…,am}和B={b1,b2,…,bn}已经存入两个单链表中，设计算法判断序列B是否是序列A的子序列。

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkList
{
public:
    LinkList();
    LinkList(T a[],int l,int flag);//flag==0时，头插法；flag==1时，尾插法
    bool isCorrect(LinkList<T> ex);
private:
    Node<T> *first;
};
template<typename T>
LinkList<T>::LinkList()
{
    first=new Node<T>;
    first->next=nullptr;
}
template<typename T>
LinkList<T>::LinkList(T a[],int l,int flag)
{
    if(flag==0)
    {
        first=new Node<T>;
        first->next=nullptr;
        for(int i=0; i<l; i++)
        {
            Node<T> *p=new Node<T>;
            p->data=a[i];
            p->next=first->next;
            first->next=p;
        }
    }
    else
    {
        first=new Node<T>;
        Node<T> *r=first,*p=nullptr;
        for(int i=0; i<l; i++)
        {
            p=new Node<T>;
            p->data=a[i];
            r->next=p;
            r=p;
        }
        r->next=nullptr;
    }
}
template<typename T>
bool LinkList<T>::isCorrect(LinkList<T> ex){//ex是长的
    Node<T> *p=first->next;
    Node<T> *q=ex.first->next;
    while(q){
        if(q->data==p->data) {q=q->next;p=p->next;}
        else {p=first->next;q=q->next;}
        if(!p) return true;
    }
    return false;
}
int main()
{
    int x[13]= {1,3,3,3,4,4,5,6,7,8,8,8,4};
    int y[4]={3,4,4,5};
    LinkList<int> a(x,13,1);
    LinkList<int> b(y,4,1);
    cout<<b.isCorrect(a);
}

（9）假设在长度大于1的循环链表中，即无头结点也无头指针，s为指向链表中某个结点的指针，试编写算法删除结点s的前趋结点。

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class CirLinkList
{
public:
    CirLinkList();
    CirLinkList(T a[],int l);
    void DeletePre(T x);
private:
    Node<T> *door;//进入循环的入口
    int length;
};
template<typename T>
CirLinkList<T>::CirLinkList()
{
    door=new Node<T>;
    door=nullptr;
    door->next=door;
    length=0;
}
template<typename T>
CirLinkList<T>::CirLinkList(T a[],int l)
{
    length=l;
    door=new Node<T>;
    Node<T> *p=door;
    p->data=a[0];
    for(int i=1;i<l;i++){
        Node<T> *t=new Node<T>;
        t->data=a[i];
        p->next=t;
        p=p->next;
    }
    p->next=door;
}
template<typename T>
void CirLinkList<T>::DeletePre(T x){
    Node<T> *p=door;
    Node<T> *t=door;
    int flag=1;
    while(p->data!=x){
        p=p->next;
        if(p==door) {cout<<"没有这个结点"<<endl;flag=0;break;}
    }
    if(flag){
        for(int i=0;i<length-1;i++)
            {t=p;p=p->next;}
        t->next=p->next;
        cout<<"已删除结点："<<p->data;
        if(p==door) door=t;
        delete p;
    }
    cout<<endl;
    Node<T> *s=door;
    do{
        cout<<s->data<<" ";
        s=s->next;
    }while(s!=door);

}
int main()
{
    int a[5]={1,2,3,4,5};
    CirLinkList<int> x(a,5);
    x.DeletePre(3);
}

（10）判断带头结点的双循环链表是否对称。

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next,*prior;
};
template <typename T>
class DCirLinkList
{
public:
    DCirLinkList();
    DCirLinkList(T a[],int l);
    bool isSymmetrical();
private:
    Node<T> *first;
    int length;
};
template<typename T>
DCirLinkList<T>::DCirLinkList()
{
    first=new Node<T>;
    first->next=first;
    first->prior=first;
    length=0;
}
template<typename T>
DCirLinkList<T>::DCirLinkList(T a[],int l)
{
    first=new Node<T>;
    Node<T> *rear=first;
    first->next=first;
    first->prior=first;
    for(int i=0; i<l; i++)
    {
        Node<T> *p=new Node<T>;
        p->data=a[i];
        rear->next=p;
        p->prior=rear;
        rear=p;
    }
    rear->next=first;
    first->prior=rear;
    length=l;
}
template<typename T>
bool DCirLinkList<T>::isSymmetrical()
{
    Node<T> *p=first->next;
    Node<T> *q=first->prior;
    do{
        if(p->data!=q->data) return false;
        p=p->next;
        q=q->prior;
    }while(p!=q);
    return true;
}
int main()
{
    int a[6]= {1,2,3,4,2,1};
    DCirLinkList<int> x(a,6);
    cout<<x.isSymmetrical()<<endl;
}

（11）设计算法实现在双链表中第i个结点的后面插入一个值为x的结点。

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next,*prior;
};
template <typename T>
class DLinkList
{
public:
    DLinkList();
    DLinkList(T a[],int l);
    void Insert(int i,T x);
private:
    Node<T> *first;
    int length;
};
template<typename T>
DLinkList<T>::DLinkList()
{
    first=new Node<T>;
    length=0;
}
template<typename T>
DLinkList<T>::DLinkList(T a[],int l)
{
    length=l;
    first=new Node<T>;
    Node<T> *rear=first;
    for(int i=0;i<l;i++){
        Node<T> *p=new Node<T>;
        p->data=a[i];
        p->prior=rear;
        rear->next=p;
        rear=p;
    }
}
template<typename T>
void DLinkList<T>::Insert(int i,T x){
    if(i>length||i<0) throw "place error!!!";
    if(length==0){
        Node<T> *p=new Node<T>;
        p->data=x;
        first->next=p;
        p->prior=first;
        length++;

    }
    else{
            Node<T> *p=first;
        int count=0;
        while(count++<i)
            p=p->next;
        Node<T> *q=new Node<T>;
        q->data=x;
        p->next->prior=q;
        q->next=p->next;
        p->next=q;
        q->prior=p;
        length++;

    }
     Node<T> *t=first->next;
    for(int i=0;i<length;i++)
    {
        cout<<t->prior->data<<" "<<t->data<<" "<<t->next->data<<endl;
        t=t->next;
    }
}
int main()
{
    int a[6]= {1,2,3,4,5,6};
    DLinkList<int> x(a,6);
    DLinkList<int> y;
    x.Insert(0,3);
    cout<<"---------------------"<<endl;
    y.Insert(0,2);
    cout<<"---------------------"<<endl;
    y.Insert(0,3);
}

（12）假设用不带头结点的单链表表示八进制数。要求写一个函数Add，该函数有两个参数A和B，分别指向表示八进制数的单链表，执行函数调用Add（A,B）后，得到表示八进制数A加八进制数B所得结果的单链表。

（1）带头结点的内置函数
#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next,*prior;
};
template <typename T>
class DLinkList
{
public:
    DLinkList();
    DLinkList(T a[],int l);
    DLinkList<T> Add(DLinkList x);
    void Print();
private:
    Node<T> *first,*rear;
    int length;
};
template<typename T>
void DLinkList<T>::Print(){
    Node<T> *p=first->next;
    while(p){
        cout<<p->data;
        p=p->next;
    }
}
template<typename T>
DLinkList<T>::DLinkList()
{
    first=new Node<T>;
    first->next=nullptr;
    length=0;
}
template<typename T>
DLinkList<T>::DLinkList(T a[],int l)
{
    length=l;
    first=new Node<T>;
    rear=first;
    for(int i=0;i<l;i++){
        Node<T> *p=new Node<T>;
        p->data=a[i];
        p->prior=rear;
        rear->next=p;
        rear=p;
    }
}
template<typename T>
DLinkList<T> DLinkList<T>::Add(DLinkList<T> x){
    Node<T> *p=x.rear;
    Node<T> *q=rear;
    DLinkList<T> f;
    int flag=0;
    if(x.length==length){
        while(p!=x.first){
            Node<T> *t=new Node<T>;
            if(p->data+q->data+flag>7){
                t->data=p->data+q->data+flag-7;
                flag=1;
            }
            else{
                t->data=p->data+q->data+flag;
                flag=0;
            }
            t->next=f.first->next;
            f.first->next=t;
            p=p->prior;
            q=q->prior;
        }
    }
    else if(x.length<length){
        while(p!=x.first){
            Node<T> *t=new Node<T>;
            if(p->data+q->data+flag>7){
                t->data=p->data+q->data+flag-7;
                flag=1;
            }
            else{
                t->data=p->data+q->data+flag;
                flag=0;
            }
            t->next=f.first->next;
            f.first->next=t;
            p=p->prior;
            q=q->prior;
        }
        while(q!=first){
            Node<T> *t=new Node<T>;
            if(q->data+flag>7){
                t->data=q->data+flag-7;
                flag=1;
            }
            else{
                t->data=q->data+flag;
                flag=0;
            }
            t->next=f.first->next;
            f.first->next=t;
            q=q->prior;
        }
    }

    else{
        while(q!=first){
            Node<T> *t=new Node<T>;
            if(p->data+q->data+flag>7){
                t->data=p->data+q->data+flag-7;
                flag=1;
            }
            else{
                t->data=p->data+q->data+flag;
                flag=0;
            }
            t->next=f.first->next;
            f.first->next=t;
            p=p->prior;
            q=q->prior;
        }
        while(p!=x.first){
            Node<T> *t=new Node<T>;
            if(p->data+flag>7){
                t->data=p->data+flag-7;
                flag=1;
            }
            else{
                t->data=p->data+flag;
                flag=0;
            }
            t->next=f.first->next;
            f.first->next=t;
            p=p->prior;
        }
    }
    return f;
}
int main()
{
    int x[5]= {1,7,1,4,7};
    int y[3]={7,2,2};
    DLinkList<int> a(x,5);
    DLinkList<int> b(y,3);
    DLinkList<int> c=a.Add(b);
    c.Print();

}
（2）不带头结点的函数调用
#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next,*prior;
};
template <typename T>
class DLinkList
{
public:
    DLinkList();
    DLinkList(T a[],int l);
//    DLinkList<T> Add(DLinkList x);
    void Print();
    Node<T> *first,*rear;
//    void Insert(T x);
    int length;
};
template<typename T>
void DLinkList<T>::Print(){
    Node<T> *p=first;
    while(p!=rear){
        cout<<p->data;
        p=p->next;
    }
}
//template<typename T>
//void DLinkList<T>::Insert(T x)
//{
//    Node<T> *p=new Node<T>;
//    p->data=x;
//    if(length==0)
//        {first=p;
//        rear=p;
//        first->next=nullptr;
//        }
//    else {
//        p->prior=rear;
//        rear->next=p;
//        rear=p;
//    }
//    length++;
//
//}
template<typename T>
DLinkList<T>::DLinkList()
{
    first=new Node<T>;
    rear=first;
    length=0;
    rear->next=nullptr;
    first->prior=nullptr;

}
template<typename T>
DLinkList<T>::DLinkList(T a[],int l)
{
    length=l;
    first=new Node<T>;
    Node<T> *p=new Node<T>;
    p->data=a[0];
    first=p;
    rear=first;
    for(int i=1;i<l;i++){
        Node<T> *p=new Node<T>;
        p->data=a[i];
        p->prior=rear;
        rear->next=p;
        rear=p;
    }
    rear->next=nullptr;
    first->prior=nullptr;
}
template<typename T>
DLinkList<T> Add(DLinkList<T> y,DLinkList<T> x){
    Node<T> *p=x.rear;
    Node<T> *q=y.rear;
    DLinkList<T> f;
    int flag=0;
    if(x.length==y.length){
        while(p){
            Node<T> *t=new Node<T>;
            if(p->data+q->data+flag>7){
                t->data=p->data+q->data+flag-7;
                flag=1;
            }
            else{
                t->data=p->data+q->data+flag;
                flag=0;
            }
            t->next=f.first;
            f.first=t;
            p=p->prior;
            q=q->prior;
        }
    }
    else if(x.length<y.length){
        while(p){
            Node<T> *t=new Node<T>;
            if(p->data+q->data+flag>7){
                t->data=p->data+q->data+flag-7;
                flag=1;
            }
            else{
                t->data=p->data+q->data+flag;
                flag=0;
            }
            t->next=f.first;
            f.first=t;
            p=p->prior;
            q=q->prior;
        }
        while(q){
            Node<T> *t=new Node<T>;
            if(q->data+flag>7){
                t->data=q->data+flag-7;
                flag=1;
            }
            else{
                t->data=q->data+flag;
                flag=0;
            }
            t->next=f.first;
            f.first=t;
            q=q->prior;
        }
    }

    else{
        while(q){
            Node<T> *t=new Node<T>;
            if(p->data+q->data+flag>7){
                t->data=p->data+q->data+flag-7;
                flag=1;
            }
            else{
                t->data=p->data+q->data+flag;
                flag=0;
            }
            t->next=f.first;
            f.first=t;
            p=p->prior;
            q=q->prior;
        }
        while(p){
            Node<T> *t=new Node<T>;
            if(p->data+flag>7){
                t->data=p->data+flag-7;
                flag=1;
            }
            else{
                t->data=p->data+flag;
                flag=0;
            }
            t->next=f.first;
            f.first=t;
            p=p->prior;
        }
    }
    return f;
}
int main()
{
    int x[4]= {1,2,3,7};
    int y[3]={2,2,4};
    DLinkList<int> a(x,4);
    DLinkList<int> b(y,3);
    DLinkList<int> c=Add(a,b);
    c.Print();
}

栈和队列 P96

3.算法设计

（1）假设以不带头结点的循环链表表示队列，并且只设一个指针指向队尾结点，但不设头指针。设计入队和出队算法。

#include <iostream>
using namespace std;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class CirLinkQueue
{
public:
    CirLinkQueue();
    CirLinkQueue(T a[],int l);
    void Print();
    void EnQueue(T x);
    void DeQueue();
    Node<T> *door,*rear;
    int length;
};
template<typename T>
void CirLinkQueue<T>::Print()
{
    if(length==0) throw "overflow!!!";

    Node<T> *s=door;
    do
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    while(s!=door);
    cout<<endl;
}
template<typename T>
CirLinkQueue<T>::CirLinkQueue()
{
    length=0;

}
template<typename T>
CirLinkQueue<T>::CirLinkQueue(T a[],int l)
{
    door=new Node<T>;
    rear=door;
    rear->next=door;
    Node<T> *p=new Node<T>;
    p->data=a[0];
    door->data=a[0];
    for(int i=1; i<l; i++)
    {
        Node<T> *p=new Node<T>;
        p->data=a[i];
        rear->next=p;
        p->next=door;
        rear=p;
    }
    length=l;
}
template<typename T>
void CirLinkQueue<T>::EnQueue(T x){
    Node<T> *p=new Node<T>;
    p->data=x;
    if(length==0){
        door=new Node<T>;
        rear=door=p;
        rear->next=door;
        door->next=rear;
    }
    else{
    rear->next=p;
    rear=p;
    p->next=door;}
    length++;
    Print();
}
template<typename T>
void CirLinkQueue<T>::DeQueue(){
    Node<T> *p=door;
    rear->next=door->next;
    door=door->next;
    delete p;
    length--;
    Print();
}
int main()
{
    int x[5]= {1,2,3,4,5};
    CirLinkQueue<int> a(x,5);
//    CirLinkQueue<int> a;
    a.EnQueue(6);
    a.EnQueue(7);
    a.DeQueue();
    a.DeQueue();

}

（2）设顺序栈S中有2n个元素，从栈顶到栈底的元素依次为a2n,a2n-1,…,a1，要求通过一个循环队列重新排列栈中元素，使得从栈顶到栈底的元素依次为a2n,a2n-2,…,a2,a2n-1,a2n-3,…,a1，设计算法实现，空闲和时间复杂度均为O(n)。

#include <iostream>
using namespace std;
const int Size=100;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class SeqStack
{
public:
    SeqStack(T a[],int l);
    T Pop();
    void Push(T x);
    void Output();

private:
    T data[Size];
    int top;
};
template<typename T>
SeqStack<T>::SeqStack(T a[],int l){
    top=-1;
    if(l>Size||l<0) throw "overflow!!!";
    for(int i=0;i<l;i++)
        data[++top]=a[i];
}
template<typename T>
T SeqStack<T>::Pop(){
    if(top==-1) throw "overflow!!!";
    return data[top--];
}
template<typename T>
void SeqStack<T>::Push(T x){
    if(top==Size) throw "overflow!!!";
    data[++top]=x;
}
template<typename T>
void SeqStack<T>::Output(){
    if(top==-1) throw "overflow!!!";
    for(int i=top;i>=0;i--)
        cout<<data[i]<<" ";
    cout<<endl;
}
template <typename T>
class CirLinkQueue
{
public:
    CirLinkQueue();
    CirLinkQueue(T a[],int l);
    void Print();
    void EnQueue(T x);
    T DeQueue();
    Node<T> *door,*rear;
    int length;
};
template<typename T>
void CirLinkQueue<T>::Print()
{
    if(length==0) throw "overflow!!!";

    Node<T> *s=door;
    do
    {
        cout<<s->data<<" ";
        s=s->next;
    }
    while(s!=door);
    cout<<endl;
}
template<typename T>
CirLinkQueue<T>::CirLinkQueue()
{
    length=0;

}
template<typename T>
CirLinkQueue<T>::CirLinkQueue(T a[],int l)
{
    door=new Node<T>;
    rear=door;
    rear->next=door;
    Node<T> *p=new Node<T>;
    p->data=a[0];
    door->data=a[0];
    for(int i=1; i<l; i++)
    {
        Node<T> *p=new Node<T>;
        p->data=a[i];
        rear->next=p;
        p->next=door;
        rear=p;
    }
    length=l;
}
template<typename T>
void CirLinkQueue<T>::EnQueue(T x){
    Node<T> *p=new Node<T>;
    p->data=x;
    if(length==0){
        door=new Node<T>;
        rear=door=p;
        rear->next=door;
        door->next=rear;
    }
    else{
    rear->next=p;
    rear=p;
    p->next=door;}
    length++;
}
template<typename T>
T CirLinkQueue<T>::DeQueue(){
    Node<T> *p=door;
    T x=p->data;
    rear->next=door->next;
    door=door->next;
    delete p;
    length--;
    return x;
}
int main()
{
    int x[8]= {1,2,3,4,5,6,7,8};
    SeqStack<int> S(x,8);
    S.Output();
    CirLinkQueue<int> b;
    for(int i=0;i<8;i++)
        b.EnQueue(S.Pop());
    for(int i=0;i<8;i++)
    {if(i%2==0)
        b.EnQueue(b.DeQueue());
    else
        S.Push(b.DeQueue());
        }
    for(int i=0;i<4;i++)
        b.EnQueue(S.Pop());
    for(int i=0;i<4;i++)
        S.Push(b.DeQueue());
    for(int i=0;i<4;i++)
        b.EnQueue(S.Pop());
    for(int i=0;i<8;i++)
        S.Push(b.DeQueue());
    S.Output();
}
/*
① 将所有元素出栈并入队；
② 依次将队列元素出队，如果是偶数结点，则再入队，如果是奇数结点，则入栈；
③ 将奇数结点出栈并入队；
④ 将偶数结点出队并入栈；
⑤ 将所有元素出栈并入队；
⑥ 将所有元素出队并入栈即为所求。
*/

（3）设计算法，把十进制整数转换为二至九进制之间的任一进制输出。

#include <iostream>
using namespace std;
const int Size=100;
template <typename T>
class Node
{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class SeqStack
{
public:
    SeqStack();
    void Push(T x);
    void Output();

private:
    T data[Size];
    int top;
};
template<typename T>
SeqStack<T>::SeqStack(){top=-1;}
template<typename T>
void SeqStack<T>::Push(T x){
    if(top==Size) throw "overflow!!!";
    data[++top]=x;
}
template<typename T>
void SeqStack<T>::Output(){
    if(top==-1) throw "overflow!!!";
    for(int i=top;i>=0;i--)
        cout<<data[i];
    cout<<endl;
}
int main()
{
    SeqStack<int> a;
    int n;
    cin>>n;
    int jj;
    cin>>jj;
    while(n!=0){
        a.Push(n%jj);
        n=n/jj;
    }
    a.Output();
}
cure_myheart
关注
  • 18
    点赞
  • 踩
  • 96
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
南邮数据结构实验1.4：带表头结点单链表的非递减排序
Wonz
05-26 6989
题目：以实验 1.2 的带表头结点单链表为存储结构，编写程序实现单链表的非递减排序。 部分代码： 带表头结点单链表的非递减排序函数： 本来想用冒泡排序的，但是没成功，此部分程序参考了这里：https://bbs.csdn.net/topics/390668062 //简单选择排序：每次选择min的排到前面 Status Order(HeaderList *h){ Node *s1...
单链表（练习）
weixin_40805072的博客
09-17 2667
1.设计算法，判断一个带头结点的单链表list是否非递减有序。 自己思路：遍历单链表 ，每遇到一个结点判断，当前结点的值 是否小于 等于后继结点值，若为真则结束循环，该list为非递减序列；否则指针后移，继续判断，直到下一个结点为NULL，结束循环。 简单写下： L=(list*)malloc(sizeof(list)); list *p=L->next; if(p==NULL) r...
判断带表头的单链表是否有序递增
Wonz
09-01 5802
题目 设计一个算法判定带表头结点的单链表是否有序递增，并讨论算法的时间复杂度。 部分代码 判断是否有序递增 Status order(HeaderList *h, int n){ int flag=-1; //判定标志 Node *p = h-&gt;head-&gt;link,*q=p-&gt;link; while(p-&gt;li...
数据结构-简答题&算法题2
weixin_46390041的博客
04-11 2955
简答题&算法题
判断该单链表是否递增有序
qq_62175345的博客
05-15 2473
给定一个非空单链表，其数据元素为整数，本题要求实现一个函数， 可判断该单链表是否递增有序。若是，输出“YES”，否则，输出“NO”。 输入样例： 5 1 2 3 4 5 输出样例： YES #include <iostream> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define MAXSIZE 100 typedef int Status; typedef int Ele..
数据结构-课后习题-全部答案.pdf
12-31
"数据结构-课后习题-全部答案.pdf" 数据结构是计算机科学中的一门重要课程，它研究的是数据之间的关系和组织方式。本节课后习题答案涵盖了数据结构的基本概念、逻辑结构、存储结构、运算三个方面的内容。 1.1 数据...
工作流技术--课后习题答案.pdf
12-28
《工作流技术--课后习题答案》 工作流技术是管理和自动化业务流程的关键工具，它涉及任务的顺序、选择、并行和迭代等基本构造。在习题1.1中，介绍了这些基本构造的定义和相互关系： 1. **顺序**：任务按照预设的...
java-web课本课后简答题.doc
11-15
Java Web 课本课后简答题 本资源摘要信息涵盖了 Java Web 开发中的一些重要概念和技术，包括 URL 和 URI、动态 Web 文档技术、MVC 设计模式、Servlet 和 HTTP 等。 一、URL 和 URI * URL（Uniform Resource ...
LinuxShell自动化运维-课后习题答案.docx
最新发布
12-17
2. Shell 数组：Shell 数组是一种数据结构，可以存储多个值。例如 `arr=(1 2 3 4 5)`。 3. Shell 正则表达式：Shell 提供了正则表达式，可以用来匹配字符串。例如 `echo "Hello World!" | grep -o "Hello"`。 四、...
python练习题-答案.doc
08-11
在 Python 中，列表、元组、字符串都是有序的数据结构，意思是它们中的元素都可以通过索引访问。 4. 查看变量类型的 Python 内置函数是 type()。 type() 函数用于获取变量的类型，在 Python 中可以使用 type() ...
设计一个算法，判断顺序表L中所有元素是否是递增有序的
热门推荐
BLOG域名:programb.blog.csdn.net
03-01 1万+
以下是一个简单的Python算法，用于判断顺序表L中所有元素是否是递增有序的：该算法使用一个简单的for循环来遍历顺序表L中的所有元素。对于每个元素，它检查当前元素是否大于或等于下一个元素。如果找到任何这样的元素对，即当前元素大于或等于下一个元素，那么该算法立即返回False，表示顺序表L中的元素不是递增有序的。如果循环完成而没有返回False，则说明顺序表L中的所有元素都是递增有序的，该算法返回True。对于大型的顺序表，该算法可能会很慢，因为它需要遍历整个顺序表。
王道课后习题2.3.6：设计一个算法使单链表L元素递增有序
qq_34941153的博客
08-21 3422
题目描述： 有一个带头结点的单链表L，设计一个算法使其元素递增有序 算法思想： 类似于直接插入排序。找到要插入的位置。 原序列：L->1->4->2->3->6 L->1->NULL 若排序到这一步： L->1->2->4 待插入3 pre p q r L-> 1-> 2-> 4 3-&gt...
C++构建一张单链表，实现对单链表的插入、删除、求表长。将单链表逆置，并判断单链表是否递增有序
Frank_LLX的博客
02-02 830
来自大二上学期实验报告1，请多指教。 一、实验任务： 构建一张单链表，实现对单链表的插入、删除、求表长。将单链表逆置，并判断单链表是否递增有序。 二、代码： template<class DataType> struct Node { DataType data; Node<DataType>* next; }; template<class DataType&g...
Leetcode每日一题：面试题02.02.kth-node-from-end-of-list-lcci（返回倒数第k个节点）
CodeLuweir 的博客
09-28 3134
思路：典型得快慢指针问题，快指针与慢指针中间隔着k-2个节点，那么同时++快慢指针，当快指针指向链表结尾节点时，慢指针指向倒数第k个节点； struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; int kthToLast(ListNode *head, int k) { ListNode *left = head, *right = head; int count = 1; .
按递增次序输出带头节点单链表的数据元素并释放其空间
vivi_and_qiao的博客
09-19 3617
#include "stdafx.h" #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;stdlib.h&gt; typedef int type; typedef struct lnode //定义链表结点的数据结构 { int data; struct lnode *next; }Lnode; ty...
数据结构-单链表
qq_30939943的博客
07-01 1281
1.单链表的结点类型定义 typedef struct LNode { int data; struct LNode*next; }LNode,*LinkList; 2.单链表头插法 算法思想：1.创建头结点指向空结点；2.循环创建结点p，p->next指针指向L->next;L->next=p->next. LinkList ListInsertHead(LinkList &L) //LinkList:意味着最终返回LinkList链表； Linkli
单链表的应用--判断单链表是否有序
qq_39400324的博客
01-25 3332
  判断单链表是否有序，利用前文写好的链表的框架，在链表类中补充IsOrdering方法。 对单链表排序一、问题分析二、代码分析1.链表类LinkList2.链表方法IsOrdering三、测试代码1.主函数2.输出结果四、源代码获取（免积分） 一、问题分析   给你一个单链表，判断其是否为升序排列。（一般默认情况下，都是讨论升序排列。） 二、代码分析   判断单链表是否有序只需要判断两个相邻的元素结点的值是否符合排序要求即可，一旦发现不符合排序要求的结点，返回0；如果直到比较结束都没有返回0，则最终返回1
2022年优秀-Linux网络服务器配置与管理4.pptx
11-14
课程强调了FTP使用的C/S模型和默认情况下使用的数据端口和命令端口的概念，并提醒学员们减少外部程序或脚本的执行，以减少安全隐患。FTP服务器允许匿名用户登录，并且许多系统要求用户将Email地址作为口令，以便更好...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值