devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构-单链表（带头结点与不带头结点表示）

作者：小丑西瓜9 | 2024-04-30 22:31:00

赞

踩

数据结构-单链表（带头结点与不带头结点表示）

概念

一、单链表是什么？

单链表是线性表的链式存取结构；是用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的；

  • 结点结构：

  • 申请新的结点：s = new Node<int> ;

二、带头结点与不带头结点的单链表，在进行操作时的区别

  • 当对单链表的表首元素进行删除或插入操作时，要进行区别处理，无头结点的单链表进行头指针的更新。（对表头特殊处理）

  • 带头结点的单链表，无论单链表是否为空链表，头指针都指向头结点。不带头结点的单链表，当单链表为非空链表时，头指针指向链表第一个结点(head)，当单链表为空链表时，头指针指向空（NULL）。

创建单链表

1.结点结构
  1.  //创建结点
  2. template<classT>
  3. struct Node {
  4.       T data;
  5.       Node<T> *next;
  6.  };
  1. LinkList模板类
  1. template<classT>
  2. class LinkList
  3.  {
  4.       Node<T> *first,*rear,*p,*s,*q;   //一般情况头指针用*first
  5.                                         // 带结点单链表中头结点用*head
  6.  public:
  7.       LinkList();
  8.       LinkList(Ta[], intn);
  9.       ~LinkList();
  10.       int Length();     //求链表长度
  11.       T Get(intpos);   //按值查找
  12.       void Insert(inti, Titem);
  13.       void HeadInsert(Ta[], intn);   //头插法
  14.       void TailInsert(Ta[], intn);   //尾插法
  15.       void Insert(inti, Titem);
  16.       void Detele(inti);
  17.       int CountX(Tdata);
  18.       void PrintLinkList();   //遍历单链表
  19.  };

3. 构造函数
  • 图解

  • 带头结点
  1. //头指针指向的结点为该单链表的头结点
  2.  template<classT>
  3.  LinkList<T>::LinkList()  //无参构造函数
  4.  {
  5.       head=new Node<T>;  //声明一个头结点
  6.       head->next=NULL;   //头结点指向的首结点为空
  7.  }
  8.  template<classT>
  9.  LinkList<T>::LinkList(Ta[], intn)   //有参构造函数
  10.  {
  11.       Node<T>*s;
  12.       Node<T>*head=new Node<T>;   //创建头结点
  13.       rear=head;
  14.       for (inti=0; i<n; i++) {
  15.            s=new Node<T>;    //申请新结点
  16.            s->data=a[i];
  17.            rear->next=s;
  18.            rear=s;
  19.       }
  20.       rear->next=NULL;
  21.  }
  • 不带头结点
  1. //头指针指向的结点为该单链表的首结点
  2.  template<classT>   //无参构造函数 
  3.  LinkList<T>::LinkList()
  4.  {
  5.       first=new Node<T>;  //头指针指向新节点 
  6.       first=NULL;   //首结点数据为空 
  7.  }
  8.  ​
  9.  template<classT>
  10.  LinkList<T>::LinkList(Ta[], intn) {
  11.       Node<T>*s=new Node<T>;   //建立新结点指针 
  12.       first=s;       //头指针指向新结点 s
  13.       Node<T>*rear=first;  // rear指向首结点 
  14.       for (inti=0; i<n; i++) {
  15.            s=newNode<T>;   //新结点 
  16.            s->data=a[i];
  17.            rear->next=s;    //插入 s 
  18.            rear=s;      // s为尾结点 
  19.       }
  20.       rear->next=NULL;  //尾结点next设为空 
  21.  }
4.析构函数
  1.  template<classT>
  2.  LinkList<T>::~LinkList() {
  3.       Node<T>*rear=first;  // 头指针赋值给尾结点 
  4.       while (rear) {   //当结点指针不为零 
  5.            Node<T>*q=rear;   // Node<T> *q = first;
  6.            rear=rear->next;  //尾指针rear 递推 ， 最后rear=NULL 
  7.            deleteq;
  8.       }
  9.       first=NULL;  //当结点指针为零 ,则为空 
  10.  }
5. 头插法建表

[] 将待插入结点插在头结点的后面

  • 带头结点 
  1.  template<classT>
  2.  LinkList<T>::~LinkList() {
  3.       Node<T>*rear=first;  // 头指针赋值给尾结点 
  4.       while (rear) {   //当结点指针不为零 
  5.            Node<T>*q=rear;   // Node<T> *q = first;
  6.            rear=rear->next;  //尾指针rear 递推 ， 最后rear=NULL 
  7.            deleteq;
  8.       }
  9.       first=NULL;  //当结点指针为零 ,则为空 
  10.  }
  1.  template<classT>
  2.  void LinkList<T>::HeadInsert(Ta[], intn) {
  3.      head=new Node<T>;
  4.      head->next=NULL;
  5.       for (inti=0; i<n; i++) {
  6.  //生成新结点
  7.  //链接在头结点和首结点之间
  8.            s=newNode<T>;
  9.            s->data=a[i];
  10.            s->next=head->next;
  11.            head->next=s;
  12.       }
  13.  }
  • 不带头结点
  1.  //插入到第一个位置
  2.  s->next=first;
  3.  first=s;
  4.  ​
  5.  //插入到其他位置
  6.  //rear = 插入之前的结点;
  7.  s->next=rear->next;
  8.  rear->next=s;
  1.  template<classT>
  2.  void LinkList<T>::HeadInsert(Ta[], intn) {
  3.       for (inti=0; i<n; i++) {   
  4.           rear=first;    // rear指针指向原首元结点地址first 
  5.           s=new Node<T>; //新结点 s
  6.            s->data=a[i];
  7.            if (i==0) {   
  8.                 s->next=NULL;   // 头插法数组第一个元素最终为表尾元素
  9.            }
  10.           else {
  11.               s->next=rear;   //在尾部加上新结点 s  
  12.          }
  13.          first=s;  // 头指针指向 s， s为首元结点 (更新头指针) 
  14.      } 
  15.  }
6. 尾插法建表

[将待插入结点插在终端结点的后面]

  • 带头结点 
  1.  template<classT>
  2.  void LinkList<T>::TailInsert(Ta[], intn) {
  3.       rear=head;
  4.       for (inti=0; i<n; i++) {
  5.  //生成新结点
  6.  //链接在尾结点后面
  7.  //尾结点后移
  8.            s=new Node<T>;
  9.            s->data=a[i];
  10.            rear->next=s;
  11.            rear=s;
  12.       }
  13.       rear->next=NULL;
  14.  }
  • 不带头结点
  1.  template<classT>
  2.  void LinkList<T>::TailInsert(Ta[], intn)
  3.   { 
  4.      rear=first;    // rear指针指向原首元结点地址first 
  5.      for (inti=0; i<n; i++) {   
  6.            s=new Node<T>; //新结点 s
  7.            s->data=a[i];
  8.            s->next=NULL; 
  9.            if(i==0){
  10.                 first=s ;   // 如果当前是第一个元素则将头指针指向当前节点
  11.            }
  12.           else {
  13.               rear->next=s;   //在尾部加上新结点 s 
  14.               rear=s;    // s 变为尾结点 
  15.          }
  16.          rear=s;
  17.          rear->next=NULL;  //尾结点 next为空 
  18.      }
  19.  }

7.插入（后插）

[] 在第 i个位置插入元素 item

  • 带头结点
  1.  template<classT>
  2.  void LinkList<T>::Insert(inti, Titem) {
  3.       p=head;
  4.       int j=0;
  5.       while (p&&j<i-1) {
  6.            p=p->next;
  7.            j++;
  8.       }
  9.       if (!p||i==0) {
  10.            cerr<<"插入位置非法。";
  11.            exit(1);
  12.       }
  13.      s=newNode<T>;
  14.       s->data=item;
  15.       s->next=p->next;
  16.       p->next=s;
  17.  }
  • 不带头结点
  1.  template<classT>
  2.  void LinkList<T>::Insert(inti, Titem) {
  3.       Node<T>*p=first;   // p指向首元结点 
  4.       Node<T>*s=new Node<T>;
  5.       if(i==1){   //插入第1个结点的操作
  6.            s->data=item;
  7.           s->next=first;   //将 s放到first(首元素)前面 
  8.           first=s;   //头指针指向 s (更改头指针) 
  9.       }
  10.      else {  
  11.       intj=1;  //第二个元素开始 
  12.       while (p&&j<i-1) {   //找到插入元素位置的前驱结点 
  13.            p=p->next;
  14.            j++;
  15.       }
  16.       if (!p||i==0) {
  17.            cerr<<"插入位置非法。";
  18.            exit(1);
  19.          }
  20.       s->data=item;
  21.       s->next=p->next;   // s->next为第 i个元素地址
  22.       p->next=s;    // 第 i-1元素 next为新元素 s 
  23.      }
  24.  }

8.求链表长度
  1. //带头结点
  2. template<classT>
  3. int LinkList<T>::Length() {
  4.       p=head->next;       //不带头结点：p = first;
  5.       int num=0;
  6.       while (p) {
  7.            p=p->next;
  8.            num++;
  9.       }
  10.       return num;
  11.  }

9.查找

  • 按位查找

  1.  //根据位置获取元素 
  2. template <class T>
  3. T LinkList<T>::Get(int pos)
  4.  {
  5.       p = head->next;
  6.       int j=1;
  7.       while(p&&j<pos) {
  8.            p=p->next;
  9.            j++;
  10.       }
  11.       if(!p||j>pos) {
  12.            cerr<<"查找位置非法"<<endl; 
  13.            exit(1);
  14.       }
  15.       else {
  16.            return p->data; 
  17.       } 
  18.  }

  • 按值查找

  1.  //寻找某元素的位置 
  2. template <class T>
  3. int LinkList<T>::Locate(T item) {
  4.       p = head->next;
  5.       int j=1;
  6.       while(p&&p->data!=item) {
  7.            p=p->next;
  8.            j++;
  9.        } 
  10.        if(p) {
  11.           return j;
  12.        }
  13.        else {
  14.           return 0;
  15.        }
  16.  }

10.遍历单链表
  1. //带头结点
  2. template<classT>
  3. void LinkList<T>::PrintLinkList() {
  4.      p=head->next;    //不带头结点 p = first;
  5.      if(!p){   //空链表 
  6.           cout<<"The LinkList is empty !"<<endl;
  7.      }
  8.      else{
  9.          cout<<"LinkList: " ;
  10.      while (p) {   // p不为NULL时依次输出 
  11.               cout<<p->data ;
  12.               if(p->next!=NULL)    {  cout<<",";     }
  13.              p=p->next;
  14.         }
  15.       }
  16.      cout<<endl;
  17.  }

完整代码及实例

LinkList.h
带头结点
  1.  #include<iostream>
  2.  using namespace std;
  3.  ​
  4.  template<classT>
  5.  structNode {
  6.       Tdata;
  7.       Node<T>*next;
  8.  }; 
  9. template<classT>
  10. class LinkList
  11.  {
  12.       Node<T> *head,*rear,*q,*p,*s;
  13.  public:
  14.       LinkList();
  15.       LinkList(Ta[], intn);
  16.       ~LinkList();
  17.       int Length();
  18.       T Get(intpos);
  19.      int CountX(Tdata);
  20.       void PrintLinkList();
  21.       void HeadInsert(Ta[], intn);
  22.       void TailInsert(Ta[], intn);
  23.       void Insert(inti, Titem);
  24.       void Detele(inti);
  25.  ​
  26.  };
  27.  ​
  28. template<classT>
  29. LinkList<T>::LinkList()
  30.  {
  31.       head=new Node<T>;
  32.       head->next=NULL; 
  33.  }
  34.  ​
  35. template<classT>
  36. LinkList<T>::LinkList(Ta[], intn) {
  37.       Node<T>*s;
  38.       head=new Node<T>;
  39.       rear=head;
  40.       for (inti=0; i<n; i++) {
  41.            s=new Node<T>;
  42.            s->data=a[i];
  43.            rear->next=s;
  44.            rear=s;
  45.       }
  46.       rear->next=NULL;
  47.  }
  48.  ​
  49. template<classT>
  50. LinkList<T>::~LinkList() {
  51.       p=head;
  52.       while (p) {
  53.            q=p;
  54.            p=p->next;
  55.            deleteq;
  56.       }
  57.       head=NULL;
  58.  }
  59.  ​
  60. template<classT>
  61. int LinkList<T>::Length() {
  62.       p=head->next;
  63.       int num=0;
  64.       while (p) {
  65.            p=p->next;
  66.            num++;
  67.       }
  68.       return num;
  69.  }
  70.  ​
  71. template<classT>
  72. T LinkList<T>::Get(intpos) {
  73.       p=head->next;
  74.       int j=1;
  75.       while (p&&j<pos) {
  76.            p=p->next;
  77.            j++;
  78.       }
  79.       if (!p||j>pos)
  80.       {
  81.            cerr<<"查找位置非法。";
  82.            exit(1);
  83.       }
  84.       else return p->data;
  85.  }
  86.  ​
  87. template<classT>
  88. int LinkList<T>::CountX(Tdata) {
  89.       int count=0;
  90.       p=head->next;
  91.       intj=0;
  92.       while(p)
  93.      {
  94.           if(p->data==data) {
  95.              count++;
  96.          }
  97.            p=p->next;
  98.      }
  99.      return count;
  100.  }
  101.  ​
  102. template<classT>
  103. void LinkList<T>::Insert(inti, Titem) {
  104.       p=head;
  105.       intj=0;
  106.       while (p&&j<i-1) {
  107.            p=p->next;
  108.            j++;
  109.       }
  110.       if (!p||i==0) {
  111.            cerr<<"插入位置非法。";
  112.            exit(1);
  113.       }
  114.      s=new Node<T>;
  115.       s->data=item;
  116.       s->next=p->next;
  117.       p->next=s;
  118.  }
  119.  ​
  120. template<classT>
  121. voidLinkList<T>::HeadInsert(Ta[], intn) {
  122.      head=new Node<T>;
  123.       for (inti=0; i<n; i++) {
  124.            s=new Node<T>;
  125.            s->data=a[i];
  126.            s->next=head->next;
  127.            head->next=s;
  128.       }
  129.  }
  130.  ​
  131. template<classT>
  132. void LinkList<T>::TailInsert(Ta[], intn) {
  133.       rear=head;
  134.       for (inti=0; i<n; i++) {
  135.            s=new Node<T>;
  136.            s->data=a[i];
  137.            rear->next=s;
  138.            rear=s;
  139.       }
  140.       rear->next=NULL;
  141.  }
  142.  ​
  143. template<classT>
  144. void LinkList<T>::Detele(inti) {
  145.       p=head;
  146.       intj=0;
  147.       while (p&&j<i-1) {
  148.            p=p->next;
  149.            j++;
  150.       }
  151.       if (!p||!p->next||i==0) {
  152.            cerr<<"删除位置非法。";
  153.            exit(1);
  154.       }
  155.       else
  156.       {
  157.            q=p->next;
  158.            //T x = q->data;
  159.            cout<<q->data<<endl;
  160.            p->next=q->next;
  161.            delete q;
  162.       }
  163.  }
  164.  ​
  165. template<classT>
  166. void LinkList<T>::PrintLinkList() {
  167.       p=head->next;
  168.       if(!p){
  169.            cout<<"The LinkList is empty !"<<endl;
  170.       }
  171.       else{
  172.           cout<<"LinkList: " ;
  173.       while (p) {
  174.                cout<<p->data ;
  175.               if(p->next!=NULL)     {  cout<<",";     }
  176.               p=p->next;
  177.          }
  178.  }
  179.       cout<<endl;
  180.  }

不带头结点

  1. #include<iostream>
  2. using namespace std;
  3.  ​
  4. template<classT>
  5. struct Node {
  6.       T data;
  7.       Node<T> *next;
  8. }; 
  9.  ​
  10. template<classT>
  11. class LinkList
  12. {
  13.       Node<T> *first,*rear,*p,*s,*q;
  14.  public:
  15.       LinkList();
  16.       LinkList(Ta[], intn);
  17.       ~LinkList();
  18.       int Length();
  19.       T Get(intpos);
  20.       int CountX(Tdata);
  21.       void PrintLinkList();
  22.       void HeadInsert(Ta[], intn);
  23.       void TailInsert(Ta[], intn);
  24.       void Insert(inti, Titem);
  25.       void Detele(inti);
  26.  ​
  27. };
  28.  ​
  29. template<classT>  //无参构造函数 
  30. LinkList<T>::LinkList()
  31. {
  32.      first=new Node<T>;  //头指针指向新节点 
  33.      first=NULL;   //新节点数据为空 
  34. }
  35.  ​
  36. template<classT>
  37. LinkList<T>::LinkList(Ta[], intn) {
  38.      Node<T> *s=new Node<T>;   //建立新结点指针 
  39.      first=s;       //头指针指向新结点 s
  40.      Node<T> *rear = first;  // 头指针赋值给尾结点 
  41.      for (inti=0; i<n; i++) {
  42.           s = new Node<T>;   //新结点 
  43.           s->data=a[i];
  44.           rear->next = s;    //插入 s 
  45.           rear = s;      // s为尾结点 
  46.       }
  47.      rear->next = NULL;  //尾结点next设为空 
  48.  }
  49.  
  50. template<classT>
  51. LinkList<T>::~LinkList() {
  52.      Node<T> *rear = first;  // 头指针赋值给尾结点 
  53.      while (rear) {   //当结点指针不为零 
  54.           Node<T> *q = rear;   // Node<T> *q = first;
  55.           rear = rear->next;  //尾指针rear 递推 ， 最后rear=0 
  56.           delete q;
  57.       }
  58.      first=NULL;  //当结点指针为零 ,则为空 
  59.  }
  60.  ​
  61. template<classT>
  62. int LinkList<T>::Length() {
  63.      Node<T>*p = first;
  64.      int num=0;
  65.       while (p) {
  66.            p=p->next;
  67.            num++;
  68.       }
  69.       return num;
  70.  }
  71.  ​
  72. template<classT>
  73. T LinkList<T>::Get(intpos) {
  74.       Node<T>*p = first;
  75.       int j = 1;
  76.       while (p && j<pos) {  //找到第 pos的元素 
  77.            p = p->next;
  78.            j++;
  79.       }
  80.       if (!p||j>pos)  
  81.       {
  82.            cerr<<"查找位置非法。";
  83.            exit(1);
  84.       }
  85.       else return p->data;  //返回 
  86.  }
  87.  ​
  88. template<classT>
  89. int LinkList<T>::CountX(Tdata) {
  90.       int count=0;
  91.       Node<T>*p = first;
  92.       intj = 0;
  93.       while(p)
  94.      {
  95.           if(p->data==data) {
  96.              count++;
  97.          }
  98.           p=p->next;
  99.      }
  100.      return count;
  101.  }
  102.  ​
  103. template<classT>
  104. void LinkList<T>::Insert(inti, Titem) {
  105.       Node<T>*p = first;   // p指向首元结点 
  106.       Node<T>*s = new Node<T>;
  107.       if(i==1){   //插入第1个结点的操作
  108.            s->data = item;
  109.           s->next = first;   //将 s放到first(首元素)前面 
  110.           first = s;   //头指针指向 s (更改头指针) 
  111.       }
  112.      else {  
  113.       int j=1;  //第二个元素开始 
  114.       while (p && j<i-1) {   //找到插入元素位置的前驱结点 
  115.            p = p->next;
  116.            j++;
  117.       }
  118.       if (!p||i==0) {
  119.            cerr<<"插入位置非法。";
  120.            exit(1);
  121.          }
  122.       s->data = item;
  123.       s->next = p->next;   // s->next为第 i个元素地址
  124.       p->next = s;    // 第 i-1元素 next为新元素 s 
  125.      }
  126.  }
  127.  ​
  128. template<classT>
  129. void LinkList<T>::HeadInsert(Ta[], intn) {
  130.       for (inti=0; i<n; i++) {   
  131.           Node<T> *rear = first;    // rear指针指向原首元结点地址first 
  132.            Node<T>*s =new Node<T>; //新结点 s
  133.            s->data=a[i];
  134.            if (i==0) {   
  135.                 s->next=NULL;   // 头插法数组第一个元素最终为表尾元素
  136.            }
  137.           else {
  138.               s->next=rear;   //在尾部加上新结点 s  
  139.          }
  140.          first=s;  // 头指针指向 s， s为首元结点 (更新头指针) 
  141.      } 
  142.  }
  143.  ​
  144. template<classT>
  145. void LinkList<T>::TailInsert(Ta[], intn)
  146.   { 
  147.      Node<T>*rear=first;    // p指针指向原首元结点地址first 
  148.      for (inti=0; i<n; i++) {   
  149.            Node<T>*s = newNode<T>; //新结点 s
  150.            s->data = a[i];
  151.            s->next = NULL; 
  152.            if(i==0){
  153.                 first = s ;   // 如果当前是第一个元素则将头指针指向当前节点
  154.            }
  155.           else {
  156.               rear->next = s;   //在尾部加上新结点 s 
  157.               rear=s;    // s 变为尾结点 
  158.          }
  159.          rear=s;
  160.          rear->next=NULL;  //尾结点 next为空 
  161.      }
  162.  }
  163.  ​
  164. template<classT>
  165. void LinkList<T>::Detele(inti) {
  166.       if(i==1)  //删除第一个结点需要更换头指针   
  167.       {
  168.            Node<T> *q = first;    // q指向第一个元素头指针指向的首元结点地址
  169.            T x = first->data;   //存放准备删除的元素 
  170.            first = q->next;  //头指针指向第二个元素的地址
  171.            delete q; 
  172.            cout<<x<<endl;
  173.       }
  174.       else {
  175.       Node<T> *p = first;  // p先从指向首元素开始 
  176.           int j = 1;   //第二个元素开始 
  177.           while (p && j<i-1) {  // p指向将删除元素 q的前驱结点
  178.            p = p->next;
  179.            j++;
  180.            }  
  181.           Node<T> *q = p->next;  // q指向将删除结点 
  182.           T x = q->data;    
  183.            p->next = q->next;   //将*q结点从链中"断开"
  184.          delete q; 
  185.          cout<<x<<endl;
  186.      }
  187.  }
  188.      
  189. template<classT>
  190. void LinkList<T>::PrintLinkList() {
  191.       Node<T> *p = first;    
  192.       if(!p){   //空链表 
  193.            cout<<"The LinkList is empty !"<<endl;
  194.       }
  195.       else{
  196.           cout<<"LinkList: " ;
  197.       while (p) {   // p不为NULL时依次输出 
  198.                cout<<p->data ;
  199.                if(p->next!=NULL)    {  cout<<",";     }
  200.               p=p->next;
  201.          }
  202.  }
  203.       cout<<endl;
  204.  }

LinkList.cpp

  1. #include<iostream>
  2. #include "LinkList_1.h"
  3. using namespace std;
  4. int main(){
  5.      intmyData[] = {4,8,8,2,9,1,7,6,4,3,2,9,11,7,9};
  6.      cout<<" — — — — > Practice One < — — — — "<<endl;
  7. /*利用无参构造函数建立单链表(myLinkList1) ，并打印出该单链表讯息。
  8.  此时，单链表中应无数据，打印出无数据的讯息。
  9.  在主程序中，采用 for 循环依序将数组 myData 中的数据插入单链表(myLinkList1)中，并打印出该单链表讯息。
  10.  int myData[15] = { 4,8,8,2,9,1,7,6,4,3,2,9,11,7,9 }; 
  11. */
  12.      LinkList<int> myLinkList_1; 
  13.      myLinkList_1.PrintLinkList();   
  14.      int myLength=sizeof(myData)/sizeof(*myData);
  15.      cout<<"The length of input data is :"<<myLength<<endl;
  16.      for(inti=1;i<=myLength;i++){
  17.          myLinkList_1.Insert(i,myData[i-1]);
  18.       }
  19.      myLinkList_1.PrintLinkList();
  20.  
  21.  ​    cout<<endl<<endl;
  22.      LinkList<int>myLinkList_2(myData,myLength);
  23.      cout<<" — — — — > Practice Two < — — — — "<<endl;
  24. /*利用有参构造函数建立单链表 ，并打印出该单链表讯息。
  25.  int myData[15] = { 4,8,8,2,9,1,7,6,4,3,2,9,11,7,9 }; 
  26.  头插法： myLinkList2
  27.  尾插法： myLinkList3
  28. */
  29.     cout<<"Inserting a node at the Beginning of a linked listed list ."<<endl;
  30.            myLinkList_2.HeadInsert(myData,myLength);
  31.            myLinkList_2.PrintLinkList();
  32.     cout<<endl;
  33.       
  34.  ​
  35.     cout<<"Inserting a node at the End of a linked listed list ."<<endl;
  36.           myLinkList_2.TailInsert(myData,myLength);
  37.           myLinkList_2.PrintLinkList();
  38.  ​
  39.     cout<<endl<<endl;
  40.     cout<<" — — — — > Practice Three < — — — — "<<endl;
  41. /*
  42.  删除单链表中的元素
  43.  试写一个函数删除单链表中的结点，并返回被删除结点的内容。
  44.  针对 myLinkList1 中的内容进行删除。
  45.  删除第 1 个元素，并打印出删除元素的内容。
  46.  删除第 5 个元素，并打印出删除元素的内容。
  47. */
  48.  ​
  49.      cout<<"The data of the detele node is : " ;
  50.      myLinkList_1.Detele(1);
  51.      myLinkList_1.PrintLinkList();
  52.      cout<<endl;
  53.      cout<<"The data of the detele node is : " ;
  54.      myLinkList_1.Detele(5);
  55.      myLinkList_1.PrintLinkList();
  56.  ​
  57.     cout<<endl<<endl;
  58.     cout<<" — — — — > Practice Four < — — — — "<<endl;
  59. /*试写一个函数計算单链表中所储存数据的个数，并返回计算的结果。
  60.  针对 myLinkList1 中的内容进行计算。
  61.  统计 9 的个数。
  62. */
  63.     cout<<"The number of 9 "<<"is "<<myLinkList_1.CountX(9) <<endl;   
  64.  }

运行结果

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/515609
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号