数据结构实验2：C++实现单链表类

太简单了，直接贴题目然后上代码。

题目：

实验2

2.1 实验目的

熟练掌握线性表的链式存储结构。

熟练掌握单链表的有关算法设计。

根据具体问题的需要，设计出合理的表示数据的链式存储结构，并设计相关算法。

2.2 实验要求

本次实验中的链表结构指带头结点的单链表；

单链表结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；

比如存储、算法实现放入文件：linkedList.h

实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；

程序有适当的注释。

2.3 实验任务

编写算法实现下列问题的求解。

<1>尾插法创建单链表，打印创建结果。

<2>头插法创建单链表，打印创建结果。

<3>销毁单链表。

<4>求链表长度。

<5>求单链表中第i个元素（函数），若不存在，报错。

实验测试数据基本要求：

第一组数据：单链表长度n≥10，i分别为5，n，0，n+1，n+2

第二组数据：单链表长度n=0，i分别为0，2

<6>在第i个结点前插入值为x的结点。

实验测试数据基本要求：

第一组数据：单链表长度n≥10，x=100,  i分别为5,n,n+1,0,1,n+2

第二组数据：单链表长度n=0，x=100，i=5

<7>链表中查找元素值为x的结点，成功返回结点指针，失败报错。

实验测试数据基本要求：

单链表元素为（1，3，6，10，15，16，17，18，19，20）

x=1，17，20，88

<8>删除单链表中第i个元素结点。

实验测试数据基本要求：

第一组数据：单链表长度n≥10，i分别为5,n,1,n+1,0

第二组数据：单链表长度n=0， i=5

<9>在一个递增有序的单链表L中插入一个值为x的元素，并保持其递增有序特性。

实验测试数据基本要求：

单链表元素为（10,20,30,40,50,60,70,80,90,100）,

x分别为25，85，110和8

<10>将单链表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的单链表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。

实验测试数据基本要求：

第一组数据：单链表元素为（1,2,3,4,5,6,7,8,9,10,20,30,40,50,60）

第二组数据：单链表元素为（10,20,30,40,50,60,70,80,90,100）

代码：

 // stdafx.h : include file for standard system include files,
 //  or project specific include files that are used frequently, but
 //      are changed infrequently
 //

 #if !defined(AFX_STDAFX_H__195DB73A_A23D_4A80_A4F5_2F4FC5141CBC__INCLUDED_)
 #define AFX_STDAFX_H__195DB73A_A23D_4A80_A4F5_2F4FC5141CBC__INCLUDED_

 #if _MSC_VER > 1000
 #pragma once
 #endif // _MSC_VER > 1000

 #include <stdc++.h>

 using namespace std;

 typedef int elementType;
 typedef struct node
 {
     elementType data;
     node* next;
 }LList, *PList;

 // TODO: reference additional headers your program requires here

 //{{AFX_INSERT_LOCATION}}
 // Microsoft Visual C++ will insert additional declarations immediately before the previous line.

 #endif // !defined(AFX_STDAFX_H__195DB73A_A23D_4A80_A4F5_2F4FC5141CBC__INCLUDED_)

 // linkedList1.h: interface for the linkedList class.
 //
 //////////////////////////////////////////////////////////////////////

 #if !defined(AFX_LINKEDLIST1_H__4C3F34C9_D36C_43D6_97CF_A8E55FD6BD7D__INCLUDED_)
 #define AFX_LINKEDLIST1_H__4C3F34C9_D36C_43D6_97CF_A8E55FD6BD7D__INCLUDED_

 #if _MSC_VER > 1000
 #pragma once
 #endif // _MSC_VER > 1000

 #include "StdAfx.h"

 using namespace std;

 class linkedList
 {
 public:
     linkedList();//构造函数
     virtual ~linkedList();//析构函数，销毁单链表
     bool createLinkedListRail( int length );//尾插法构建单链表
     bool createLinkedListFront( int length );//头插法构建单链表
     void addLinkedListNodeLast( int value );//警告：必须初始化才能使用！
     //我尝试判断调用对象的链表是否初始化来作为是否调用该函数的依据，结果失败：无论如何判断，总是不能在零节点时插入
     bool initiateLinkedList();//初始化单链表
     bool isEmpty();//判断单链表是否为空
     bool getElementByPosition( int pos, int& value );//求单链表中第pos个元素（函数），若不存在，报错
     bool insertListByPosition( int pos, int value );//在第pos个结点前插入值为value的结点
     bool getElementByValue( int& pos, int value );//链表中查找元素值为x的结点，成功返回结点指针，失败报错。
     bool removeListNodeByPosition( int pos, int& value );//删除单链表中第pos个元素结点
     bool insertListSort( int value );//在一个递增有序的单链表L中插入一个值为value的元素，并保持其递增有序特性
     bool oddEvenSort( linkedList& LA,linkedList& LB );//将调用单链表中的元素按奇偶性分配給被调用的单链表LA与LB
     void printLinkedList();//打印单链表
     int linkedListLength();//返回单链表长度
 private:
     LList *head;
     int len;
 };

 #endif // !defined(AFX_LINKEDLIST1_H__4C3F34C9_D36C_43D6_97CF_A8E55FD6BD7D__INCLUDED_)

 // linkedList1.cpp: implementation of the linkedList class.
 //
 //////////////////////////////////////////////////////////////////////

 #include "stdafx.h"
 #include "linkedList1.h"

 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////

 linkedList::linkedList()
 {
     head = NULL;
     len = ;
 }

 linkedList::~linkedList()
 {
     LList* tmp = head;
     //for( int i = 0; i < len; i ++ )
     while( tmp->next )
     {
         LList *q = tmp;
         tmp = tmp->next;
         delete q;
     }
 }

 bool linkedList::initiateLinkedList()
 {
     std::ios::sync_with_stdio(false);
     head = new LList;
     if( !head )
     {
         cout << "初始化失败！" << endl;
         return false;
     }
     head->next = NULL;
     return true;
 }

 bool linkedList::createLinkedListRail( int length )
 {
     std::ios::sync_with_stdio(false);
     initiateLinkedList();
     LList* rail = head;
     for( int i = ; i <= length; i ++ )
     {
         LList* tmp = new LList;
         int num;
         cin >> num;
         //num = i + 1;
         tmp->data = num;
         tmp->next = rail->next;
         rail->next = tmp;
         rail = tmp;
         len ++;
     }
     return true;
 }

 bool linkedList::createLinkedListFront( int length )
 {
     std::ios::sync_with_stdio(false);
     initiateLinkedList();
     for( int i = ; i < length; i ++ )
     {
         int num;
         cin >> num;
         //num = i + 1;
         LList* tmp = new LList;
         tmp->data = num;
         tmp->next = head->next;
         head->next = tmp;
         len ++;
     }
     return true;
 }

 void linkedList::addLinkedListNodeLast( int value )
 {
     //ios::sync_with_stdio(false);

     LList* tmp = head;
     LList* last = NULL;
     while(tmp)
     {
         last = tmp;
         tmp = tmp->next;
     }
     LList* PNew = new LList;
     PNew->data = value;
     PNew->next = NULL;
     last->next = PNew;
     len ++;
 }

 bool linkedList::isEmpty()
 {
     return head->next == NULL;
 }

 void linkedList::printLinkedList()
 {
     std::ios::sync_with_stdio(false);
     if( isEmpty() )
     {
         cout << "空链表，无法打印！" << endl;
         return;
     }
     LList* tmp = head->next;
     int column = ;
     while(tmp)
     {
         cout << setiosflags(ios::left) << setw() << tmp->data << " ";
         column ++;
         if( column %  ==  )
             cout << endl;
         tmp = tmp->next;
     }
     cout << endl;
 }

 int linkedList::linkedListLength()
 {
     if( isEmpty() )
     {
         cout << "空链表！" << endl;
         return -;
     }
     int l = ;
     LList* tmp = head->next;
     while(tmp)
     {
         tmp = tmp->next;
         l ++;
     }
     return l;
     //return len;
 }

 bool linkedList::getElementByPosition( int pos, int& value )
 {
     ios::sync_with_stdio(false);
     if( isEmpty() )
     {
         cout << "链表为空！获取元素失败！" << endl;
         return false;
     }
     if( pos > len )
     {
         cout << "位置大于表长！获取元素失败！" << endl;
         return false;
     }
     if( pos <=  )
     {
         cout << "位置必须大于0！获取元素失败！" << endl;
         return false;
     }
     int index = ;
     LList* tmp = head;
     while(tmp)
     {
         if( index == pos )
         {
             //cout << tmp->data;
             value = tmp->data;
             return true;
         }
         tmp = tmp->next;
         index ++;
     }
     return true;
 }

 bool linkedList::insertListByPosition( int pos, int value )
 {
     ios::sync_with_stdio(false);
     if( isEmpty() )
     {
         cout << "链表为空！插入元素失败！" << endl;
         return false;
     }
     else if( pos > len )
     {
         cout << "位置大于表长且差值大于1！删除元素失败！" << endl;
         return false;
     }
     else if( pos == len )
     {
         cout << "将会直接把新节点接在链表尾部！" << endl;
         addLinkedListNodeLast( value );
         return true;
     }
     else if( pos <=  )
     {
         cout << "位置必须大于0！插入元素失败！" << endl;
         return false;
     }
     int index = ;
     LList* tmp = head;
     while( index != pos -  && tmp )
     {
         index ++;
         tmp = tmp->next;
     }
     if( tmp == NULL )
     {
         cout << "位置大于表长且不在表长的后一位！插入元素失败！" << endl;
         return false;
     }
     LList* PNew = new LList;
     PNew->data =  value;
     PNew->next = tmp->next;
     tmp->next = PNew;
     len ++;
     return true;
 }

 bool linkedList::getElementByValue( int& pos, int value )
 {
     ios::sync_with_stdio(false);
     if( isEmpty() )
     {
         cout << "链表为空！获取元素失败！" << endl;
         return false;
     }
     int index = ;
     LList* tmp = head->next;
     while(tmp)
     {
         if( tmp->data == value )
         {
             pos = index;
             return true;
         }
         tmp = tmp->next;
         index ++;
     }
     return false;
 }

 bool linkedList::removeListNodeByPosition( int pos, int& value )
 {
     ios::sync_with_stdio(false);
     if( isEmpty() )
     {
         cout << "链表为空！删除元素失败！" << endl;
         return false;
     }
     if( pos > len )
     {
         cout << "位置大于表长！删除元素失败！" << endl;
         return false;
     }
     if( pos <=  )
     {
         cout << "位置必须大于0！删除元素失败！" << endl;
         return false;
     }
     LList* tmp = head;
     int index = ;
     while( index != pos -  && tmp )
     {
         tmp = tmp->next;
         index ++;
     }
     LList* PDel = tmp->next;
     value = PDel->data;
     tmp->next = tmp->next->next;
     delete PDel;
     len --;
     return true;
 }

 bool linkedList::insertListSort( int value )
 {
     ios::sync_with_stdio(false);
     if( isEmpty() )
     {
         cout << "链表为空！插入元素失败！" << endl;
         return false;
     }
     LList* tmp = head;
     while( tmp->next && tmp->next->data < value )//下一个节点的data比value小就继续循环
     //写成下面这样导致比最后一个节点的data大的value无法插入！因为循环结束时tmp->next为NULL，无法插入。
     //while( tmp && tmp->next->data < value )
     {
         //if( tmp->data < value )
             tmp = tmp->next;
     }
     LList* PNew = new LList;
     PNew->data = value;
     PNew->next = tmp->next;
     tmp->next = PNew;
     return true;
 }

 bool linkedList::oddEvenSort( linkedList& LA,linkedList& LB )
 {
     ios::sync_with_stdio(false);
     if( isEmpty() )
     {
         cout << "原链表为空！分配元素失败！" << endl;
         return false;
     }
     //if( !LA.head->next && !LB.head->next )
     if( !LA.head && !LB.head )
     {
         LA.initiateLinkedList();
         LB.initiateLinkedList();
     }
     LList* tmp = head->next;
     while(tmp)
     {
         if( tmp->data >=  && ( tmp->data &  ) )
             LA.addLinkedListNodeLast( tmp->data );
         //else if( tmp->data >= 0 && !( tmp->data & 1 ) )
         else
             LB.addLinkedListNodeLast( tmp->data );
         tmp = tmp->next;
     }
     return true;
 }

 // LinkedList.cpp : Defines the entry point for the console application.
 //

 #include "stdafx.h"
 #include "linkedList1.h"

 int main(int argc, char* argv[])
 {
     ios::sync_with_stdio(false);
     freopen( "1.in", "r", stdin );

     linkedList L1;//, L2;
     int n;
     cin >> n;
     L1.createLinkedListFront(n);
     cout << "原表表长为：" << endl;
     cout << L1.linkedListLength() << endl;
     cout << "原表元素为：" << endl;
     L1.printLinkedList();
     /*
     L1.~linkedList();
     cout << "现表表长为：" << endl;
     cout << L1.linkedListLength() << endl;
     cout << "现表元素为：" << endl;
     L1.printLinkedList();
     //L2.createLinkedListFront(5);
     //cout << L2.linkedListLength() << endl;
     //L2.printLinkedList();
     22
     30 70 92 91 15 47 84 10 43 34 9 62 60 26 79 96 38 4 92 24 25 5

     linkedList L3;
     int n;
     cin >> n;
     L3.createLinkedListRail(n);
     cout << "原表表长为：" << endl;
     cout << L3.linkedListLength() << endl;
     cout << "原表元素为：" << endl;
     L3.printLinkedList();//5，n，0，n+1，n+2

     int value = -100;
     int num;
     cin >> num;
     for( int i = 0; i < num; i ++ )
     {
         int pos;
         cin >> pos;
         if( L3.getElementByPosition( pos, value ) )
         {
             cout << "第 " << pos << " 个元素的值为：" << value << endl;

         }
         else
             cout << "不存在位置为 " << pos << " 的元素！" << endl;
     }

     linkedList L4;
     int n;
     cin >> n;
     L4.createLinkedListRail(n);
     cout << "原表表长为：" << endl;
     cout << L4.linkedListLength() << endl;
     cout << "原表元素为：" << endl;
     L4.printLinkedList();//x=100,  i分别为5,n,n+1,0,1,n+2
     int value = 100;
     int num;
     cin >> num;
     for( int i = 0; i < num; i ++ )
     {
         int pos;
         cin >> pos;
         if( L4.insertListByPosition( pos, value ) )
         {
             cout << "value = " << value << " 的值已插在 pos = " << pos << "的位置上！" << endl;
             cout << "现表表长为：" << endl;
             cout << L4.linkedListLength() << endl;
             cout << "现表元素为：" << endl;
             L4.printLinkedList();
         }
     }

     linkedList L5;
     int n;
     cin >> n;
     L5.createLinkedListRail(n);
     cout << "原表表长为：" << endl;
     cout << L5.linkedListLength() << endl;
     cout << "原表元素为：" << endl;
     L5.printLinkedList();
     int index = -1;
     //1，17，20，88
     for( int i = 0; i < 4; i ++ )
     {
         int value;
         cin >> value;
         if( L5.getElementByValue( index, value ) )
         {
             cout << "pos = " << index << ", value = " << 1 << endl;
         }

         else
         {
             cout << "链表中不存在值为 " << value << " 的值" << endl;
         }
     }

     linkedList L6;
     int n;
     cin >> n;
     L6.createLinkedListRail(n);
     L6.printLinkedList();
     cout << L6.linkedListLength() << endl;
     int value = -1;
     //5,n,1,n+1,0
     if( L6.removeListNodeByPosition( 5, value ) )
     {
         cout << "pos = " << 5 << ", value = " << value << "已删除！" << endl;
     }
     L6.printLinkedList();
     if( L6.removeListNodeByPosition( n , value ) )
     {
         cout << "pos = " << n << ", value = " << value << "已删除！" << endl;
     }
     else
     {
         cout << "不存在位置等于 " << n << " 的元素！" << endl;
     }
     L6.printLinkedList();
     if( L6.removeListNodeByPosition( 1, value ) )
     {
         cout << "pos = " << 1 << ", value = " << value << "已删除！" << endl;
     }
     L6.printLinkedList();
     if( L6.removeListNodeByPosition( n + 1, value ) )
     {
         cout << "pos = " << n + 1 << ", value = " << value << "已删除！" << endl;
     }
     else
     {
         cout << "不存在位置等于 " << n + 1 << " 的元素！" << endl;
     }
     L6.printLinkedList();
     if( L6.removeListNodeByPosition( 0, value ) )
     {
         cout << "pos = " << 0 << ", value = " << value << "已删除！" << endl;
     }
     else
     {
         cout << "不存在位置等于 " << 0 << " 的元素！" << endl;
     }
     L6.printLinkedList();

     linkedList L7;
     int n;
     cin >> n;
     L7.createLinkedListRail(n);
     cout << "原表表长为：" << endl;
     cout << L7.linkedListLength() << endl;
     cout << "原表元素为：" << endl;
     L7.printLinkedList();

     //int value = -1;
     //5,n,1,n+1,0
     for( int i = 0; i < 1; i ++ )
     {
         int value;
         cin >> value;
         if( L7.removeListNodeByPosition( 5, value ) )
         {
             cout << "pos = " << 5 << ", value = " << value << "已删除！" << endl;
             cout << "现表表长为：" << endl;
             cout << L7.linkedListLength() << endl;
             cout << "现表元素为：" << endl;
             L7.printLinkedList();
         }
         if( L7.removeListNodeByPosition( n , value ) )
         {
             cout << "pos = " << n << ", value = " << value << "已删除！" << endl;
         }
         else
         {
             cout << "不存在位置等于 " << n << " 的元素！" << endl;
         }
     }

     linkedList L8;
     int n;
     cin >> n;
     L8.createLinkedListRail(n);
     cout << "原表表长为：" << endl;
     cout << L8.linkedListLength() << endl;

     cout << "原表元素为：" << endl;
     L8.printLinkedList();
     int value;
     for( int i = 0; i < 4; i ++ )
     {
         cin >> value;
         if( L8.insertListSort(value) )
         {
             cout << "插入元素 " << value << " 后表长为：" << endl;
             cout << L8.linkedListLength() << endl;
             cout << "插入元素 " << value << " 表元素为：" << endl;
             L8.printLinkedList();
         }
         else
             cout << "Error!" << endl;
     }

     int n;
     linkedList L9, LA, LB;
     cin >> n;
     L9.createLinkedListRail(n);
     //LA.initiateLinkedList(), LB.initiateLinkedList();
     cout << "原链表表长为：" << endl;
     cout << L9.linkedListLength() << endl;
     cout << "原链表元素为：" << endl;
     L9.printLinkedList();
     L9.oddEvenSort( LA, LB );
     cout << "奇数链表表长为：" << endl;
     cout << LA.linkedListLength() << endl;
     cout << "奇数链表元素为：" << endl;
     LA.printLinkedList();
     cout << "偶数链表表长为：" << endl;
     cout << LB.linkedListLength() << endl;
     cout << "偶数链表元素为：" << endl;
     LB.printLinkedList();
     */
     return ;
 }

图1 测试（1）

图2 测试（2）

图3 测试（3）

图4 测试（4）

图5 测试（5）

图6 测试（5）

图7 测试（6）

图8 测试（6）

图9 测试（7）

图10 测试（8）

图11 测试（8）

图12 测试（9）

图13 测试（10）

图14 测试（10）