[C++/数据结构]1.2 线性表的链式存储

已于 2022-04-28 16:04:52 修改
阅读量1.2k 收藏
点赞数
分类专栏： 数据结构 C C++ 文章标签： 数据结构 c++
于 2022-04-20 16:50:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43150072/article/details/124279021
版权
C++ 同时被 3 个专栏收录
13 篇文章 0 订阅
订阅专栏
C
7 篇文章 0 订阅
订阅专栏
数据结构
4 篇文章 0 订阅
订阅专栏

如果你有C++11的了解，我建议您直接跳掉 5 基于C++11新特性的改进，因为原本方法在造节点上必须一个个元素写出来，然后再手动连接，十分不便；此外这里的原本的方法是不可靠的，仅作参考

1 需要构造的函数

1. Status InitList L(LinkList &L);
//生成新节点作为表头，用头指针L指向头结点；把头结点的指针域置空

2.isEmpty
//判断是否为空即判断头结点指针域是否为空，因为当加入元素时，头结点的指针域是一定要指向第一个元素的地址

3.DestroyList
//引入一个新指针，他指向表头，然后直接释放这块地方；指向下一个，释放。。。重复重复；需要注意的是要保存地址指向下一个地方；

4.ClearList
//需要三个指针，不删除头结点，然后清除所有元素delete

5.ListLen
//弄个计数器

6.LocateElem
//查找，从头开始找

7. GetElem
//获取i位置的元素

8. InsertList
9. DeleteList
 //两者类似，增加（删减）插入位置元素的地址即可

2 节点的设计

关于节点的设计，我们当然可以像老师那样将链表名跟节点放在一起，但是在对象的设计角度来说，他们两个的“方法”将重叠，比如说一个链表的任意节点都可以使用初始化链表的操作。因此我觉得把他们设计成两个对象

由于这次的设计会涉及到两种对象，一个是链表本身（或者说头结点），另一个是普通节点，他们在一些操作上是不相容的，比如说我们想要计算这个链表有多长，但是我们不会计算一个节点有多长；我们会想在链表插入一个节点，但是我们不会对一个节点对象插入一个节点。

实际上这是只在单链表才需要考虑的，如果设置成双链表，或者循环列表，那么表头即链表名无所谓跟节点有区别。

typedef struct
{
	int age;
	float grade;
}ElemType;

class LNode
{
private:
	ElemType* elem;
	
public:
	LNode* next;
	LNode(ElemType*e,LNode* left=NULL)
	{
		elem = e;
		next = left;
	}
	void show()
	{
		cout << "age is: " << elem->age << " ,grade is: " << elem->grade << endl;
	}

};

lnode为左节点，一个节点里面存在两个数据，一个数据ElemType去存储复杂的数据类型，另一个LNode* next。

3 方法

以下方法我很多是偷懒没写全的，比如Insert的位置我没有判定是否合法，首节点和结尾的处理我也没做

class LinkList
{

public:
	LNode* next;

	LinkList()
	{
		next = NULL;
		cout << "Link List Inited!" << endl;
	}

	~LinkList()
	{

	}

	bool isEmpty()
	{
		if (next == NULL)
		{
			cout << "is Empty!" << endl;
			return 0;
		}
		else
		{
			cout << "Not Empty!" << endl;
			return 1;
		}
	}

	int ListLen()
	{
		auto p = next;
		int i = 0;
		while (p != NULL)
		{
			p = p->next;
			i++;
		}
		cout << "length is: " << i << endl;
		return i;
	}

	void Print()
	{
		auto p = next;
		while (p != NULL)
		{
			p->show();
			p = p->next;
		}
	}

//todo loc valid?
	void InsertList(LNode* n, int loc)
	{
		auto p = next;
		auto q = next;
		int i = 1, j = 1;
		//先找到loc位置上的元素地址，然后让n连接他
		while (i != (loc))
		{
			p = p->next;
			i++;
		}
		n->next = p;

		
		//后找到loc-1位置上的元素，然后让q连接n；
		//loc,loc-1查找的顺序不能调换
		while (j != (loc -1))
		{
			q = q->next;
			j++;
		}
		q->next = n;

	}

//todo loc valid?
	void DeleteList(int loc)
	{
		auto p = next;
		auto q = next;
		int i = 1, j = 1;
		while (i != (loc+1))
		{
			p = p->next;
			i++;
		}

		while (j != (loc - 1))
		{
			q = q->next;
			j++;
		}

		q->next = p;
	}

//todo loc valid?
	LNode* GetElem(int loc)
	{
		auto p = next;
		int i = 1;
		while (i<(loc))
		{
			p = p->next;
			i++;
		}
		return p;
	}
	

	int LocateElem(LNode* n, int (*cmp)(void* e1, void* e2))
	{
		auto p = next;
		int i = 1;
		for (p; p != NULL; p = p->next)
		{
			if (cmp(p, n) == 0)
			{
				cout << "Location Found:  " << i << endl;
				return i;
			}
			i++;
		}
		printf("No such elem!\n");
		return -1;
	}
	

};

测试文件

#include "Header.h"

int cmp_age(void* e1, void* e2)
{
	return (int)(((ElemType*)e1)->age - ((ElemType*)e2)->age);
}


int main()
{
	//创建链表
	LinkList L;
	//L.isEmpty();
	//节点数据以及创建节点
	ElemType p1 = { 1,1.1 };
	//ElemType q1 = { 14,11.11 };
	ElemType p2 = { 2,2.2 };
	ElemType p3 = { 3,3.3 };
	ElemType p4 = { 4,4.4 };
	LNode n1(&p1);
	LNode n2(&p2);
	LNode n3(&p3);
	LNode n4(&p4);

	//连接节点
	L.next = &n1;
	n1.next = &n2;
	n2.next = &n3;
	n3.next = &n4;

	L.isEmpty();
	L.Print();
	L.ListLen();

	//测试insert
	//ElemType q1 = { 14,11.11 };
	//LNode m1(&q1);
	//L.InsertList(&m1, 2);
	//L.ListLen();
	//L.Print();

	测试Delete
	//L.DeleteList(2);
	//L.ListLen();
	//L.Print();

	//测试Get
	//LNode m2(&p1);
	//m2 = *L.GetElem(2);
	//m2.show();


	测试Locate
	//ElemType q1 = { 14,11.11 };
	//LNode m1(&q1);
	//L.LocateElem(&m1, cmp_age);

	return 0;
}

4 STL中的list

list是一个双向链表容器，他不可以进行随机存取，只能顺序存储，但是可以进行有效的插入和删除。这跟我们的线性表链式存储是一致的。

4.1 初始化

  std::list<int> first;                                // empty list of ints
  std::list<int> second (4,100);                       // four ints with value 100
  std::list<int> third (second.begin(),second.end());  // iterating through second
  std::list<int> fourth (third);                       // a copy of third

  int myints[] = {16,2,77,29};
  std::list<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

4.2 部分方法

  1. a.begin(); a.end();//获得首节点，尾节点

  2. a.push.back();a.pop_back();//从末端添加，删除节点

  3. a.push_front();a.pop_back();//从前端添加，删除节点

  4. a.empty();

  5. a.clear();

  6. a.front();a.back();//获得首元素，尾元素

  7. a.reverse();

  8. a.merge(b,greater<\int>());//合并a,b，结果放在a处，greater值升序，可改。实际上这是函数指针，所以你可以放入自定义函数。

  9. a.insert(a.begin(),100); //在a的开始位置插入100。

    a.insert(a.begin(),2,200);// 在a的开始位置插入2个100。

    a.insert(a.begin(),b.begin(),b.end());//在a的开始位置插入b的从开始到结束的所有位置的元素。

  10. a.erase(a.begin()); 将l1的第一个元素删除。

    a.erase(a.begin(),a.end()); 将l1的从begin()到end()之间的元素删除。

4.3 应用

1 合并两个集合

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

template <class T>
list<T> combine(list<T> l1, list<T> l2)
{
    list<T> tmp(l1.begin(), l1.end());
    for (auto i : l2)
    {
        for (auto j : l1)
        {
            if (i == j)
            {
                break;
            }
            if (j == l1.back())
            {
                tmp.push_back(i);
            }
        }
    }
    return tmp;
}

int main()
{
    list<int> l1{1, 2, 3, 4};
    list<int> l2{5, 1};

    auto l3 = combine(l1, l2);
    for (auto i : l3)
    {
        cout << i << endl;
    }
    system("pause");
    return 0;
}

5 基于C++11新特性的改进

考虑到list<int> l1{1, 2, 3, 4};他有这样3个特性，1是可以直接进行任意数量数据的赋值，2是自动进行节点的连接，3是可以支持任意类型的数据。实际上这样的操作，1是需要initializer_list这样的技术，2则是内存管理分配的问题，3则是类模板问题。我这里仅做抛砖引玉的工作，实现1,2的特性，3的话您可以修改Node类来实现。

struct Node
{
    int val;
    Node *next;
    Node() : val(0), next(nullptr) {}
    Node(int x) : val(x), next(nullptr) {}
    Node(int x, Node *next) : val(x), next(next) {}
};

template <class T>
class Linklist
{
private:
    Node *List;
public:
//initializer_list<T>是一个以array为基础的容器，你可以放任意数量的元素进去
    Linklist(initializer_list<T> initList)
    {
		//创造一个链表（其实也就是头结点）
        List = new Node;
        //创造一个指针用来帮我进行遍历操作
        Node *head = List;
        for (auto i : initList)
        {
        //将表头的next指向一个新节点，节点里存放i
            head->next = new Node(i);
        //移动指针指向新的节点
            head = head->next;
        }
    }

    int len()
    {
        int len = 0;
        auto p = List->next;
        while (p != 0)
        {
            p = p->next;
            len++;
        }
        return len;
    }

    void print()
    {
        auto p = List->next;
        while (p != 0)
        {
            cout << p->val << endl;
            p = p->next;
        }
    }
};

int main()
{
    Linklist<int> L{1, 2, 3, 4};
    cout << L.len() << endl;
    L.print();
    system("pause");
    return 0;
}
学生Joe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
3.5.4 字符数据在内存中的存储形式及使用方法 41 3.5.5 字符串常量 41 3.5.6 符号常量 42 3.6 变量赋初值 42 3.7 各类数值型数据之间的混合运算 43 3.8 算术运算符和算术表达式 44 3.8.1 C运算符简介 44 3.8.2 算术...
链表数据结构的C++实现：类模板实现线性表的链式存储
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
04-07 1140
C++类模板实现链表数据结构。
mysql基础（三）查改删与排序分组
作为一个长者,有必要记录下人生经验
07-27 242
建表 CREATE TABLE aa( id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(5) NOT NULL, sex CHAR(2), age TINYINT ) 插入数据 INSERT INTO aa VALUES(NULL,'张三','男',35),(NULL,'李四','女',NULL),(NULL,'王五','男',NULL),(NULL,'李四','男',28) 查： 查询年龄字段为空： SELECT * FROM aa WHERE
C++用链表存放数据
Mr mao的博客
10-26 3035
用链表存放数据在插入和删除操作时比用线性表方便很多，链表不用去移动那些位置的数据。 这是用链表实现的简单通讯录，先上代码 /* * 程序功能：用链表储存学生通讯录信息 * 作者：BossMao * 版本：2.0 */ #include #include using namespace std; struct student_Info{ double stu_Num; //学生学
c++使用单向链表存储一组有序数据_数据结构线性表（二）
weixin_34723270的博客
12-29 806
1、 线性表的链式存储结构1、线性表的链式存储结构—链表(1)如果每个结点只设置一个指向其后继结点的指针成员，这样的链表称为线性单向链接表，简称单链表。(2)如果每个结点中设置两个指针成员，分别用以指向其前驱结点和后继结点，这样的链表称之为线性双向链接表，简称双链表。2、单链表每个结点为LinkNode类对象，包括存储元素的数据列表data和存储后继结点的指针属性next。单链表类LinkList...
C++实现单链表的各种操作（数据结构）
Ethereal的博客
10-27 1101
单链表的定义注意点，头指针和头结点的区别，用C++实现单链表的各种基本操作。
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
3.5.4 字符数据在内存中的存储形式及使用方法 41 3.5.5 字符串常量 41 3.5.6 符号常量 42 3.6 变量赋初值 42 3.7 各类数值型数据之间的混合运算 43 3.8 算术运算符和算术表达式 44 3.8.1 C运算符简介 44 3.8.2 算术...
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
5.2 线性表数据结构 5.2.1 抽象数据类型linearList 5.2.2 抽象类linearList 5.3 数组描述 5.3.1 描述 5.3.2 变长一维数组 5.3.3 类arrayList 5.3.4 C++迭代器 5.3.5 arrayList的一个迭代器 5.4 vector的描述 5.5 在...
数据结构与算法实验内容.pdf
07-11
实验目的 (1) 掌握线性表的链式存储结构； (2) 熟练掌握链式基本算法的实现； (3) 掌握利用线性表数据结构解决实际问题的方法和基本技巧； (4) 按照实验题目要求独立正确地完成实验内容。 2. 实验环境 (1) 硬件：每...
C++实现数据结构入门02——链式存储实现线性表
小橙子的博客
11-16 1674
一、创建结构体 1.图解 这个结构体需要两个变量， 一个是数据存储数据的，可以是字符串、数字等。 一个是地址存储的，存储下一个结构体的地址，所以类型是本身结构体的类型。 2.代码 #include <iostream> #include <string> using namespace std; //链表的结构体 struct LNode{ string data;//节点的数据域（存储数据的地方） LNode * next;//节点指针域 （储存下一个.
C++项目中用链表存储信息详解代码
qq_26139541的博客
09-21 702
首先我们建立一个链表类，链表结构体也可 #pragma once #include"People.h" class list { public: People data; list* next; }; data信息类，可以根据实际需求自由拓展 #pragma once #include<string> #include<cstring> using namespace std; class People { public: void setid(char *ID
数据结构之单链表创建 c++实现
sotfish的博客
04-13 1842
数据结构之单链表创建（c++） 说明：使用c++创建单链表，使用头插法，动态空间规划法，以‘’#‘’或‘$’结束j键盘输入，最后打印出链表内容。 必备条件：结构体、指针、动态规划、循环语句等 #include <stdio.h> #include <stdlib.h> #include <iostream.h> typedef struct Node ...
C++基于数组存储结构的链表设计与实现
qq_43521551的博客
12-06 1523
基于数组存储结构的链表 数组中的每一个元素附加一个指向后续元素的指针，对数组元素的访问顺序由指针指向的位置决定，这样可以不改变各个元素的物理位置，就可以改变数组的逻辑顺序 这是一种基于数组的存储结构，倘若运算过程中数组的大小不发生改变则称之为静态链表，其实也可以改造为动态数组来实现 基于数据存储结构的链表的每个元素包含：data数据和link指针域 优点：对数组元素的插入、删除操作只需要修改链接指针而不需要移动元素，因此具有更高的效率 缺点：查找元素需要从头部开始逐个遍历，随机存取较慢 基于
关于链表的建立与操作（c++实现）
weixin_74943550的博客
08-06 5092
因为线性表是静态线性的存储结构，所以为了方便动态地对数据进行处理，我们引入链表这一数据结构。因为链表是动态的存储结构，所以存储在其中的数据地址不一定是连续的。因此在创建链表时不仅需要保存数据本身，还需保存它的地址。所以我们就用一个结构体来存储链表的结点。其中每个结点都要包含两个领域，分别是数据域和指针域，用于存储数据和存储下一个结点的地址。int data;//这里的data可以是任意数据类型 struct node * link;} LNode;
c++使用单向链表存储一组有序数据_[C/C++基础知识] 那些被遗忘的链表学问
weixin_28760171的博客
12-30 242
[C/C++基础知识] 那些被遗忘的链表知识最近快毕业了,复试又复习了一些知识.其中就包括那些被遗忘的链表知识,而它又是C语言中非常重要一个知识点.同时发现很多同学都会忘记该知识,所以通过这篇文章一方面帮助大家回忆链表知识,同时对刚接触C语言的同学也有帮助.我采用问答的方式回顾那些知识,希望能接受!提示:该文章引用李凤霞(北理)的《C语言程序设计教程》及课件和谭浩强(清华)的《C程序设计》.一.链...
c++采用链式存储完成学生信息的管理
weixin_51658547的博客
03-27 4225
采用链式存储完成学生信息的管理。学生信息包括：学号、姓名、专业、班级、性别、年龄等。要求实现学生信息数据的录入、插入、删除、查找、修改、排序、合并等。具体步骤包括：定义链表（任一种）的存储结构、实现相应基本操作、实现学生信息数据的管理；对链表中的学生信息按学号从小到大排序；将两个存储了学生信息的有序链表合并成一个链表。
C++数据结构day01-链式存储
qq_59841463的博客
11-18 304
于数据结构上来说，新手都是在定义结构体直接写进链式存储中，但对于企业项目我们要做到定义的结构体和数据结构的链式存储分离才算好。 现在我们来学习怎么去分离结构体和链式存储 这个的主要思想是我们将结构体定义到main.c中通过使用(LinkListNode*)(&t1)强转去调用函数，返回的值再利用强转(Teacher*)LinkList_Get(list, i)，得到值。
【数据结构C/C++】详解线性表之链式与顺序存储结构增删改查的实现方式(附代码)
Zhangsama1的博客
07-30 7746
文章目录前言一、顺序存储结构1：建立一个包含数组的结构体2：获得元素（从数组中获取所需元素）3：插入元素4：删除元素二、链式存储结构（方法1）1.创建承载数据的载体2:创建链表2.显示链表数据3：删除链表数据4：插入数据二、链式存储结构（方法2）1：结构体创建2：创建链表3：删除链表4：获取元素5：插入元素6：删除元素推荐学习网站 前言 链表，作为数据结构中非常重要的一种算法，有着诸多用途，因此写下本文记录自己的学习过程。 参考书籍《大话数据结构第二版》 一、顺序存储结构 我们知道，数组最大的特点就.
数据结构--线性表链式存储
m0_62476845的博客
10-01 1088
为了克服顺序表的缺点，可以采用链式方式存储线性表。链式存储是最常用的动态存储方式，它不需要用地址连续存储的存储单元来实现，而是通过“链”建立起数据元素之间的逻辑关系，对线性表的插入，删除不需要移动数据元素。}LinkList;//让链表的名称为LinkList顺序表和链表的存储结构各有优缺点。在实际应用中究竟选用何种存储结构要根据具体的要求和性质。一、空间的考虑线性表要事先对MAXSIZE要有合适的设定，防止浪费或溢出。因此对线性表的长度或存储规模难以估计时，不宜采用顺序表。
c++数据结构实验一线性表
最新发布
09-17
数据结构实验一是关于线性表的实验。线性表是一种常见的数据结构，它是由一组具有相同类型的数据元素组成的有限序列。 在实验一中，我们将学习线性表的基本操作和实现方式。首先，我们需要明确线性表的特点：包括...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值