OJ：整数顺序表的基本运算

风范1997

已于 2022-10-25 00:32:27 修改

阅读量384

点赞数

文章标签：数据结构算法

于 2022-10-25 00:20:30 首次发布

本文链接：https://blog.csdn.net/m0_70232279/article/details/127505366

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

题目叙述

题目叙述

总时间限制:

10000ms

内存限制:

655350kB

描述

定义单链表类，创建带头结点的单链表（节点类型为整型数据），要求包含以下成员函数：

头插法创建单链表(利用构造函数实现)

尾插法创建单链表(重载构造函数实现)

链表的遍历

按值删除一个节点

按位置删除一个节点

判断该链表是否递增有序

链表的析构

输入

输入一组数据，以尾插法的形式创建单链表（０表示输入结束）（构造第一个链表）
输入一组数据，以头插法的形式创建单链表（０表示输入结束）（构造第二个链表）
输入要删除元素的值（在尾插法创建的链表中进行该操作）
输入要删除元素的位置（在尾插法创建的链表中进行该操作）

输出

输出尾插法创建链表的结果
输出头插法插法创建链表的结果
输出按值删除之后链表中剩余的元素（在尾插法创建的链表中进行该操作.若删除的元素不存在，输出Error）
输出按位置删除之后链表中剩余的元素（在尾插法创建的链表中进行该操作.若删除的元素不存在，输出Error
输出链表是否递增有序(在尾插法创建的链表中进行该操作.递增有序,输出Yes.否则输出No。)

样例输入

1 2 3 4 5 0　
1 2 3 4 5 0
2
0

样例输出

1 2 3 4 5
5 4 3 2 1
1 3 4 5
Error
Yes

代码：

#include <iostream>
#include <cstdlib>
using namespace std;
//cout<<l.head2是显示l.head2的地址
//cout<<l.head2->data是显示head2->data的值
//cout<<l.head2->next是显示head2->next的地址
class Node {//节点定义
public:
   int data;//数据域
   class Node* next;//指针域
};
class LinkList {
public:
   LinkList() {//初始化
       head = new Node;//new（新建）一个头节点
       head->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head->next = nullptr;

       head1 = new Node;//new（新建）一个头节点
       head1->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head1->next = nullptr;

       head2 = new Node;//new（新建）一个头节点
       head2->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head2->next = nullptr;
       int data1 = 1;
       while (data1 != 0) {
           cin >> data1;
           if (data1 != 0) {
               Node* newNode = new Node;//先定义一个Node节点指针newNode，头节点
               newNode->data = data1;//将data赋值给新定义的节点的数据域中
               Node* p = head1;//定义指针p指向头节点
               if (head1 == nullptr) {//当头节点为空时，设置newNode为新节点
                   head1 = newNode;
               }
               newNode->next = p->next;//将新节点插入指定位置
               p->next = newNode;//新节点的next指针指向之前的头节
           }
       }
       /*if (head1 == nullptr && head1->next == nullptr) {
           cout << "空" << endl;
       }*/

       Node* p1 = head1;
       while (p1->next != nullptr)
       {
           p1 = p1->next;
           cout << p1->data << " ";
       }

cout << endl;

   }
   LinkList(int n) {
       head = new Node;//new（新建）一个头节点
       head->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head->next = nullptr;

       head2 = new Node;//new（新建）一个头节点
       head2->data = 0;//因为定义head时用的是Node自定义类型，
       //因此有数据域，有指针域，data先定义为0，后面插入数据时更改，next同理
       head2->next = nullptr;
       int data1 = 1;
       while (data1 != 0) {
           cin >> data1;
           if (data1 != 0) {
               Node* newNode = new Node;//先定义一个Node节点指针newNode
               newNode->next = nullptr;//定义newNode的数据域和指针域
               newNode->data = data1;
               Node* p = head2;
               if (head2 == nullptr) {
                   head2 = newNode;
               }
               while (p->next != nullptr)
               {
                   p = p->next;//次循环结束后，p即为插入前的最后一个节点
               }
               p->next = newNode;
           }
       }

Node* p1 = head2;

       do {
           p1 = p1->next;
           cout << p1->data << " ";
       } while (p1->next != nullptr);
       cout << endl;

   }
   ~LinkList() {//析构
       delete head;
       delete head1;
       delete head2;
   }
   int CreatLinkList(int size);
   int GetLen();
   int GetlenForweicha();
   void JudgeZeng();
   void showLinkList();
   Node* Find(int data);
   Node* FindForweicha(int data1);
   void touchaList();
   void weichaList();
   void anyList(int data, int n);
   void DeleteAnyList(int data);
   void DeleteHeadList();
   bool isEmpty();
   void DeleteAll();
   void DeleteAnyListForweicha(int data1);
   void DeleteHeadListForweicha();
   void DeleteZhiListForweicha(int data1);
   void CreatFLink();
   void DisfloatLink();
private:
   Node* head;//头指针
   Node* head1;
   Node* head2;
   Node* temp;
};

int LinkList::GetlenForweicha() {
   int size = 0;
   Node* p = head2->next;//定义一个新指针，指向头节点的next
   //（next是第一个，头节点不算）
   //*p =的是next的值，head是=&next，(head->next==Node.next)
   while (p != nullptr) {
       size++;
       p = p->next;
   }
   return size;

}
//共三种创建链表方法
void LinkList::DeleteAnyListForweicha(int data1) {//删除任意位置元素,data1为位置
   Node* ptemp;
   if (data1 > GetlenForweicha() || data1 < 1) {
       cout << "Error" << endl;
   }
   else if (data1 == 1) {
       ptemp == head2->next;
       LinkList Link;
       Link.DeleteHeadListForweicha();
       Node* p1 = head2;

       do {
           p1 = p1->next;
           cout << p1->data << " ";
       } while (p1->next != nullptr);
       cout << endl;
   }
   else {
       Node* p = head2;
       for (int i = 1; i < data1; i++) {
           p = p->next;
       }
       ptemp = p;
       p = p->next;
       ptemp->next = p->next;
       delete p;
       p = nullptr;
       Node* p1 = head2;

       do {
           p1 = p1->next;
           cout << p1->data << " ";
       } while (p1->next != nullptr);
       cout << endl;
   }

}
void LinkList::DeleteHeadListForweicha() {//删除头部节点
   Node* p = head2;
   if (p == nullptr || p->next == nullptr) {
       cout << "该链表为空" << endl;
   }
   else {
       Node* ptemp = nullptr;
       p = p->next;
       ptemp = p->next;
       delete p;
       p = nullptr;
       head2->next = ptemp;
   }

}
Node* LinkList::FindForweicha(int data1) {//查找函数

   Node* p = head2;//p指向head2的地址
   if (p == nullptr)
   {

       cout << "空" << endl;
       return nullptr;
   }
   else
   {

       while (p->next != nullptr) {
           if (p->data == data1)
           {

               return p;
           }
           p = p->next;
       }
   }
   if (p->data == data1) {

       return p;
   }
   /*else {
       return nullptr;
   }*/
}
void LinkList::DeleteZhiListForweicha(int data1) {
   Node* ptemp = FindForweicha(data1);
   if (ptemp == nullptr) {
       cout << "Error" << endl;

   }
   else if (ptemp == head2->next) {
       LinkList Link;
       Link.DeleteHeadListForweicha();
       Node* p1 = head2;
       do {
           p1 = p1->next;
           cout << p1->data << " ";
       } while (p1->next != nullptr);
       cout << endl;
   }
   else {
       Node* p = head2;

       while (p->next != ptemp) {
           p = p->next;
       }
       p->next = ptemp->next;
       delete ptemp;
       ptemp = nullptr;
       Node* p1 = head2;
       do {
           p1 = p1->next;
           cout << p1->data << " ";
       } while (p1->next != nullptr);
       cout << endl;

}

void LinkList::JudgeZeng()
{
   Node* p = head2->next, * q;
   if (p)
   {
       while (p->next)
       {
           q = p->next;
           if (q->data > p->data)
               p = q;
           else
               cout << "No";
       }

}
cout << "Yes";
}

void diaoyong();
int main() {
int i;
int zhi, place;

LinkList l1(9);//weicha
LinkList l;

cin >> zhi;

   l1.DeleteZhiListForweicha(zhi);
   cin >> place;
   l1.DeleteAnyListForweicha(place);
   l1.JudgeZeng();
   return 0;

}
void diaoyong()
{

LinkList l1(9);

}