线性表之单链表

一、头文件:LinkedList.h

 //单链表是用一组任意的存储单元存放线性表的元素,这组单元可以是连续的也可以是不连续的,甚至可以是零散分布在内存中的任意位置。
//单链表头文件
#include<iostream>
using namespace std;
//定义单链表结点-结构体类型
template<class DataType>
struct Node
{
  //数据域,存放该结点的数据
  DataType data;
  //指针域,指向下一个结点
  Node<DataType> *next;
}; template<class DataType>
class LinkedList{
public:
  //单链表无参构造器
  LinkedList();
  //单链表有参构造器
  LinkedList(DataType array[], int n);
  LinkedList(int n, DataType array[]);
  //单链表析构函数
  ~LinkedList();
  //获取单链表的长度
  int GetLength();
  //查找单链表指定元素的序号
  int GetLocal(DataType x);
  //获取单链表指序号的元素
  DataType GetElement(int index);
  //单链表中在指定位置插入指定的元素
  void Insert(int index, DataType x);
  //在单链表中删除指定位置的元素
  DataType Delete(int index);
  //按序号输出单链表中的元素
  void PrintLinkedList(); private :
  //声明单链表的头指针
  Node<DataType> *first;
}; //实现单链表的无参构造函数
template<class DataType>
LinkedList<DataType>::LinkedList()
{
  first = new Node<DataType>;
  first->next = NULL;
} //头插法建立单链表
template<class DataType>
LinkedList<DataType>::LinkedList(int n,DataType array[])
{
  //初始化一个空链表
  first = new Node<DataType>;
  first->next = NULL;
  for (int i = ; i < n; i++)
  {
    //为每一个数组元素都申请新结点
    Node<DataType> *s = new Node<DataType>;
    //数组元素赋值给结点数据域
    s->data = array[i];
    //将结点插入到头结点之前
    s->next = first->next;
    first->next = s;   }
} //尾插法建立单链表
template<class DataType>
LinkedList<DataType>::LinkedList(DataType array[], int n)
{
  //生成头结点
  first = new Node<DataType>;
  //定义尾结点
  Node<DataType> *r = first;
  for (int i = ; i < n; i++)
  {
    //为每一个数组元素申请一个结点
    Node<DataType> *s = new Node<DataType>;
    //把数组元素赋值给结点的数据域
    s->data = array[i];
    //将每一个结点追加到终端结点之后
    r->next = s;
    r = s;
  }
  //尾结点尾NULL
  r->next = NULL;
} //实现单链表的析构函数
template<class DataType>
LinkedList<DataType>::~LinkedList()
{
  //声明工作指针
  Node<DataType> *q;
  while (first != NULL)
  {
    //暂存被释放的结点
    q = first;
    //让头指针指向要释放结点的下一个结点
    first = first->next;
    delete q;
  }
} //实现单链表插入:在指定的位置插入指定的元素
template<class DataType>
void LinkedList<DataType>::Insert(int index, DataType x)
{
  //定义工作指针
  Node<DataType> *p = first->next;
  //定义计数器,初始值为0
  int count = ;
  while (p != NULL &&count < index - )
  {
    //工作指针后移
    p = p->next;
    count ++;
  }
  //找到 index-1 的位置
  if (p == NULL)
  {
    throw "插入的位置有误";
  }
  else
  {
    //申请一个新结点
    Node<DataType> *s;
    s= new Node<DataType>;
    //其数据域为 x
    s->data = x;
    //在新结点的指针域存放工作指针p的指针域
    s->next = p->next;
    //将结点s插入到p结点之后
    p->next = s;
  }
} //实现单链表的按值查找,返回指定元素在单链表中的序号(如不存在,则返回0)
template<class DataType>
int LinkedList<DataType>::GetLocal(DataType x)
{
  //定义工作指针
  Node<DataType> *p = first->next;
  //定义计数器,初始值是1
  int count = ;
  //查找序号所对应的位置
  while (p != NULL)
  {
    if (p->data == x)
    {
      return count;
    }
    //工作指针后移
    p = p->next;
    //计数器加1
    count++;
  }
  //如果找不到该元素,则返回0
  return ;
} //实现单链表按位查找,返回指定位置的元素
template<class DataType>
DataType LinkedList<DataType>::GetElement(int index)
{
  //定义工作指针
  Node<DataType> *p = first->next;
  //定义计数器,初始值是1
  int count = ;
  //查找序号所对应的位置
  while (p != NULL&&count < index)
  {
    //工作指针后移
    p = p->next;
    //计数器加1
    count++;
  }
  //如果找到单链表的末尾,还找不到指定的位置,则抛出异常
  if (p == NULL)
  {
    throw "查找的位置有误";
  }
  else
  {
    //当找到合适的位置时,返回该位置上的元素
    return p->data;
  } } //实现获取单链表的长度
template<class DataType>
int LinkedList<DataType>::GetLength()
{
  //定义计数器,用来计算单链表的长度
  int count = ;
  //定义工作指针
  Node<DataType> *p = first->next;
  while (p != NULL)
  {
    p = p->next;
    count++;
  }
  return count; } //实现单链表的按序号输出元素
template<class DataType>
void LinkedList<DataType>::PrintLinkedList()
{
  //声明工作指针
  Node<DataType> *p;
  //初始化工作指针
  p = first->next;
  while(p != NULL)
  {
    cout << p->data << " ";
    //工作指针向后移动
    p = p->next;
  }
  cout << endl;
} //实现单链表的删除
template<class DataType>
DataType LinkedList<DataType>::Delete(int index)
{
  Node<DataType> *p = first->next;
  int count = ;
  //查找第 index-1 位置结点
  while (p != NULL&&count < index - )
  {
    p = p->next;
    count++;
  }
  //如果能找到
  if (p == NULL || p->next == NULL)
  {
    throw "删除的位置有误";
  }
  else
  {
    Node<DataType> *q = p->next;
    DataType x = q->data;
    p->next = q->next;
    delete q;
    return x;
  }
}

二、测试线性表之单链表的源文件:TestLinkedList.cpp

 #include<iostream>
#include "LinkedList.h"
using namespace std;
void show()
{
  cout << "---------------------------------------" << endl;
}
int main()
{
  int array[] = { , , , , , , , , , };
  //声明单链表
  LinkedList<int> linkedList = LinkedList<int>(,array);
  cout << "输出单链表:" << endl;
  linkedList.PrintLinkedList();
  show();
  cout << "单链表的长度:" << linkedList.GetLength() << endl;
  cout << "单链表中第5个元素是:" << linkedList.GetElement() << endl;
  cout << "单链表中元素5的位置是:" << linkedList.GetLocal() << endl;
  show();
  cout << "在单链表的第5个位置上插入元素22" << endl;
  linkedList.Insert(, );
  cout << "输出单链表:" << endl;
  linkedList.PrintLinkedList();
  cout << "单链表的长度:" << linkedList.GetLength() << endl;
  show();
  cout << "删除第5位置的元素" << endl;
  linkedList.Delete();
  cout << "输出单链表:" << endl;
  linkedList.PrintLinkedList();
  cout << "单链表的长度:" << linkedList.GetLength() << endl;
  show();
  return ;
}

三、运行示例结果

线性表之单链表C++实现的更多相关文章

  1. [数据结构 - 第3章] 线性表之单链表(C++实现)

    一.类定义 单链表类的定义如下: #ifndef SIGNALLIST_H #define SIGNALLIST_H typedef int ElemType; /* "ElemType类型 ...

  2. 续上文----线性表之单链表(C实现)

    本文绪上文线性表之顺序表(C实现) 本文将继续使用单链表实现线性表的另外一种存储结构.这种使用链表实现的存储结构在内存中是不连续的. C实现代码如下: #include<stdio.h> ...

  3. 【Java】 大话数据结构(2) 线性表之单链表

    本文根据<大话数据结构>一书,实现了Java版的单链表. 每个结点中只包含一个指针域的链表,称为单链表. 单链表的结构如图所示: 单链表与顺序存储结构的对比: 实现程序: package ...

  4. 线性表 (单链表、循环链表-python实现)

    一.线性表 线性表的定义: 线性表是具有相同数据类型的有限数据的序列. 线性表的特点: 出了第一个元素外,每个元素有且仅有一个直接前驱,除最后一个元素外有且只有一个后继. 线性表是一种逻辑结构,表示元 ...

  5. Java数据结构-线性表之单链表LinkedList

    线性表的链式存储结构,也称之为链式表,链表:链表的存储单元能够连续也能够不连续. 链表中的节点包括数据域和指针域.数据域为存储数据元素信息的域,指针域为存储直接后继位置(一般称为指针)的域. 注意一个 ...

  6. [C++]数据结构:线性表之(单)链表

    一 (单)链表 ADT + Status InitList(LinkList &L) 初始化(单)链表 + void printList(LinkList L) 遍历(单)链表 + int L ...

  7. 数据结构(java版)学习笔记(三)——线性表之单链表

    单链表的优点: 长度不固定,可以任意增删. 单链表的缺点: 存储密度小,因为每个数据元素,都需要额外存储一个指向下一元素的指针(双链表则需要两个指针). 要访问特定元素,只能从链表头开始,遍历到该元素 ...

  8. 【线性表基础】顺序表和单链表的插入、删除等基本操作【Java版】

    本文表述了线性表及其基本操作的代码[Java实现] 参考书籍 :<数据结构 --Java语言描述>/刘小晶 ,杜选主编 线性表需要的基本功能有:动态地增长或收缩:对线性表的任何数据元素进行 ...

  9. 玩转C线性表和单向链表之Linux双向链表优化

    前言: 这次介绍基本数据结构的线性表和链表,并用C语言进行编写:建议最开始学数据结构时,用C语言:像栈和队列都可以用这两种数据结构来实现. 一.线性表基本介绍 1 概念: 线性表也就是关系户中最简单的 ...

随机推荐

  1. Ubuntu自定义终端窗口位置

    方法一: 自定义终端启动快捷键 具体方法是自定义一个快速启动终端的快捷键,附带设置终端启动时的位置参数.首先获得需要放置窗口的目标位置信息,可以通过终端命令“ xwininfo ”来获得.步骤是首先打 ...

  2. Java并发编程(2) AbstractQueuedSynchronizer的内部结构

    一 前言 虽然已经有很多前辈已经分析过AbstractQueuedSynchronizer(简称AQS,也叫队列同步器)类,但是感觉那些点始终是别人的,看一遍甚至几遍终不会印象深刻.所以还是记录下来印 ...

  3. Ping程序的实现

    Ping程序的实现 在windows系统下进行cmd可以进行ping操作. ping命令是用来确定本地主机与网络中其他主机的网络通信情况,或者查看是否是为效IP. ping的工作原理:网络另一主机发送 ...

  4. inspect的使用

    # -*- coding: utf-8 -*- # @Time : 2018/9/11 10:29 # @Author : cxa # @File : inspecttest.py # @Softwa ...

  5. 【转】WCF光芒下的Web Service

    WCF光芒下的Web Service 学习.NET的开发人员,在WCF的光芒照耀下,Web Service 似乎快要被人遗忘了.因为身边做技术的人一开口就是WCF多么的牛逼!废话不多,本人很久不写博客 ...

  6. Splay算法摘要

    先介绍变量定义 int n; struct Node { //Splay节点定义 ],val,num,siz; //fa:它爸爸:son它儿子,左0右1:val:这个节点的值 //num:这个值的数量 ...

  7. python基础--类的方法

    一:类的方法说明 类的方法分为实例方法,析构方法,构造方法,类方法,静态方法,属性方法,等等 类方法和静态方法都可以被类和类实例调用,类实例方法仅可以被类实例调用 类方法的隐含调用参数是类,而类实例方 ...

  8. 阿里妈妈MLR模型(论文)

    论文来源:https://arxiv.org/abs/1704.05194v1 阿里技术:https://mp.weixin.qq.com/s/MtnHYmPVoDAid9SNHnlzUw?scene ...

  9. java基础47 装饰着模式设计

    1.装饰者模式 增强一个类的功能,而且还可以让这些装饰类相互装饰 2.装饰者设计模式的步骤 1.在装饰类的内部维护一个被装饰类的引用    2.让装饰者有一个共同的父类或者父接口 3.实例 packa ...

  10. Java HashCode详解

    一.为什么要有Hash算法 Java中的集合有两类,一类是List,一类是Set.List内的元素是有序的,元素可以重复.Set元素无序,但元素不可重复.要想保证元素不重复,两个元素是否重复应该依据什 ...