王道数据结构线性表课后试题(二)

王道数据结构线性表课后试题(二)

链表节点：

struct Node
{
    int data;
    Node *next;
};

Q1:设计递归算法，删除不带头结点的单链表中值为X的节点

void DeleteValueX(Node* &l,int x)
{
    Node *p;
    if(l==nullptr)
        return;
    if(l->data==x)
    {
        p=l;
        l=l->next;
        delete(p);
        DeleteValueX(l,x);
    }
    else
        DeleteValueX(l->next,x);
}

Q2:删除带头结点的单链表中值为X的节点

Node *DeleteValueXWithhead(Node *l,int x)
{
    Node *p=l->next,*pre=l,*q;
    while(p!=nullptr)
    {
        if(p->data==x)
        {
            q=p;
            p=p->next;
            pre->next=p;
            delete q;
        }
        else
        {
            pre=p;
            p=p->next;
        }
    }
    return l;
}

Q3:逆序输出单链表

//为了方便直接用stl了，常规空间换时间
void ReOrderPrint(Node *l)
{
    stack<int> s;
    cout<<l->data<<" ";
    Node *p=l->next;
    while(p!=nullptr)
    {
        s.push(p->data);
        p=p->next;
    }

    while(!s.empty())
    {
        cout<<s.top()<<" ";
        s.pop();
    }
}

Q4:删一个最小值节点，最小值唯一。

Node *DeleteminimumValue(Node *l)
{
    int Min=99999;
    Node *p1=l->next,*p2=l;
    while(p1!=nullptr)
    {
        if(p1->data<Min)
            Min=p1->data;
        p1=p1->next;
    }

    while(p2->next!=nullptr)
    {
        if(p2->next->data==Min)
        {
            Node *pnext=p2->next;
            p2->next=pnext->next;
            delete pnext;
            break;
        }
        else p2=p2->next;
    }
    return l;
}

//看了标准答案之后改的
Node *DeleteminimumValue(Node *l)
{
    int Min=99999;
    Node *p=l->next,*pre=l,*Minptr=nullptr,*Minpreptr=nullptr;
    while(p!=nullptr)
    {
        if(p->data<Min)
        {
            Minpreptr=pre;
            Minptr=p;
            Min=p->data;
        }
        pre=p;
        p=p->next;
    }
    Minpreptr->next=Minptr->next;
    delete Minptr;
    return l;
}

Q5:将链表就地逆置，辅助空间复杂度为O(1)

//先将第一个元素断下来
//将头节点后面的元素一个个断掉，接到第一个元素前面
//最后头节点指向倒置的链表
Node *InversionLinkList(Node *l)
{
    Node *s=l->next,*p;
    l->next=s->next;
    s->next=nullptr;

    while(l->next!=nullptr)
    {
        p=l->next;
        l->next=p->next;
        p->next=s;
        s=p;
    }
    l->next=s;
    return l;
}

Q6:给链表升序排序

//直接插入排序
void AscendingSort(Node* &l)
{
    Node *p1=l->next,*r,*pre=l;
    r=p1->next;
    p1->next=nullptr;//只有头节点和第一个元素的链表（之后的元素都直接插入到这个链表中）
    p1=r;//第二段链表的第一个节点
    while(p1!=nullptr)
    {
        r=p1->next;
        pre=l;
        while(pre->next!=nullptr&&pre->next->data>p1->data)
            pre=pre->next;
        p1->next=pre->next;
        pre->next=p1;

        p1=r;
    }
}

Q7:无序链表中删除给定值范围内的节点

//删除给定值范围内的元素
void DeleteInScope(Node* &l,int m,int M)
{
    Node *p=l->next,*pre=l;
    while(p!=nullptr)
    {
        if(p->data>m&&p->data<M)
        {
            Node *temp=p;
            pre->next=p->next;
            p=p->next;
            delete temp;
        }
        else
        {
            pre=p;
            p=p->next;
        }
    }
}