一个链表小程序

最新推荐文章于 2022-08-14 21:06:44 发布
最新推荐文章于 2022-08-14 21:06:44 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： C/C++ 文章标签： null iostream delete cms string class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsh_333/article/details/722532
版权

源程序如下：

＃以下源程序编译环境为VC 2005

**使用链表结构编写此练习**

 

BaseString.h

#pragma once

 

struct Node        // 链表中的节点结构

{

     char item;

     Node * next;

};

    

class BaseString

{

protected:                  // 派生类可以使用这些指针成员

     Node * front;      // 头节点指针

     Node * rear;       // 尾节点指针

     Node * current;        // 当前节点指针

public:

     BaseString(void);

     BaseString(BaseString & bs);

     virtual ~BaseString(void);

 

     BaseString & operator=(BaseString & bs);  // 赋值操作符重载不能定义成friend

 

     void Get();

     void Show();

};

 

BaseString.cpp

#include <iostream>

#include "BaseString.h"

using std::cout;

using std::cin;

using std::endl;

 

BaseString::BaseString(void)

{

     front = NULL;

     rear = NULL;

     current = new Node;

     front = current;   // 设置front指向当前的第一个节点

}

 

BaseString::BaseString(BaseString & bs)        // 自定义复制构造函数（复制链表）

{

     bs.current = bs.front;

     front = NULL;

     rear = NULL;

     current = new Node;

     front = current;

     if (bs.front == bs.rear)             // 只存在一个节点时

     {

         current->item = bs.front->item;

         rear = current;

     }

     else

     {

         while (bs.current != bs.rear)

         {

              current->item = bs.current->item;    // 复制源链表中的数据到新链表中

              rear = new Node;                     // 为新生成的链表申请空间并串接

              rear->next = NULL;

              current->next = rear;

              current = rear;

              bs.current = bs.current->next;

              if (bs.current == bs.rear)

              {

                   current->item = bs.current->item;   

                   current->next = NULL;

                   break;

              }

         }

     }

 

}

 

BaseString::~BaseString(void)

{

     if (rear != NULL)           // 若链表为空则不析构

     {

         Node * temp;

         current = front;

         while(current != rear)

         {

              temp = current;

              current = current->next;

              delete temp;

              if (current == rear)

                   delete current;

         }

     }

}

 

BaseString & BaseString::operator=(BaseString & bs)

{

     if (this == &bs)

         return *this;

     else

     {

         if (rear != NULL)           // 如果此链表不为空

         {

              Node * temp;                // 首先释放掉原先链表占用的空间

              current = front;

              while(current != rear)

              {

                   temp = current;

                   current = current->next;

                   delete temp;

                   if (current == rear)

                       delete current;

              }

         }

         bs.current = bs.front;

         front = NULL;

         rear = NULL;

         current = new Node;

         front = current;

         if (bs.front == bs.rear)

         {

              current->item = bs.front->item;

              rear = current;

         }

         else

         {

              while (bs.current != bs.rear)

              {

                   current->item = bs.current->item;    // 复制源链表中的数据到新链表中

                   rear = new Node;                     // 为新生成的链表申请空间并串接

                   rear->next = NULL;

                   current->next = rear;

                   current = rear;

                   bs.current = bs.current->next;

                   if (bs.current == bs.rear)

                   {

                       current->item = bs.current->item;   

                       current->next = NULL;

                       break;

                   }

              }

         }

         return *this;

     }

}

 

void BaseString::Get()

{

     char c;

     c = cin.get();

     if (c != '/n')

     {

         current->item = c;

         rear = current;             // 只要读入了非'/n'的字符，rear就不为NULL

         c = cin.get();

         while (c != '/n')

         {

              rear = new Node;

              rear->next = NULL;

              current->next = rear;

              current = rear;

              current->item = c;

              c = cin.get();

         }

     }

}

 

void BaseString::Show()

{

     if (rear == NULL)           // 检验是否为空链表

         cout << "**************/nNO INFORMATION/n**************";

     else  if (front == rear)    // 检验是否front,rear同指向一个节点（即此时只有一个节点）

         cout << front->item;

     else

     {

         current = front;

         while (current != rear)

         {

              cout << current->item;

              current = current->next;

              if (current == rear)       

              {

                   cout << current->item;

                   break;

              }

         }

     }

}

 

ReString.h

#pragma once

#include "BaseString.h"

 

class ReString : virtual public BaseString

{

public:

     ReString(void);

     ReString(ReString & bs);

     virtual ~ReString(void);

 

     ReString & operator=(ReString & rs);     

 

     void Reverse();        // 字符反转成员函数

};

 

ReString.cpp

#include <iostream>

#include "ReString.h"      

 

ReString::ReString(void) : BaseString()

{

}

 

ReString::ReString(ReString & bs) : BaseString(bs)

{

}

 

ReString::~ReString(void)

{

}

 

ReString & ReString::operator=(ReString & rs)

{

     if (this == &rs)

         return *this;

     else

     {

         if (rear != NULL)      // 链表不为空

         {

              Node * temp;               

              current = front;

              while(current != rear)

              {

                   temp = current;

                   current = current->next;

                   delete temp;

                   if (current == rear)

                       delete current;

              }

         }

         rs.current = rs.front;

         front = NULL;

         rear = NULL;

         current = new Node;

         front = current;

         if (rs.front == rs.rear)         // 只存在一个节点时

         {

              current->item = rs.front->item;

              rear = current;                  // 使rear不为NULL

         }

         else

         {

              while (rs.current != rs.rear)

              {

                   current->item = rs.current->item;   

                   rear = new Node;                    

                   rear->next = NULL;

                   current->next = rear;

                   current = rear;

                   rs.current = rs.current->next;

                   if (rs.current == rs.rear)

                   {

                       current->item = rs.current->item;   

                       current->next = NULL;

                       break;

                   }

              }

         }

         return *this;

     }

}

 

 

void ReString::Reverse()    // 反转链表

{

     Node * temp = rear;                  // 保存最初链表的rear节点

     if (front != rear)               // 保证链表有两个或两个以上的节点

     {

         while (temp != NULL)             // 保证此链表非空

         {

              current = front;            // 重置当前current指向为链表第一个节点

              if (current->next == rear)  // 判断当前是否为反转最后一个链表节点

              {

                   rear->next = current;

                   rear = current;

                   current->next = NULL;

                   front = temp;

                   break;

              }

              while (current->next != rear)        // 此循环结束时current位于rear-1个节点处

              {

                   current = current->next;

              }                               

              rear->next = current;

              rear = current;                  // 链表反转结束

         }

     }

}

 

CopyString.h

#pragma once

#include "BaseString.h"

 

class CopyString : virtual public BaseString

{

public:

     CopyString(void);

     CopyString(CopyString & cs);

     virtual ~CopyString(void);

 

     CopyString & operator=(CopyString & cs);

 

     void Copy(CopyString & cs);      // 实现字符的copy功能

};

 

CopyString.cpp

#include <iostream>

#include "CopyString.h"

 

CopyString::CopyString(void) : BaseString()

{

}

 

CopyString::CopyString(CopyString & cs) : BaseString(cs)

{

}

 

CopyString::~CopyString(void)

{

}

 

CopyString & CopyString::operator=(CopyString & cs)

{

     if (this == &cs)

         return *this;

     else

     {

         if (rear != NULL)      // 链表不为空     

         {

              Node * temp;               

              current = front;

              while(current != rear)

              {

                   temp = current;

                   current = current->next;

                   delete temp;

                   if (current == rear)

                       delete current;

              }

         }

         cs.current = cs.front;

         front = NULL;

         rear = NULL;

         current = new Node;

         front = current;

         if (cs.front == cs.rear)         // 只存在一个节点时

         {

              current->item = cs.front->item;

              rear = current;

         }

         else

         {

              while (cs.current != cs.rear)

              {

                   current->item = cs.current->item;   

                   rear = new Node;                    

                   rear->next = NULL;

                   current->next = rear;

                   current = rear;

                   cs.current = cs.current->next;

                   if (cs.current == cs.rear)

                   {

                       current->item = cs.current->item;   

                       current->next = NULL;

                       break;

                   }

              }

         }

         return *this;

     }

}

 

void CopyString::Copy(CopyString & cs)

{

     if (cs.rear == NULL)        // 源链表为空

         std::cout << "/nThe Source String is empty!!/n";

     else

     {

         if (rear != NULL)          

              {

                   Node * temp;               

                   current = front;

                   while(current != rear)

                   {

                       temp = current;

                       current = current->next;

                       delete temp;

                       if (current == rear)

                            delete current;

                   }

              }

              cs.current = cs.front;

              front = NULL;

              rear = NULL;

              current = new Node;

              front = current;

              if (cs.front == cs.rear)

              {

                   current->item = cs.front->item;

                   rear = current;

              }

              else

              {

                   while (cs.current != cs.rear)

                   {

                       current->item = cs.current->item;   

                       rear = new Node;                    

                       rear->next = NULL;

                       current->next = rear;

                       current = rear;

                       cs.current = cs.current->next;

                       if (cs.current == cs.rear)

                       {

                            current->item = cs.current->item;   

                            current->next = NULL;

                            break;

                       }

                   }

              }

     }

}

 

    

CmpString.h

#pragma once

#include "BaseString.h"

 

class CmpString : virtual public BaseString

{

public:

     CmpString(void);

     CmpString(CmpString & cms);

     virtual ~CmpString(void);

 

     CmpString & operator=(CmpString & cms);

 

     void Compare(CmpString & cms);       // 进行字符串比较的成员函数

};

 

CmpString.cpp

#include <iostream>

#include "CmpString.h"

 

CmpString::CmpString(void) : BaseString()

{

}

 

CmpString::CmpString(CmpString & cms) : BaseString(cms)

{

}

 

CmpString::~CmpString(void)

{

}

 

CmpString & CmpString::operator=(CmpString & cms)

{

     if (this == &cms)

         return *this;

     else

     {

         if (rear != NULL)           // 链表不为空

         {

              Node * temp;               

              current = front;

              while(current != rear)

              {

                   temp = current;

                   current = current->next;

                   delete temp;

                   if (current == rear)

                       delete current;

              }

         }

         cms.current = cms.front;

         front = NULL;

         rear = NULL;

         current = new Node;

         front = current;

         if (cms.front == cms.rear)       // 只存在一个节点时

         {

              current->item = cms.front->item;

              rear = current;

         }

         else

         {

              while (cms.current != cms.rear)

              {

                   current->item = cms.current->item;  

                   rear = new Node;                    

                   rear->next = NULL;

                   current->next = rear;

                   current = rear;

                   cms.current = cms.current->next;

                   if (cms.current == cms.rear)

                   {

                       current->item = cms.current->item;  

                       current->next = NULL;

                       break;

                   }

              }

         }

         return *this;

     }

}

 

void CmpString::Compare(CmpString & cms)

{

     if (rear == NULL && cms.rear == NULL) // 如果两个链表都为空

         std::cout << "Two Empty Strings!!";

     else

     {

         current = front;

         cms.current = cms.front;

         while (1)

         {

              if ((current == rear && cms.current != cms.rear) || (current != rear && cms.current == cms.rear))

              {

                   std::cout << "The Different Strings!";

                   break;

              }

              if (current->item != cms.current->item)

              {

                   std::cout << "The Different Strings!";

                   break;

              }

              if (current == rear && cms.current == cms.rear)

              {

                   if (current->item == cms.current->item)

                   {

                       std::cout << "The Same Strings!";

                       break;

                   }

                   else

                   {

                       std::cout << "The Different Strings!";

                       break;

                   }

              }

              current = current->next;

              cms.current = cms.current->next;

         }

     }

}

 

 

NewString.h

#include "ReString.h"

#include "CopyString.h"

#include "CmpString.h"

#pragma once

 

class NewString : public ReString, public CopyString, public CmpString

{

public:

     NewString(void);

     NewString(NewString & ns);

     virtual ~NewString(void);

 

     NewString & operator=(NewString & ns);

 

};

 

NewString.cpp

#include <iostream>

#include "NewString.h"

 

NewString::NewString(void) : BaseString(), ReString(), CopyString(), CmpString()    // 由于BaseString是虚基类，所以这里也要调用它的构造函数（无参数）

{

}

 

NewString::NewString(NewString & ns) : BaseString(ns)

{

}

 

NewString::~NewString(void)

{

}

 

NewString & NewString::operator=(NewString & ns)

{

     if (this == &ns)

         return *this;

     else

     {

         if (rear != NULL)           // 链表不为空

         {

              Node * temp;               

              current = front;

              while(current != rear)

              {

                   temp = current;

                   current = current->next;

                   delete temp;

                   if (current == rear)

                       delete current;

              }

         }

         ns.current = ns.front;

         front = NULL;

         rear = NULL;

         current = new Node;

         front = current;

         if (ns.front == ns.rear)         // 只存在一个节点时

         {

              current->item = ns.front->item;

              rear = current;

         }

         else

         {

              while (ns.current != ns.rear)

              {

                   current->item = ns.current->item;   

                   rear = new Node;                    

                   rear->next = NULL;

                   current->next = rear;

                   current = rear;

                   ns.current = ns.current->next;

                   if (ns.current == ns.rear)

                   {

                       current->item = ns.current->item;   

                       current->next = NULL;

                       break;

                   }

              }

         }

         return *this;

     }

}

 

Main.cpp

#include <iostream>

#include "ReString.h"

#include "CopyString.h"

#include "CmpString.h"

#include "NewString.h"

using std::cout;

using std::cin;

using std::endl;

 

int main()

{

     NewString str1;

     cout << "Input String #1:/n";

     str1.Get();

     NewString str2;

     cout << "Input String #2:/n";

     str2.Get();

     cout << "/nCompare the two Strings: ";

     str1.Compare(str2);

     cout << "/n/nReversed String #1:/n";

     str1.Reverse();

     str1.Show();

     cout << "/n/nCopied String #2 to String #1./n";

     str1.Copy(str2);

     cout << "/nString #1:/n";

     str1.Show();

     cout << "/nString #2:/n";

     str2.Show();

     cout << "/n/nCompare the two Strings: ";

     str1.Compare(str2);

     cout << endl << endl;

     return 0;

}

    

辛苦了！！

zsh_333
关注
专栏目录
c语言return 一个链表,关于链表以及函数返回值的有关问题
weixin_34115768的博客
05-19 1588
关于链表以及函数返回值的问题本人新手，最近在学习链表的构建，自己打了如下的程序。但是在编译过程中报错，现实的错误报告如下：linkedlist.c:在函数‘main’中:linkedlist.c:128:10:警告：赋值时将整数赋给指针，未作类型转换[默认启用]head=delete_node(head,b);^/tmp/ccC1e3lL.o：在函数‘main’中：linkedlist...
每日程序C语言45-连接两个链表
星星的博客
02-25 2398
题目： 连接两个链表 程序分析 可以将后面的链表直接接在第一个链表后面，但是注意，删除第二个链表的头结点再进行删除 主要代码 main.c //创建结点类型 typedef struct Node{ int data; struct Node *next; }Node,*LinkList; //打印链表 void print(LinkList L){ L=L->next; while (L) { printf("%3d",L->data); L=L->next; }
链表的小程序
12-11
一些小的有关链表的数据结构，对于初学者应该挺有用，供大家分享
链表写的小程序
xhp513454480的博客
08-25 978
今天没有讲新东西，而是做了一天的题目，下面是用链表写的一个查询成绩的小程序，写的并不好吧： #include #include using namespace std; class student{ public: string name;//学生姓名 int xuehao;//学号 string banji; //班级 int cj;    //成绩 int cj1;
每天一个小程序（1）——链表的创建
h470775422的专栏
03-16 563
单链表的创建 可以用头插法和尾插法，也分带头结点的链表和不带头结点的链表#include #include typedef int datatype; typedef struct lnode { datatype data; struct lnode *next; }LNode,*LinkList; LinkList H; int flag = -1; //头插法创建链表 LinkL
[转载]学生成绩管理系统C源代码
热门推荐
Nest of Nonsenser
01-07 1万+
#include #include #include #define LEN sizeof(struct scorenode)#define DEBUG#include struct scorenode{int number;/*学号*/char name[10];/*姓名*/float yuwen;/*语文成绩*/float yingyu;/*英语成绩*/float shuxue;/*数学成绩
用链表实现的一个小程序（C语言）
To be a Tough Man——liushuaikobe
08-24 1199
这个程序是实现这样一个功能：输入一列整数，输出是把这列数重复出现的数字过滤掉。 例如：输入12 13 12 14 13，输出：12 13 14，用链表实现。 //liushuaikobe1993@163.com #include #include typedef st
写一个程序用链表实现，用来存储学生的学号和成绩，并按分数从低到高排序
yll5201314125的博客
09-17 3297
输出结果： Makefile CC:=gcc OBJS:=student.o main.o CFLAGS:=-c -g RM:= rm -rf test:$(OBJS) $(CC) $^ -o $@ student.o:student.c student.h $(CC) $(CFLAGS) $< -o $@ main.o:main.c $(CC) $(CFLAGS) $< -o $@ .PHONY:clean clean: $(RM) *.o student.h .
将两个有序链表合并
weixin_47988506的博客
08-14 7677
无
两个有序链表合并成一个有序链表
xupengbo527的博客
04-17 9345
算法：两个有序链表合并成一个有序链表（Java实现） 首先我们创建链表的结构类 @Getter @Setter class Node{ private Integer data; //存储数据 private Node next; //后继引用 public Node(Integer data) { this.data = data; } }...
链表小程序
12-02
链表 ，简单对链表的认识，在c的开发环境中运行！
HospitalManager:一个使用链表的程序，允许医院管理患者
07-08
本文将深入探讨一个名为“HospitalManager”的程序，它采用Java语言，利用链表这种数据结构来管理医院的患者信息。 链表是一种基础但非常实用的数据结构，它在内存中不连续存储元素，而是通过节点间的引用关系连接...
数据结构链表部分和queue 结合的一个小程序
11-10
单向链表的每个节点仅有一个指向前一个节点的指针，最后一个节点指向空值（null）表示链表的结束。 队列是一种先进先出（First In First Out, FIFO）的数据结构，类似于现实生活中的排队。在队列中，新元素被添加到...
用链表实现的一个电话本小程序
04-28
电话本小程序是一个基础的编程项目，它展示了如何利用链表数据结构来管理联系人信息。在这个项目中，链表被用来存储姓名、电话号码等关键数据，并提供了添加、删除、修改和查找联系人的功能。这样的设计对于初学者来...
冒泡，选择，快速排序算法比较
诸神的小屋
06-27 4160
#include using namespace std;    void DataInput(int * p, int c);       // 输入函数void DataCopy(int * dest1, int * dest2, int * dest3, int * source, int c); // 复制函数void DataShow(int * p, int c);
单词的存储，查找，替换与删除
诸神的小屋
06-24 1563
#include #include using namespace std; void DataInput(char ** a);                              // 资料输入模块int DataSearch(char * a, char ** b);                    // 单词查找模块void DataReplace(ch
模拟player成绩统计
诸神的小屋
06-04 1273
原始要求：对参赛结果分数进行处理：参赛选手n人（n>1），评委m人（m>2），评委给每一选手打一个分数score（分数score为小于等于10的一个正实数）。选手的最后得分lastScore计算方法为（1）m时，去掉一个最高分和一个最低分后另m-2个得分的平均值。（2）m≥9时，去掉两个最高分和两个最低分后另m-4个得分的平均值。假设事先已经建立了text型的数据文件f1.txt，
一元多项式相加程序实现与链表操作
程序的核心内容包括定义一个链表结构来表示多项式的系数和指数，以及四个主要函数：创建链表、递增排序、多项式相加和显示结果。 1. **定义结点**： 结构`LinkList`被定义用来存储多项式的每个项，包含三个成员...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值