数据结构第二章线性表（二）①单链表逆置②单链表删除重复数值③查找单链表倒数第k个结点

4、单链表逆置

以单链表作存储结构存储非空线性表，编写一个实现线性表就地逆置的算法。空间复杂度均是O(1)。

/*单链表逆置
以单链表作存储结构存储非空线性表，编写一个
实现线性表就地逆置的算法。空间复杂度均是O(1)。
*/
#include 
using namespace std;

typedef int DataType;
typedef struct node{
     
    DataType data;
    node* next;
}node;
node* first;
int length;

void init()
{
     
    first = new node;
    first->next = NULL;
    node* rear = first;
    cin>>length;
    for(int i=0;i<length;++i){
     
        DataType elem;
        cin>>elem;
        node* s = new node;
        s->data = elem;
        s->next = NULL;
        rear->next = s;
        rear = s;
    }
}
void reverseList()
{
     
    node *p,*q;
            p=first->next;
            first->next=NULL;
            while(p!=NULL){
     
            q=p->next;
            p->next=first->next;
            first->next=p;
            p=q;}

}
void show()
{
     
    node* p = first->next;
    while(p != NULL){
     
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}
int main()
{
     
    init();
    reverseList();
    show();
    return 0;
}

5、单链表删除重复数值

有一个递增非空单链表，设计一个算法删除值域重复的结点。例如{1,1,2,3,3,3,4,4,7,7,7,9,9,9,}，经过删除后变成{1,2,3,4,7,9}。

/*单链表删除重复数值
有一个递增非空单链表，设计一个算法删除值域
重复的结点。例如{1,1,2,3,3,3,4,4,7,7,7,9,9,
9,}，经过删除后变成{1,2,3,4,7,9}。
*/
#include 
using namespace std;

template <class DataType>
struct node{
     
DataType data;
node<DataType>* next;
};

template <class DataType>
class linkList{
     
    public:
        linkList();
        ~linkList();
        void Delete();
        void show();
    private:
        node<DataType>* first;
};

template <class DataType>
linkList<DataType>::linkList()
{
     
    first = new node<DataType>;
    first->next = NULL;
    node<DataType>* rear = first;
    int n;
    cin>>n;
    for(int i=0;i<n;++i){
     
        DataType elem;
        cin>>elem;
        node<DataType>* s = new node<DataType>;
        s->data = elem;
        s->next = NULL;
        rear->next = s;
        rear = s;
    }
}
template <class DataType>
linkList<DataType>::~linkList()
{
     
    node<DataType>* p;
    while(first != NULL){
     
        p = first;
        first = first->next;
        delete p;
    }
}
template <class DataType>
void linkList<DataType>::Delete()
{
     
    node<int>*p=first->next,*q=NULL;
     while(p->next!=NULL)
     {
     
         q=p->next;
         if(p->data==q->data)
         {
     
             p->next=q->next;
             delete q;
         }
        else p=q;
     }

}

template <class DataType>
void linkList<DataType>::show()
{
     
    node<DataType>* p = first->next;
    if(p == NULL) cout<<"Empty";
    else{
     
        while(p != NULL){
     
            cout<<p->data<<" ";
            p = p->next;
        }
        cout<<endl;
    }
}
int main()
{
     
    linkList<int> L;
    L.Delete();
    L.show();
    L.~linkList();
    return 0;
}

6、查找单链表倒数第k个结点

【问题描述】输入一个单向链表，输出该链表中倒数第k个结点，链表的最后一个结点是倒数第1个节点。

【输入形式】第一行是数据的个数，第二行是空格分割的整型值，第三行是K值。

【输出形式】输出为倒数第K个结点的值，若无，则输出Not Found。

【样例输入】

               8

               13 45 54 32 1 4 98 2

              3

【样例输出】4

【样例说明】K值为3，则输出链表倒数第3个结点的值，为4；数据输入间以空格隔开

【评分标准】本题要综合输出正确性及使用的数据结构。需由输入数据构建单链表。不使用链表的将不得分。

/*查找单链表倒数第k个结点
问题描述】输入一个单向链表，输出该链表中倒
数第k个结点，链表的最后一个结点是倒数第1个
节点。
输入形式】第一行是数据的个数，第二行是空格
分割的整型值，第三行是K值。
输出形式】输出为倒数第K个结点的值，若无，则
输出Not Found。
样例输入】                   8

                   13 45 54 32 1 4 98 2

                  3
样例输出】4
样例说明】K值为3，则输出链表倒数第3个结点的
为4；数据输入间以空格隔开
*/#include 
using namespace std;

template <class DataType>
struct node{
     
DataType data;
node<DataType>* next;
};

template <class DataType>
class linkList{
     
    public:
        linkList();
        ~linkList();
        node<DataType>* reverseFindK(int k);
    private:
        node<DataType>* first;
};

template <class DataType>
linkList<DataType>::linkList()
{
     
    first = new node<DataType>;
    first->next = NULL;
    node<DataType>* rear = first;
    int n;
    cin>>n;
    for(int i=0;i<n;++i){
     
        DataType elem;
        cin>>elem;
        node<DataType>* s = new node<DataType>;
        s->data = elem;
        s->next = NULL;
        rear->next = s;
        rear = s;
    }
}
template <class DataType>
linkList<DataType>::~linkList()
{
     
    node<DataType>* p;
    while(first != NULL){
     
        p = first;
        first = first->next;
        delete p;
    }
}

template <class DataType>
node<DataType>* linkList<DataType>::reverseFindK(int k)
{
     
    node<DataType>*p=first->next,*q=NULL;
      int count=0;
      while(p!=NULL)
      {
     
          p=p->next;
          count++;
      }
      if (k>count)
        q=NULL;
      else{
     
         q=first->next;
      int count2=1;
      while(q!=NULL&&count2<count-k+1)
      {
     
          q=q->next;
          count2++;
      }
      }

     return q;

}
int main()
{
     
    linkList<int> L;
    int k;
    cin>>k;
    node<int>* p = L.reverseFindK(k);
    if(p == NULL)
        cout<<"Not Found"<<endl;
    else
        cout<<p->data<<endl;
    L.~linkList();
    return 0;
}