2021-12-19 数据结构——线性表(中) (c++代码和c代码)

已于 2022-05-03 10:20:54 修改
阅读量862 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c++ c语言
于 2021-12-20 16:27:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011514176/article/details/122040670
版权

1. 线性表的链式存储

不要求逻辑上相邻的两个元素物理上也相邻，通过"链"建立起数据之间的逻辑关系。线性表的链式存储结构的特点是==用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。==这就意味着，这些元素可以存在内存未被占用的任意位置。
在这里插入图片描述
链表的定义是递归的，它或者为空null，或者指向另一个节点node的引用，这个节点含有下一个节点或链表的引用，线性链表的最后一个结点指针为“空”（通常用NULL或“^”符号表示）。
在这里插入图片描述
插入、删除不需要移动数据元素，只需要修改"链"

template<class DataType>
struct Node
{
    DataType data;              //存储数据
    Node<DataType> *next;       //存储下一个结点的地址
};

结点由存放数据元素的数据域和存放后继结点地址的指针域组成。
在这里插入图片描述

2. 链式存储结构的抽象数据类型 （c里面的L应该是第一个空节点？第一个空节点即头结点序号是0！！）

2.1 模板

c++

template<class DataType>
class LinkList
{
public:
    LinkList();            //默认构造          
    LinkList(DataType a[], int n);   // 有参构造
    ~LinkList();                    //析构函数
    int Length();                   //参数
    DataType Get(int i);            //按位置查找
    int Locate(DataType x);         //按值查找
    void Insert(int i, DataType x); //插入
    DataType Delete(int i);         //删除
    void PrintList();               //打印输出
private:
    Node<DataType> *first;          //头指针
};

c语言

List L;

List MakeEmpty(); //初始化链表 
int Length(List L);  // 以遍历链表的方法求链表长度 
List FindKth(int K,List L);  // 按序号查找 
List Find(ElementType X,List L);  // 按值查找 
List Insert(ElementType X,int i,List L);  //将 X 插入到第 i-1(i>0) 个结点之后 
List Delete(int i,List L); // 删除第 i(i>0) 个结点 
void Print(List L); // 输出链表元素

2.1.1 特点

用一组任意的存储单元存储线性表的数据元素， 这组存储单元可以存在内存中未被占用的任意位置
顺序存储结构每个数据元素只需要存储一个位置就可以了，而链式存储结构中，除了要存储数据信息外，还要存储它的后继元素的存储地址

2.2 初始化，构造

2.2.1 无参构造

生成只有空节点的空链表
c++

template<class DataType>
LinkList<DataType>::LinkList()
{
    first = new Node<DataType>;
    first->next = NULL;
}

c

// 初始化链表 
List MakeEmpty(){
	List L = (List)malloc(sizeof(struct LNode));
	L = NULL;
	return L;
}

2.3 头插法构造单链表

头插法是每次将新申请的结点插在头结点后面。
  在这里插入图片描述
c++

template<class DataType>
LinkList<DataType>::LinkList(DataType a[], int n)
{
    first = new Node<DataType>;
    first->next = NULL;
    for (int i = 0; i < n; i++)
    {
        Node<DataType> *s = new Node<DataType>;
        s->data = a[i];
        s->next = first->next; //这边这个first->next;指的是原来还没有插入的时候的节点的数据，这个时候正好就把要插入的s节点指向了s后面的节点的数据了。
        first->next = s;  
    }
}

c

/* 插入
1. 用 s 指向一个新的结点
2. 用 p 指向链表的第 i-1 个结点 
3. s->Next = p->Next，将 s 的下一个结点指向 p 的下一个结点 
4. p->Next = s，将 p 的下一结点改为 s   */
List Insert(ElementType X,int i,List L){
	List p,s;
	if(i == 1){     // 新结点插入在表头 ，如果插入的节点是头结点
		s = (List)malloc(sizeof(struct LNode));   //新插入的节点
		s->Data = X;  //x是数据域
		s->Next = L;
		return s;     //插入的结点为头结点 
	}
	p = FindKth(i-1,L);   // 找到第 i-1 个结点，
	if(!p){   // 第 i-1 个结点不存在   
		printf("结点错误");
		return NULL;
	}else{  //如果插入的不是头结点！！！！！！！！！也就是说随机插入的话
		s = (List)malloc(sizeof(struct LNode));
		s->Data = X;
		s->Next = p->Next;   //将 s 的下一个结点指向 p 的下一个结点   这边这个p->next;指的是原来还没有插入的时候的节点的数据，这个时候正好就把要插入的s节点指向了s后面的节点的数据了。
		p->Next = s;   // 将 p 的下一结点改为 s
		return L;
	}
}

2.4 尾插法构造单链表

尾插法就是每次将新申请的结点插在终端节点的后面
在这里插入图片描述

template<class DataType>
LinkList<DataType>::LinkList(DataType a[], int n)
{
    first = new Node<DataType>;
    Node<DataType> *r = first;
    for (int i = 0; i < n; i++)
    {
        Node<DataType> *s = new Node<DataType>;
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

2.5 中间插入

单链表在插入过程中需要注意分析在表头、表中间、表尾的三种情况，由于单链表带头结点，这三种情况的操作语句一致，不用特殊处理，时间复杂度为 O(n)
在这里插入图片描述

template<class DataType>
void LinkList<DataType>::Insert(int i, DataType x)
{
    first = new Node<DataType>;
    Node<DataType> *p = first;  //？？？？？？？？？？？
    int count = 0;
    while (p != NULL && count<i - 1)  //count<i - 1！！！！！！！！
    {
        p = p->next;
        count++;
    }
    if (p == NULL) throw "Location";
    else {
        Node<DataType> *s = new Node<DataType>;
        s->data = x;
        s->next = p->next;  // p->next是未插入的时候指向的下一个数据
        p->next = s;
    }
}

总结插入元素：

还是c的代码比较牛，这样直接融会贯通了。

2.6 析构函数

单链表类中的结点是用new申请的，在释放的时候无法自动释放，所以，析构函数要将单链表中的结点空间释放

template<class DataType>
LinkList<DataType>::~LinkList()
{
    while (first != NULL)
    {
        Node<DataType>* q = first;
        first = first->next;
        delete q;
    }
}

C语言就需要析构了！。。

2.7 计算长度

单链表中不能直接求出长度，所以我们只能将单链表扫描一遍，所以时间复杂度为O(n)
  在这里插入图片描述
C++

template<class DataType>
int LinkList<DataType>::Length()
{
    Node<DataType>* p = first->next;
    int count = 0;
    while (p != NULL)
    {
        p = p->next;  //再次指向下一个
        count++;
    }
    return count;
}

C

//求表长 
int Length(List L){
	List p = L;
	int len=0;
	while(p){  // 当 p 不为空 
		p = p->Next;
		len++;
	}
	return len;
}

2.8 按位查找

单链表中即使知道节点位置也不能直接访问，需要从头指针开始逐个节点向下搜索，平均时间性能为O(n) ，单链表是顺序存取结构

template<class DataType>
DataType LinkList<DataType>::Get(int i)  // i代表的是 第几个 
{
    Node<DataType>* p = first->next;
    int count = 1;
    while (p != NULL && count<i)
    {
        p = p->next;
        count++;
    }
    if (p == NULL) throw "Location";
    else return p->data;
}

// 按序查找 
List FindKth(int K,List L){
	List p = L;
	int i = 1;  //从 1 开始 
	while(p && i<K){
		p = p->Next;
		i++;
	}
	if(i == K)    // 找到了 
		return p;
	else    // 未找到 
		return NULL;
}

2.9 按值查找

单链表中按值查找与顺序表中的实现方法类似，==对链表中的元素依次进行比较，平均时间性能为O(n) ==

template<class DataType>
int LinkList<DataType>::Locate(DataType x)
{
    Node<DataType> *p = first->next; //第一个空节点后面的带数据域的节点！！！！！ 注意这个序号！
    int count = 1;
    while (p != NULL)
    {
        if (p->data == x) return count;
        p = p->next;
        count++;
    }
    return 0;
}

// 按值查找  
List Find(ElementType X,List L){
	List p = L;
	while(p && p->Data!=X)
		p = p->Next;
	// 找到了，返回 p
	// 未找到，返回 NULL，此时 p 等于 NULL 
	return p;   
}

2.10 删除

删除操作时需要注意表尾的特殊情况，此时虽然被删结点不存在，但其前驱结点却存在。因此仅当被删结点的前驱结点存在且不是终端节点时，才能确定被删节点存在，时间复杂度为O(n) .
  在这里插入图片描述

template<class DataType>
DataType LinkList<DataType>::Delete(int i)  //注意：：这个p是要删除的节点q的前一个节点
{
    Node<DataType> *p = first;
    int count = 0;
    while (p != NULL && count<i - 1)
    {
        p = p->next;
        count++;
    }
    if (p == NULL || p->next == NULL) throw "Location";
    else {
        Node<DataType> *q = p->next;
        int x = q->data;
        p->next = q->next;
        return x;
    }
}

c

/* 删除
1. 用 p 指向链表的第 i-1 个结点 
2. 用 s 指向要被删除的的第 i 个结点
3. p->Next = s->Next，p 指针指向 s 后面
4. free(s)，释放空间 
*/
List Delete(int i,List L){
	List p,s;
	if(i==1){   //如果要删除头结点 
		s = L;
		if(L)   // 如果不为空 
			L = L->Next;
		else
			return NULL;
		free(s);   // 释放被删除结点 
		return L; 
	}
	p = FindKth(i-1,L);    // 查找第 i-1 个结点
	if(!p || !(p->Next)){     // 第 i-1 个或第 i 个结点不存在 
		printf("结点错误");
		return NULL;
	}else{
		s = p->Next;    // s 指向第 i 个结点 
		p->Next = s->Next;  //从链表删除 
		free(s);  // 释放被删除结点 
		return L;
	}
}

2.11 遍历

遍历单链表时间复杂度为O(n) .
  在这里插入图片描述

template<class DataType>
void LinkList<DataType>::PrintList()
{
    Node<DataType> *p = first->next;
    while (p != NULL)
    {
        cout << p->data << endl;
        p = p->next;
    }
}

c

// 输出链表元素 
void Print(List L){
	List t;
	int flag = 1;
	printf("当前链表为：");
	for(t = L;t;t =t->Next){
		printf("%d  ",t->Data);
		flag = 0;
	}
	if(flag)
		printf("NULL");
	printf("\n"); 
}

2.12 测试

c++

int main()
{
    LinkList<int> p;
    p.Insert(1, 6);
    p.Insert(2, 9);
    p.PrintList();
    p.Insert(2, 3);
    p.PrintList();
    cout << p.Get(2) << endl;
    cout << p.Locate(9) << endl;
    cout << p.Length() << endl;
    p.Delete(1);
    p.PrintList();
    return 0;
}

c

int main(){
	L = MakeEmpty();
	Print(L);
	L = Insert(11,1,L);
	L = Insert(25,1,L);
	L = Insert(33,2,L);
	L = Insert(77,3,L);
	Print(L);
	printf("当前链表长度为：%d\n",Length(L));
	printf("此时链表中第二个结点的值是：%d\n",FindKth(2,L)->Data);
	printf("查找22是否在该链表中：");
	if(Find(22,L))
		printf("是！\n");
	else
		printf("否！\n");
	printf("查找33是否在该链表中：");
	if(Find(33,L))
		printf("是！\n");
	else
		printf("否！\n");
	L = Delete(1,L);
	L = Delete(3,L);
	printf("----------删除后-----\n"); 
	Print(L);
	return 0;
}

3. 链式存储的优缺点

优点：
插入、删除不需移动其他元素，只需改变指针.
链表各个节点在内存中空间不要求连续，空间利用率高
缺点：
查找需要遍历操作，比较麻烦

爱抖腿的小松鼠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构》C++代码 线性表
icedream61的专栏
11-27 1589
线性表，分数组和链表两种（官方名称记得是叫顺序存储和链式存储）。代码里天天用，简单写写。          首先是数组，分静态、动态两种，没什么可说的，注意动态的要手动释放内存就好了。          其次是链表，依旧分静态、动态。课内一般都是讲的是动态实现，但其实还有一种静态实现方法。动态实现剩内存，但是静态实现剩时间，考试的时候当然是要视情况而定的。但是我估计，课内考试应该不会去卡这
数据结构之线性表(C++实现)
单线程的Daniel的博客
07-27 481
数据结构之线性表线性表的特点线性表的基本操作操作的实现 线性表的特点 存在唯一的一个被称作“第一个”的数据元素 存在唯一的一个被称作“最后一个”的数据元素 除第一个外，集合中的每个数据元素均只有一个前驱 除最后一个元素外，集合中的每个数据元素均只有一个后继 线性表的基本操作 InitList(&L); 构造空的线性表L DestoryList(&L); 销毁...
c++实现线性表完整代码
11-07
c++实现线性表完整代码，内涵注释，可视化操作线性表。
线性表 c++语言代码,《数据结构之线性篇》-线性表的C++实现
weixin_29310853的博客
05-22 265
#pragma once#ifndef _LIST_H_#define _LIST_H_#includeusing namespace std;templateclass List{public:List(int size);~List();void ClearList();bool isEmpty();//检测线性表是否为空int ListLength();//获取线性表的长度bool GetE...
数据结构 线性表 代码
12-08
数据结构中有关线性表的代码实现，完成了线性表创建，插入，删除，查找等功能。
C++语言笔试-19.docx
最新发布
11-02
【C++语言笔试-19】的题目涵盖了C++编程语言的基础知识，数据结构与算法，以及软件工程的相关概念。以下是对这些知识点的详细解释： 1. **栈**：栈是一种后进先出（LIFO）的数据结构。当元素依次入栈后再依次出栈时...
C++语言笔试-19.pdf
11-02
循环队列是线性数据结构的一种，它利用数组的循环特性来模拟队列的头部和尾部。循环队列需要队头和队尾两个指针来跟踪元素，队头指针指向第一个元素，队尾指针指向最后一个元素的下一个位置。队列中元素的动态变化...
清华大学数据结构计划20071
08-08
此外，课程还包括实践项目——**制作《可重用的数据结构类库与函数库》**，旨在让学生通过实际编程加深理解，创建具有通用性的类库和函数库，要求提供清晰的接口和文档，以及性能分析。 教材方面，推荐使用殷人昆、...
2021-2022计算机二级等级考试试题及答案No.3415.docx
11-01
数据结构——栈 - **知识点概述**：栈是一种基本的数据结构。 - **详细说明**： - 栈遵循后进先出（LIFO）的原则，即最后添加的元素最先被取出。 - 支持子程序调用的数据结构通常是栈。 ### 21. Java中的同步...
2021-2022计算机二级等级考试试题及答案No.13604.docx
10-27
数据结构——队列的应用 - **知识点**: 队列是一种特殊的线性表，只允许在表的一端进行插入操作，在另一端进行删除操作，具有先进先出的特点。 - **题目解析**: 题目询问与队列结构有关联的选项。正确答案D表示...
数据结构之线性表全部代码
07-01
数据结构实用教程之线性表的应用，里面有线性表的定义以及应用，线性表的应用包含 两个有序表的合并、集合运算、一元多项式的表示和相加
线性表（c++代码）
03-14
数据结构：线性表的创建、插入、查找、删除 vector的简单应用
数据结构C++有关线性表的源代码
03-27
本资源是有关数据结构C++有关线性表的源代码，里面提供了相关的程序，大家可以参考参考。
线性表源代码（C/C++）
12-23
完全正确的线性表源代码，绝对正确，保证运行
2021-12-18 数据结构——线性表(上) (c++代码和c代码)
名幕新星的博客
12-17 1308
线性表是最基本、最简单、也是最常用的一种数据结构。==线性表（linear list）==是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 1.基本概念 线性表：零个或多个数据元素的有限序列。 线性表：包括顺序表和链表 顺序表（数组）：里面元素的地址是连续的， 链表：链表里面节点的地址不是连续的，是通过指针连起来的。 表中元素个数称为线性表的长度 线性表没有元素时，称为空表 表起始位置称为表头，表结束位置称表尾 2. 线性表的抽象数据类型 类型名称：线性表（List） 操作集：线性表 L
数据结构之线性表/顺序存储/C++代码实现
weixin_45118086的博客
03-25 429
线性表 线性表有两种存储方式：连续存储与链接存储。先更线性存储，连接存储待更。 线性表是由n个元素组成的有序序列。 连续存储 线性表的元素存储在一个表中，表的大小是固定的，大于或等于要表示的线性表的最大长度。 线性表的结点： struct ListNode{ Elemtype elem;//线性表存储的数据类型 } 线性表： struct List{ Elemtype* node;//连续存储的首位置 int length;//当前存储的数据个数 int listsize;//当前表的剩余容量 }
C++数据结构和算法每天一练(线性表)
weixin_30730151的博客
06-21 99
#include <iostream> using namespace std; class ArrayLinerTable { public: void InitLinerTable(int); //初始化线性表 void MakeEmpty() ;//清空线性表 int GetLength() ;//获取长度 in...
数据结构线性表（C++ ）
chaichai126的博客
10-24 579
我自由了
数据结构之线性表（C++实现）
qq_47471199的博客
09-10 1035
顺序表 函数声明 List.h（顺序表的定义，各项功能和变量） #pragma once #ifndef LIST_H #define LIST_H #endif #define Elem int class List { public: List(int size);//创建线性表 ~List();//销毁线性表 void ClearList();//清空线性宝 bool ListEmpty();//判断线性表是否为空 int ListLengh();//获取线性表的长度 bool GetE
C语言实现的数据结构：线性表操作源代码
"该资源提供的是C语言实现的数据结构源代码，主要针对线性表的顺序存储结构进行了详细实现，包括初始化、判断空表、清除表、获取表长、获取指定位置元素等功能。" 在数据结构中，线性表是一种基本且重要的数据组织...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值