【数据结构】线性表-单链表（图解、c++、java）

已于 2022-06-07 11:43:21 修改
阅读量1.1k 收藏 4
点赞数 2
分类专栏： URLeisure的数据结构之旅 文章标签： 数据结构 java c++ 链表 图解法
于 2022-01-13 11:32:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50564032/article/details/122463711
版权

文章目录

GitHub同步更新（已分类）：Data_Structure_And_Algorithm-Review

公众号：URLeisure 的复习仓库
公众号二维码见文末

以下是本篇文章正文内容，下面案例可供参考。

什么是链表？

  • 链表是线性表的链式存储方式。
  • 逻辑上相邻的数据在计算机内的存储位置不一定相邻。
  • 链表由节点组成，每个节点都包含下一个节点的指针。

单链表的存储方式（图解）

指针

  • 给每个元素附加一个指针域，指向下一个元素的存储位置。

  • 由图可以看出，每个节点包含两个域：数据域和指针域。

  • 数据域存储元素，指针域存储下一个节点的地址，因此指针指向的类型也是节点类型。

  • 每个指针都指向下一个节点，都是朝一个方向的，这样的链表称为单向链表或单链表。

  • 脑里有图的话，链表学起来还是很简单的。

单链表的基本操作

  • 首先定义一个结构体（内部类），包含数据域与指针域。

c++代码如下（示例）：

typedef struct LNode{
    int date;
    LNode *next;
}*LinkList;

java代码如下（示例）：

private class LNode{
 	int date;
	LNode next;
}

1.初始化

  • 单链表的初始化是指构建一个空表。
  • 先创建一个头节点，不存储数据，然后令其指针域为空（判断终止时会用到）。

c++代码如下（示例）：

bool InitList(LinkList &L){
    L = new LNode;//生成新节点
    if(!L){//鲁棒
        return false;
    }
    L->date = 0;
    L->next = NULL;//下一个节点为空
    return true;
}

java代码如下（示例）：

public boolean init(){
	lnode = new LNode(
	if(lnode==null){
     	return false;
   	}	
    lnode.next = null;
    return true;
}

2.创建

  • 创建单链表分为头插法和尾插法两种。

  • 头插法是指每次把新节点插到头节点之后，其创建的单链表和数据输入顺序正好相反，因此也称为逆序建表。

头插法

  • 头插法，就是新指针插到头指针后面。也就是上次插入元素的前面。

  • 很明显可以看出，输出顺序与输入顺序相反。有一种栈（后进先出）的感觉，后面栈链的实现也是使用的这种方法。

c++代码如下（示例）：

void CreateList_H(LinkList &L,int n){
    LinkList s;
    while(n--){
        s = new LNode;
        cin>>s->date;
        //新节点next替换头节点next
        s->next = L->next;
        L->next = s;
    }
}

java代码如下（示例）：

public void create_H(int n){
	LNode s;
	while(n-- > 0){
		s = new LNode();
		s.date = input.nextInt();
		s.next = lnode.next;
        lnode.next = s;
    }
}
  • 尾插法是指每次把新节点链接到链表尾部，其创建的单链表和数据输入顺序一致，因此也称为正序建表。

在这里插入图片描述

  • 尾插法，将新节点链接到尾节点（r）后面，非常的简单。

  • 注意新节点的指针域与尾结点的更新。

c++代码如下（示例）：

void CreateList_R(LinkList &L,int n){
    LinkList s;
    LinkList r = L;
    while(n--){
        s = new LNode;
        cin>>s->date;
        s->next = NULL;
        r->next = s;//节点连上
        r = s;//更新尾节点
    }
}

java代码如下（示例）：

public void create_R(int n){
   	LNode s,r = lnode;
    while(n-- > 0){
      	s = new LNode();
        s.date = input.nextInt();
        s.next = null;
        r.next = s;
        r = s;
   	}
}

3.取值

  • 单链表的取值不像顺序表那样可以随机访问任何一个元素，单链表只有头指针，各个节点的物理地址是不连续的。

  • 要想找到第 i 个节点，就必须从第一个节点开始顺序向后找，一直找到第 i 个节点。

c++代码如下（示例）：

bool GetElem(LinkList L,int i,int &e) {//i 查看第i个元素 e为此元素的值 
    LinkList p = L->next;
    int j = 1;
    while (p && j < i) {
        p = p->next;
        j++;
    }
    if (!p) {
        return false;
    }
    e = p->date;
    return true;
}

java代码如下（示例）：

public int get(int i){
   	LNode p = lnode.next;
    int j = 1;
    while(p!=null && j<i){
  	   p = p.next;
       j++;
    }
    if(p==null && j>i){
       return -1;
    }
    return p.date;
}

4.查找

  • 查找是否存在元素 e，可以定义一个 p 指针，指向第一个元素节点，比较 p 指向节点的数据域是否等于 e。

c++代码如下（示例）：

bool LocateElem(LinkList L,int e){
    LinkList p = L->next;
    while(p && p->date!=e){
        p = p->next;
    }
    if(!p)//不存在e时，p == NULL
        return false;
    return true;
}

java代码如下（示例）：

public int locate(int e){
  	LNode p = lnode.next;
    int i = 1;
    while(p!=null && p.date!=e){
    	  p = p.next;
          i++;
   	}
    if(p == null){
          return -1;
    }
    return i;
}

5.插入

插入

  • 要在第i个节点前插入一个元素，则必须先找到第i-1个节点。

  • 因为单链表只有一个指针域，是向后操作的，无法向前操作。

c++代码如下（示例）：

bool ListInsert(LinkList &L,int i,int e){//第i个位置插入元素e
    LinkList p = L;
    int j = 0;
    while(p && j<i-1){//寻找前一个
        p = p->next;
        j++;
    }
    if(!p || j>i-1){//防止i超出范围（i<1 || i>length）
        return false;
    }
    LinkList s = new LNode;
    s->date = e;
    s->next = p->next;
    p->next = s;
    return true;
}

java代码如下（示例）：

public boolean insert(int i,int e){
  	LNode s,p = lnode;
    int j = 0;
    while(p!=null && j<i-1){
       	p = p.next;
        j++;
    }
    if(p==null || j>i-1){
        return false;
    }
    s = new LNode();
    s.date = e;
    s.next = p.next;
    p.next = s;
    return true;
}

6.删除

删除

  • 删除一个节点，实际上是把这个节点跳过去。

  • 根据点链表向后操作的特性，要跳过第i个节点，就必须先找到第i-1个节点。

  • 删除同时，c++需要释放内存。

c++代码如下（示例）：

bool ListDelete(LinkList &L,int i,int &e){//删除第i个位置 记录删除的元素值e
    LinkList p = L;
    int j = 0;
    while(p && j<i-1){
        p = p->next;
        j++;
    }
    if(!p || j>i-1){//防止i超出范围（i<1 || i>length）
        return false;
    }
    LinkList q = p->next;
    p->next = q->next;
    e = q->date;
    delete q;
    return true;
}

java代码如下（示例）：

public int delete(int i){
    LNode q,p = lnode;
    int j = 0;
    while(p!=null && j<i-1){
      	p = p.next;
        j++;
   	}
    if(p==null || j>i-1){
        return -1;
    }
    q = p.next;
    p.next = q.next;
    return q.date;
}

7.打印

  • 打印非常简单，直接上代码。

c++代码如下（示例）：

void PrintList(LinkList L){
    LinkList p = L->next;
    while(p){
        cout<<p->date<<" ";
        p = p->next;
    }
    cout<<endl;
}

java代码如下（示例）：

public void print(){
   	LNode p = lnode.next;
    while(p != null){
     	System.out.print(p.date+" ");
        p = p.next;
    }
    System.out.println();
}

8.释放内存

  • c++需要手动释放内存，而java不需要。

c++代码如下（示例）：

void DestroyList(LinkList &L){
    LinkList tmp;
    for(LinkList cur = L->next;cur!=NULL;){
        tmp = cur;
        cur = cur->next;
        delete tmp;
    }
    delete L;
}

完整代码

c++代码如下（示例）：

#include<iostream>

using namespace std;

typedef struct LNode {
    int date;
    LNode *next;
} *LinkList;

bool InitList(LinkList &L) {
    L = new LNode;
    if (!L) {
        return false;
    }
    L->next = NULL;
    return true;
}

void CreateList_H(LinkList &L) {
    printf("输入要插入的个数\n");
    int n;
    cin >> n;
    LinkList L1;
    printf("输入elem\n");
    while (n--) {
        L1 = new LNode;
        cin >> L1->date;
        L1->next = L->next;
        L->next = L1;
    }
}

void CreateList_R(LinkList &L) {

    int n;
    cin >> n;
    LinkList s, r;
    r = L;
    while (n--) {
        s = new LNode;
        cin >> s->date;
        s->next = NULL;
        r->next = s;
        r = s;
    }
}

bool GetElem(LinkList L, int i, int &e) {
    int j = 1;
    LinkList p;
    p = L->next;
    while (j < i && p) {
        p = p->next;
        j++;
    }
    if (p == NULL) {
        return -1;
    }
    e = p->date;
    return true;
}

bool LocateElem_L(LinkList L, int e) {
    LinkList p = L->next;
    while (p && p->date != e) {
        p = p->next;
    }
    if (!p) {
        return false;
    }
    return true;
}

bool ListInsert_L(LinkList &L, int i, int e) {
    LinkList p = L;
    int j = 0;
    while (p && j < i - 1) {
        p = p->next;
        j++;
    }

    if (!p) {
        return false;
    }

    LinkList n = new LNode;
    n->date = e;
    n->next = p->next;
    p->next = n;
    return true;
}

bool ListDelete_L(LinkList &L, int i, int &e) {
    LinkList p = L, q;
    int j = 0;
    while (p && j < i - 1) {
        p = p->next;
        j++;
    }
    if (!p) {
        return false;
    }
    q = p->next;
    p->next = q->next;
    delete q;
    return true;
}

void ListPrint_L(LinkList L) {
    LinkList p = L->next;
    while (p) {
        printf("%d ", p->date);
        p = p->next;

    }
    puts("");
}

void ListFree_L(LinkList L) {
    LinkList temp;
    for (LinkList cur = L->next; cur != NULL;) {
        temp = cur;
        cur = cur->next;
        delete temp;
        temp = NULL;
    }
    L = NULL;
}

int main() {
    LinkList L;
    int i, e, x;

    InitList(L);//初始化表

    CreateList_H(L);//头插法

    //CreateList_R(L);//尾插法

    cin >> i;//取值
    GetElem(L, i, e);
    cout << "第" << i << "个元素是" << e << endl;

    cin >> x;//查找
    if (LocateElem_L(L, x)) {
        cout << "查找成功" << endl;
    } else {
        cout << "查找失败" << endl;
    }

    cin >> i >> e;//插入 位置-元素
    ListInsert_L(L, i, e);

    cin >> i;//删除
    ListDelete_L(L, i, e);
    cout << "已删除" << e << endl;
    ListPrint_L(L);//打印

    ListFree_L(L);//释放空间

    return 0;
}

java代码如下（示例）：

import java.util.Scanner;

public class A {

    public static class LNode {
        int date;
        LNode next;
    }

    public static boolean init(LNode L) {
        L = new LNode();

        L.next = null;
        return true;
    }

    public static void create_h(LNode L) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入几个？");
        int n = sc.nextInt();
        LNode s;
        while (n > 0) {
            s = new LNode();
            s.date = sc.nextInt();
            s.next = L.next;
            L.next = s;
            n--;
        }
    }

    public static void create_r(LNode L) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入几个？");
        int n = sc.nextInt();
        LNode p = L, s;
        while (n > 0) {
            s = new LNode();
            s.date = sc.nextInt();
            s.next = null;
            p.next = s;
            p = s;
            n--;
        }
    }

    public static int get(LNode L, int i) {
        LNode p = L.next;
        int j = 1;
        while (p != null && j < i) {
            p = p.next;
            j++;
        }
        if (p == null) {
            return -1;
        }
        return p.date;
    }

    public static int locate(LNode L, int e) {
        LNode p = L.next;
        int i = 1;
        while (p != null && p.date != e) {
            p = p.next;
            i++;
        }
        if (p == null) {
            return -1;
        }

        return i;
    }

    public static boolean insert(LNode L, int i, int e) {
        LNode p = L;
        LNode s = new LNode();
        int j = 0;
        while (p != null && j < i - 1) {
            p = p.next;
            j++;
        }
        if (p == null) {
            return false;
        }
        s.date = e;
        s.next = p.next;
        p.next = s;
        return true;
    }

    public static boolean delete(LNode L, int i) {
        LNode p = L;
        LNode s;
        int j = 0;
        while (p != null && j < i - 1) {
            p = p.next;
            j++;
        }
        if (p == null) {
            return false;
        }
        s = p.next;
        p.next = s.next;
        return true;
    }

    public static void print(LNode L) {
        LNode p = L.next;
        while (p != null) {
            System.out.print(p.date + " ");
            p = p.next;
        }
    }

    public static void main(String[] args) {
        LNode L = new LNode();
        Scanner sc = new Scanner(System.in);

        int e, i;
        init(L);
        System.out.println("1.头插法\n2.尾插法");

        int ch = sc.nextInt();
        if (ch == 1) {
            create_h(L);
        } else {
            create_r(L);
        }

        i = sc.nextInt();//取值
        e = get(L, i);
        System.out.println("第" + i + "个元素为" + e);
        
        e = sc.nextInt();//查询
        i = locate(L, e);
        System.out.println(e + "是第" + i + "个元素！");
        
        //插入 位置-元素
        i = sc.nextInt();
        e = sc.nextInt();
        insert(L, i, e);

        i = sc.nextInt();//删除
        delete(L, i);

        print(L);
    }
}

总结

  • 在单链表中，每个节点除了存储自身数据之外，还存储了下一个节点的地址，因此可以轻松访问下一个节点，以及后面的所有后继节点。
  • 但是，如果想访问前面的节点就不行了，是回不去的。
  • 如果要向前操作，就需要用下下下一篇文章的另外一种链表——双向链表。
关注公众号，感受不同的阅读体验

请添加图片描述

下期预告： 顺序队列-单向队列

扑腾的江鱼
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构线性表-顺序表（c++、java）.pdf
11-12
顺序表的实现c ++ 源代码
单链表详细解析|画图理解
wangjiushun的博客
09-26 486
无头单向非循环链表详解
(五）数据结构-单链表
zhufei463738313的博客
03-06 356
1. 链表是以节点的方式来存储，是链式存储； 2. 每个节点包含 data 域，next 域，next 域指向下一个节点； 3. 如图：发现链表的各个节点不一定是连续存放的； 4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。
今天小胡杨手绘28张图只为教会你单链表
m0_64770095的博客
04-27 3039
学数据结构你不画图吗？ 小胡杨今天手绘30张图，12个函数接口手把手教你实现，必须教会你单链表的实现。
【玩转链表①】单链表动图图解（超详解）
罅隙的博客
03-17 3493
全网最全面细致的单链表讲解
单链表图画解析
v_one的博客
07-08 596
实现一个单链表，链表初始为空，支持三种操作： 现在要对该链表进行 M次操作，进行完所有操作后，从头到尾输出整个链表。注意:题目中第 k个插入的数并不是指当前链表的第 k 个数。 例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为： 第 1 个插入的数，第 2 个插入的数，…第 n个插入的数。 输入格式第一行包含整数 M，表示操作次数。接下来 M行，每行包含一个操作命令，操作命令可能为以下几种： 输出格式共一行，将整个链表从头到尾输出。 数据范围1≤M≤100000所有操作保
数据结构-线性表-单链表的查找、插入、删除.doc
10-10
数据结构-线性表-单链表的查找、插入、删除.doc
实验1-2 线性表-单链表.doc
最新发布
04-11
实验1-2 线性表-单链表.doc
C++ 数据结构线性表-数组实现
08-30
主要介绍了C++ 数据结构线性表-数组实现的相关资料,需要的朋友可以参考下
【数据结构】单链表（带图详解）
Z1tai的博客
05-12 9587
概念：链表是一种物理存储结构上非连续非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
单链表-----数据结构
lwd2621的博客
03-28 323
//测出链表表长  int ListLength_L(LinkList L) { p=L; k=0; while(p) { k++; p=p->next; } return k; } //查找元素  LNode * LocateELem_L(LinkList L,ElemType e) { p=L; while(p&&p->date!=e) p=p->
数据结构3：单向链表实现及图解
m0_53607711的博客
10-03 1296
头删的逻辑也不算困难，理解了二级指针之后就非常容易了。
数据结构之单链表的增删查改等操作画图详解
小赵小赵福星高照的博客
08-05 2333
单链表 文章目录单链表链表的概念及其结构概念结构链表的实现开辟一个新结点链表的销毁打印链表单链表的尾插单链表的头插单链表的头删单链表的尾删找到单链表中的一个结点在pos位置后插入结点在pos位置前插入一个结点pos位置后删除结点pos位置删除结点返回链表大小判断链表是否为空源代码SList.h(单链表结构及其函数的声明)SList.c(单链表函数的实现)test.c(单链表功能的测试) 为什么有了顺序表，还需要有链表这样的数据结构呢？ 顺序表存在的问题： 中间或者头部插入删除，需要挪动数据时间复杂度为
数据结构——单向链表
m0_45364328的博客
05-10 693
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录链表的介绍单链表的介绍单链表的应用实例我在编写第二种方式犯的错误：单链表的常见面试题有如下 链表的介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表的介绍 单链表(带头结点) 逻辑结构示意图如下 单链表的应用实例.
【第二章 - 线性表之单链表】- 数据结构
melonyzzZ的博客
03-01 308
详解数据结构第二章 - 线性表之单链表
线性表之单链表
weixin_61932507的博客
03-17 828
链表 1.链表的概念及结构 概念：连表示一种屋里存储结构上的非连续，非吮吸的储存结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 物理上：1.链式结构在逻辑上是连续的，但在物理上不一定连续。 2.现实中的节点一般都是从对上申请出来的。 3.从对上申请空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。 2.链表的分类 1.单向或者双向 2.带头或者不带头 3.循环或者非循环 共计8种 最常用的两种链表：无头单向非循环链表 和 带头双向循环链表 ..
线性表—单链表
qq_39172845的博客
03-16 1111
C++模板类实现单链表以及常用操作
【数据结构从菜鸟到大牛】链表（画图教你手撕单链表）
K_04_10的博客
04-30 1309
📑前言 🌝顺序表优点 之前我们学习了顺序表，其本质就是数组 了解了顺序表是有自己的优点的： 物理空间连续 下标随机访问 我只要知道了首元素的地址，就可以访问顺序表的所有的元素 😅顺序表缺点 空间不够，需要扩容。扩容就有一定的性能消耗，其次一般扩容2倍，存在一些空间浪费 头部或者中间位置插入删除的效率低下，需要挪动---O(N)，尾插尾删比较容易 ⚒️改善方案 1.按需申请释放空间 需要一个就申请一个 ，哪一个不用了我们就释放哪一个 这样开辟的是一个一个的单独独立的空间，...
线性表—单链表、循环链表、双向链表。
weixin_46153942的博客
01-27 1881
单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 链表的存取必须从头指针开始，头指针指示链表的第一个结点（即第一个数据元素的存储映像，也称首元结点）。同时，最后一个数据元素没有直接后继，最后一个结...
用C语言实现单链表遍历
06-11
以下是用C语言实现单链表遍历的代码示例： ```c #include <stdio.h> #include <stdlib.h> // 定义单链表节点结构体 typedef struct ListNode { int val; struct ListNode* next; } ListNode; // 遍历单链表 void traverseList(ListNode* head) { ListNode* p = head; while (p != NULL) { // 对每个节点执行操作，这里输出节点的值 printf("%d ", p->val); // 指针p指向下一个节点 p = p->next; } } int main() { // 创建单链表 ListNode* head = (ListNode*)malloc(sizeof(ListNode)); head->val = 1; head->next = NULL; ListNode* node1 = (ListNode*)malloc(sizeof(ListNode)); node1->val = 2; node1->next = NULL; head->next = node1; ListNode* node2 = (ListNode*)malloc(sizeof(ListNode)); node2->val = 3; node2->next = NULL; node1->next = node2; // 遍历单链表 traverseList(head); // 释放内存 free(head); free(node1); free(node2); return 0; } ``` 在遍历单链表时，需要注意链表为空的情况，即头节点为空。此时直接返回即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

扑腾的江鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值