（Data Structure）数据结构第二章 线性表（Linear List）

已于 2023-03-21 08:19:35 修改
阅读量184 收藏 1
点赞数 2
文章标签： 数据结构 list 算法
于 2023-03-16 21:34:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73120357/article/details/129569166
版权

第2章 线性表（Linear List）

2.1 线性表的定义与基本概念

线性表是数据结构的一种
定义：n(≥0)个具有相同特性数据元素的有限序列

线性表的特性有以下几点 ：

  • 线性表是由零个或多个数据元素组成的有限序列，每个元素都是单个元素
  • 线性表中必存在唯一的一个第一个元素和最后一个元素
  • 除了第一个和最后一个元素外，每个元素都有唯一的前驱和后继
  • 线性表可以用顺序存储结构或链式存储结构来实现，顺序存储结构可以实现随机存取，链式存储结构可以方便地插入和删除

线性表的抽象数据类型定义
在这里插入图片描述

2.2 线性表的顺序存储和实现

存储方式：用一组地址连续的存储单元顺序存放线性表中逻辑相邻的元素。假定每个元素需占用d个存储单元，则n个元素的线性表存储为：
在这里插入图片描述
优缺点
优点：实现相对简单——直接使用数组语法支持随机存取
缺点：插入、删除操作需要大量移动元素，需要预先分配内存空间——可能造成浪费，解决方案—链表

顺序表定义

//定义顺序表的结构体
typedef struct {
	//用数组存储数据元素
	int array[100];

	//记录顺序表的当前长度
	int size;
}sequential_list;

顺序表初始化

void seq_list(sequential_list* L) {
	L.size = 0;
}

顺序表插入

void insert_element(sequential_list* L, int index, int value) {
	//检查index是否合法
	if (index < 0 || index > L->size) {
		printf("索引无效");
		return;
	}

	//从后往前移动元素，为插入位置腾出空间
	for (int i = 98; i >= index; i--) {
		L->array[i + 1] = L->array[i];
	}

	//在index位置赋值为value
	L->array[index] = value;
	L->size++;
}

顺序表删除

//删除方法，并返回删除的值
int delete_element(sequential_list* L, int index) {
	//检查index是否合法
	if (index < 0 || index > L->size) {
		printf("索引无效");
		return -1;
	}

	//记录被删除的值
	int result = L->array[index];

	//从前往后移动元素，覆盖被删除的位置
	for (int i = index + 1; i < 99; i++) {
		L->array[i - 1] = L->array[i];
	}

	//更新有效元素个数
	L->size--;

	//返回被删除的值
	return result;
}

顺序表查找

//查找方法，在顺序表中查找value并返回其位置，如果不存在则返回-1
int search_element(sequential_list* L, int value) {
	//遍历数组，比较每个元素和value
	for (int i = 0; i < 100; i++) {
		if (L.array[i] == value) {
			//如果找到了，返回其位置
			return i;
		}
	}
	//如果没有找到，返回-1
	return -1;
}

顺序表遍历

//打印顺序表
void print_element(sequential_list* L) {
	for (int i = 0; i < L->size; i++) {
		printf("%d ", L->array[i]);
	}
	printf("\n");
}

2.3 线性表的链式存储和实现

存储方式：
用一组任意的存储单元来存储线性表中的结点。用指针（即链）实现线性表中各结点的逻辑关系。

  • 根据链接方式不同，分为∶单链表、循环链表、双向链表
  • 根据链表实现不同，分为︰静态链表、动态链表

优缺点
优点无需占据连续内存，按需申请内存，不会造成浪费，插入、删除时无需移动元素(但T(n)仍为O(n)
缺点：不支持随机存取——按位置找元素时需要遍历链，仅支持单向(从表头到表尾)遍历
在这里插入图片描述

单链表定义

//定义结构体类型
typedef struct node {
	//数据域
	int data;
	//指针域
	struct node* next;
}node;

//创建节点
node* create_node(int data) {
	//分配内存空间
	node* new_node = malloc(sizeof(node));

	//初始化节点
	new_node->data = data;
	new_node->next = NULL;

	//返回节点的地址
	return new_node;
}

单链表插入

//单链表插入
void insert_at_begin(node** head, int data) {
	//创建新节点
	node* new_node = create_node(data);

	//新节点的next指向头节点
	new_node->next = *head;

	//头指针变成新节点
	*head = new_node;
}

void insert_at_end(node** head, int data) {
	//创建新节点
	node* new_node = create_node(data);

	//不存在头节点
	if (*head == NULL) {
		//头节点变为新节点
		*head = new_node;
		return;
	}

	//遍历链表
	node* current = *head;
	while (current->next != NULL) {
		current = current->next;
	}

	//新节点连接到最后节点
	current->next = new_node;
}

单链表删除

//单链表删除
void delete_node(node** head, int data) {
	node* current = *head;
	node* previous = NULL;
	//遍历寻找data值
	while (current->next != NULL) {
		if (current->data == data) {
			//如果在第一个节点
			if (previous == NULL) {
				//头节点成为下一个节点
				*head = current->next;
			}
			else {
				//前继节点指向下下一个节点
				previous->next = current->next;
			}
			free(current);
			return;
		}
		previous = current;
		current = current->next;
	}
}

单链表遍历

//单链表打印
void print_node(node* head) {
	//遍历链表
	node* current = head;
	while (current != NULL) {
		//输出数据
		printf("%d", current->data);
		current = current->next;
	}
	printf("\n");
}

2.3.2 单向循环链表

存储特点：单向循环链表是单向链表的变形。单向循环链表最后一个结点的指针域指向头结点使整个链表形成一个环
形式一∶带头指针的单向循环链表
在这里插入图片描述
形式二∶带尾指针的单向循环链表
在这里插入图片描述

2.3.3 双向链表

存储特点：每个结点有两个指针域，其中一个指向直接后继，一个指向直接前驱。
结构特点：
在这里插入图片描述
形式一∶双向链表
在这里插入图片描述
形式二：双向循环链表
在这里插入图片描述

完整代码

C语言顺序表

#include <stdio.h>
#include <string.h>

//定义顺序表的结构体
typedef struct {
	//用数组存储数据元素
	int array[100];

	//记录顺序表的当前长度
	int size;

} sequential_list;

void seq_list(sequential_list *L);
void insert_element(sequential_list* L, int index, int value);
int delete_element(sequential_list* L, int index);
int search_element(sequential_list* L, int value);
void print_element(sequential_list* L);

int main()
{
	sequential_list L;
	seq_list(&L);
	insert_element(&L, 0, 1);
	insert_element(&L, 1, 3);
	insert_element(&L, 2, 2);
	print_element(&L);
	delete_element(&L, 1);
	print_element(&L);
	return 0;
}

//初始化
void seq_list(sequential_list* L) {
	L->size = 0;
}

//添加方法
void insert_element(sequential_list* L, int index, int value) {
	//检查index是否合法
	if (index < 0 || index > L->size) {
		printf("索引无效\n");
		return;
	}

	//从后往前移动元素，为插入位置腾出空间
	for (int i = 98; i >= index; i--) {
		L->array[i + 1] = L->array[i];
	}

	//在index位置赋值为value
	L->array[index] = value;
	L->size++;
}

//删除方法，并返回删除的值
int delete_element(sequential_list* L, int index) {
	//检查index是否合法
	if (index < 0 || index > L->size) {
		printf("索引无效");
		return -1;
	}

	//记录被删除的值
	int result = L->array[index];

	//从前往后移动元素，覆盖被删除的位置
	for (int i = index + 1; i < 99; i++) {
		L->array[i - 1] = L->array[i];
	}

	//更新有效元素个数
	L->size--;

	//返回被删除的值
	return result;
}

//查找方法，在顺序表中查找value并返回其位置，如果不存在则返回-1
int search_element(sequential_list* L, int value) {
	//遍历数组，比较每个元素和value
	for (int i = 0; i < 100; i++) {
		if (L->array[i] == value) {
			//如果找到了，返回其位置
			return i;
		}
	}
	//如果没有找到，返回-1
	return -1;
}

//打印顺序表
void print_element(sequential_list* L) {
	for (int i = 0; i < L->size; i++) {
		printf("%d ", L->array[i]);
	}
	printf("\n");
}

Java顺序表

import java.util.Arrays;

public class SequentialList {
    //数组
    private int[] array;

    //有效元素个数
    private int size;

    //构造方法，初始化数组和大小
    public SequentialList(int capacity) {
        array = new int[capacity];
        size = 0;
    }

    //插入方法，在index位置插入value
    public void insertElement(int index, int value) {
        //检查index是否合法
        if (index < 0 || index > size) {
            System.out.println("索引无效");
            return;
        }

        //检查数组是否已满
        if (size == array.length) {
            System.out.println("数组已满");
            return;
        }

        //从后往前移动元素，为插入位置腾出空间
        for (int i = size - 1; i >= index; i--) {
            array[i + 1] = array[i];
        }

        //在index位置赋值为value
        array[index] = value;
        size++;
    }

    //删除方法，在index位置删除元素，并返回被删除的值
    public int deleteElement(int index) {
        //检查index是否合法
        if (index < 0 || index > size) {
            System.out.println("索引无效");
            return -1;
        }

        //记录被删除的值
        int result = array[index];

        //从前往后移动元素，覆盖被删除的位置
        for (int i = index + 1; i < size; i++) {
            array[i - 1] = array[i];
        }

        //更新有效元素个数
        size++;

        //返回被删除的值
        return result;
    }

    //查找方法，在顺序表中查找value并返回其位置，如果不存在则返回-1
    public int searchElement(int value) {
        //遍历数组，比较每个元素和value
        for (int i = 0; i < size; i++) {
            if (array[i] == value) {
                //如果找到了，返回其位置
                return i;
            }
            //如果没有找到，返回-1
        }
        return -1;
    }

    @Override
    public String toString() {
        return "SequentialList{" +
                "array=" + Arrays.toString(array) +
                ", size=" + size +
                '}';
    }
}

C语言单链表

#include <stdio.h>
#include <stdlib.h>

//定义结构体类型
typedef struct node {
	//数据域
	int data;
	//指针域
	struct node* next;
}node;

//创建节点
node* create_node(int data) {
	//分配内存空间
	node* new_node = malloc(sizeof(node));

	//初始化节点
	new_node->data = data;
	new_node->next = NULL;

	//返回节点的地址
	return new_node;
}

//单链表插入
void insert_at_begin(node** head, int data) {
	//创建新节点
	node* new_node = create_node(data);

	//新节点的next指向头节点
	new_node->next = *head;

	//头指针变成新节点
	*head = new_node;
}

void insert_at_end(node** head, int data) {
	//创建新节点
	node* new_node = create_node(data);

	//不存在头节点
	if (*head == NULL) {
		//头节点变为新节点
		*head = new_node;
		return;
	}

	//遍历链表
	node* current = *head;
	while (current->next != NULL) {
		current = current->next;
	}

	//新节点连接到最后节点
	current->next = new_node;
}

//单链表删除
void delete_node(node** head, int data) {
	node* current = *head;
	node* previous = NULL;
	//遍历寻找data值
	while (current->next != NULL) {
		if (current->data == data) {
			//如果在第一个节点
			if (previous == NULL) {
				//头节点成为下一个节点
				*head = current->next;
			}
			else {
				//前继节点指向下下一个节点
				previous->next = current->next;
			}
			free(current);
			return;
		}
		previous = current;
		current = current->next;
	}
}

//单链表打印
void print_node(node* head) {
	//遍历链表
	node* current = head;
	while (current != NULL) {
		//输出数据
		printf("%d", current->data);
		current = current->next;
	}
	printf("\n");
}

int main()
{
	node* head = NULL;
	insert_at_begin(&head, 1);
	insert_at_begin(&head, 2);
	insert_at_begin(&head, 3);
	insert_at_begin(&head, 4);
	insert_at_begin(&head, 5);
	print_node(head);
	delete_node(&head, 3);
	print_node(head);
	return 0;
}

Java单链表

//定义节点类
class Node {
    //数据域
    int data;

    //指针域
    Node next;

    //无参构造方法
    public Node() {
    }

    //有参构造方法
    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

//定义单链表类
class LinkedList {
    //头节点
    Node head;

    public void linkedList() {
        this.head = null;
    }
    
	//头插法
    public void headInsert(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            Node node = new Node(arr[i]);
            node.next = head;
            head = node;
        }
    }

	//尾插法
    public void tailInsert(int[] arr) {
        // 尾结点
        Node tail = new Node();

        for (int i = 0; i < arr.length; i++) {
            Node node = new Node(arr[i]);

            // 如果链表为空，将头结点和尾结点都指向新结点
            // 如果链表不为空，将尾结点的next指向新结点，然后将尾结点更新为新结点
            if (head == null) {
                head = node;
                tail = node;
            } else {
                tail.next = node;
                tail = node;
            }
        }
    }

    public void printList() {
        // 辅助指针p，遍历链表
        Node p = head;

        // 当p不为空时，打印当前结点的值，并将p移动到下一个结点
        while (p != null) {
            System.out.print(p.data + " ");
            p = p.next;
        }
        // 换行
        System.out.println();
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建一个单链表类的对象
        LinkedList list = new LinkedList();

        // 创建一个数组，用来存放数据
        int[] arr = {1, 2, 3, 4, 5};

        // 使用头插法创建单链表
        list.headInsert(arr);

        // 打印单链表，应该输出5->4->3->2->1
        list.printList();
    }
}
汽水汽水
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构笔记Data Structure
sandonz的博客
07-30 468
文章目录数据结构抽象数据类型ADT（Abstract Data Type） 数据结构 数据结构： 数据对象在计算机中的组织方式 逻辑结构（线性、树、图） 数据对象必定与一系列加在其上的操作相关联 完成这些操作所用的方法就是算法 抽象数据类型ADT（Abstract Data Type） 数据类型： 数据对象集 数据集合相关联的操作集 抽象：描述数据类型的方法不依赖于具体实现 ............
《大话数据结构》：线性表
weixin_43464554的博客
01-27 153
// C语言-大话数据结构：线性表 // // Created by pengxiangzhou on 2021/1/24. // #include <form.h> #ifndef C_DS_LINEAR_LIST_H #define C_DS_LINEAR_LIST_H #endif //C_DS_LINEAR_LIST_H /*线性表-顺序存储结构 * 顺序存储结构的三个属性：数组data，存储位置为存储空间的位置；数组存储数据元素的最大值；线性表当前长度 * 数组的长度是存
【数据结构与算法】数据结构与算法之线性表Linear table（Java版）
fearless的博客
01-19 645
文章内容绪论1、概述2、时间复杂度 有想看源码的小伙伴请移步这里????https://gitee.com/fearless123/demo/tree/master/src/main/java/com/ma 绪论 1、概述 数据之间的相互关系成为逻辑结构。通常分为四类基本结构： 集合：结构中的数据元素除了同属于一种类型外，别无其它关系。 线性结构：结构中的数据元素之间存在一对一的关系。 树形结构：结构中的数据元素之间存在一对多的关系。 图状结构或网状结构：结构中的数据元素之间存在多对多的关系。 数据
数据结构-线性表
xiyandr的博客
04-25 282
此处只演示创建，清空，返回第i个位置的值 ，返回和e相同的值 #include <iostream> #include <stdlib.h> #define LIST_MAX_LENGTH 100 int overflow=0; typedef struct SequentialList { int actualLength; int *data; //The maximum length is fixed. } SequentialListPtr; void
数据结构之线性表
C2395850595的博客
04-25 188
线性表的定义： 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。 老师代码： #include <...
数据结构(Data Structure)——线性表ADT(C/C++语言)
HarvestWu的博客
04-22 2515
1.线性表定义:       线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。       在稍复杂的线性表中，一个数据元素可由多个数据项（item）组成，此种情况下常把数据元素称为记录（record），含有大量记录的线性表又称文件（file）。       线性表中的个数n定义为线性表...
数据结构概述(Data structure)
Tonywu2018的博客
04-23 7408
在计算机科学中，数据结构(data structure)是计算机中存储、组织数据的方式。在维基百科中对数据结构是这样形容的：数据结构意味着接口或封装，即一个数据结构可被视为两个函数之间的接口，或者是由数据类型联合组成的存储内容的访问方法封装。而在百度百科中对数据结构是这么形容的：数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 目录 1. 数据结构的类型 1.1 线性表(Line...
【数据结构】1.线性表
m0_60965347的博客
04-01 515
详解数据结构中的线性表，并用C语言实现
数据结构之线性表课后作业
greatwaves11的博客
04-25 934
线性表的定义 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环列表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。 分类 我们说“线性”和“非线性”，只在逻辑...
《数据结构》第二章线性表习题.doc
12-01
"《数据结构》第二章线性表习题" 本资源摘要信息对应的知识点主要涉及到数据结构的第二章线性表习题，包括线性表的定义、链式存储、顺序存储、单链表、双向循环链表、栈和队列等概念。 一、线性表的定义 线性表是...
数据结构第二章线性表c++代码
07-14
数据结构第二章线性表c++代码，由devc++软件编写，内部有静态顺序表，动态顺序表，单链表，双链表代码实现增删改查。
专升本数据结构第二章 线性表.pdf
01-14
第二章 线性表
《数据结构》第二章 线性表 思维导图
01-11
顺序表、单链表、双链表、循环链表等
数据结构：第二章 线性表.ppt
06-07
数据结构：第二章 线性表.ppt
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 1775
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
【算法与数据结构】【数组篇】【题11-题15】
最新发布
handsomethefirst的博客
06-13 1177
本人系列文章-CSDN博客。
如何使用Python中的collections模块提供的数据结构，如deque、Counter、OrderedDict等
2402_84885073的博客
06-09 507
Python 的模块提供了一些额外的数据结构，这些数据结构在内置的数据类型（如列表、字典、集合等）的基础上，增加了额外的功能或优化了性能。下面是如何使用模块中的dequeCounter和这三种数据结构的简单示例。
Go语言设计与实现 学习笔记 第三章 数据结构（1）
tus00000的博客
06-09 1202
3.1 数组 数组和切片是Go语言中常见的数据结构，很多刚刚使用Go的开发者往往会混淆这两个概念，数组作为最常见的集合在编程语言中是非常重要的，除了数组之外，Go语言引入了另一个概念——切片，切片与数组有一些类似，但是它们的不同之处导致使用上会产生巨大的差别。我们在这一节中会从Go语言的编译期间和运行时来介绍数组的底层实现原理，其中会包括数组的初始化、访问和赋值几种常见操作。 3.1.1 概述 数组是由相同类型元素的集合组成的数据结构，计算机会为数组分配一块连续的内存来保存其中的元素，我们可以利用数组中元素
数据结构第二章线性表
10-10
线性表是数据结构中最简单且常用的一种数据结构，它是由同类型的数据元素构成的有序序列。线性表具有以下特点： 1. 元素之间存在顺序关系，即元素在表中的位置是唯一确定的。 2. 线性表中的元素类型可以相同也可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值