数据结构--02(链表)

最新推荐文章于 2024-04-13 16:10:05 发布
最新推荐文章于 2024-04-13 16:10:05 发布
阅读量212 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37650458/article/details/117202463
版权

目录

 

1.链表的重要性

​

  2.链表的实现 

 

3.使用链表的虚拟头结点（链表技巧）

4.链表的遍历查询和修改

链表的删除

​

时间复杂度分析

1.链表的重要性

  2.链表的实现 

对于链表来说我们想要访问存在在这个链表的所有节点，必须存放他的头

 往链表中添加元素

 

在链表的中间添加新的元素,在索引为2的地方添加元素666

思路：你得先找到索引为2的前一个元素是什么，只能通过遍历，找到索引为1的元素，然后创建出新的元素，索引为1的next赋值给新元素的next，新元素赋值给索引为1的next

自己先写出来，

实现链表元素的添加和输出

package com.wx.test01.data;

/**
 * Created by wangxiang on 2021/5/25
 */
public class LinkedList<E> {

    /**
     * 设计成私有的内部类
     */
    private class Node {
        public E e;
        /**
         * 设计成公有的属性，方便外部类操作，且不需要get set方法
         */
        public Node next;

        public Node(E e, Node node) {
            this.e = e;
            this.next = node;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    /**
     * 整条链表的头
     */
    private Node head;
    /**
     * 链表的容量
     */
    int size;

    /**
     * 返回
     *
     * @return
     */
    public int getLinkedSize() {
        return this.size;
    }

    /**
     * 往链表的首部添加元素
     *
     * @param e
     */
    public void addFirstNode(E e) {
        Node node = new Node(e, head);
        head = node;
        size++;
    }

    /**
     * 往链表的中间添加元素
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed!.Illegal index.");
        }
        if (index == 0) {
            addFirstNode(e);
        }
        //找到前index元素，pre
//        Node node = new Node(e);
        Node pre = head;
        for (int i = 0; i < index - 1; i++) {
            pre = pre.next;
        }
        // 目前这个pre 就是index位置的前一个节点
//        node.next = pre.next;
//        pre.next = node;

        pre.next = new Node(e, pre.next);
        size++;
    }

    /**
     * 在链表的末尾添加元素
     *
     * @param e
     */
    public void addLast(E e) {
        add(size, e);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node pre = head;
        for (int i = 0; i <= size - 1; i++) {
            sb.append(pre.e).append("->");
            pre = pre.next;
        }
        sb.append("NULL");
        return sb.toString();
    }


}

 输出：

 

 

3.使用链表的虚拟头结点（链表技巧）

   这样链表中所有的元素都不具有特殊性，因为他们都有前一个元素,这个虚拟的头节点是一个存null数据的节点，而他本身并不是null

 

  添加虚拟头节点：

package com.wx.test01.data;

/**
 * Created by wangxiang on 2021/5/25
 */
public class LinkedList<E> {

    /**
     * 设计成私有的内部类
     */
    private class Node {
        public E e;
        /**
         * 设计成公有的属性，方便外部类操作，且不需要get set方法
         */
        public Node next;

        public Node(E e, Node node) {
            this.e = e;
            this.next = node;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    /**
     * 整条链表的虚拟头节点
     */
    private Node dummyHead;
    /**
     * 链表的容量
     */
    int size;

    public LinkedList() {
        dummyHead = new Node();
        size = 0;
    }

    /**
     * 返回
     *
     * @return
     */
    public int getLinkedSize() {
        return this.size;
    }

    /**
     * 往链表的首部添加元素
     *
     * @param e
     */
    public void addFirstNode(E e) {
        add(0, e);
    }

    /**
     * 往链表的中间添加元素
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed!.Illegal index.");
        }
        Node pre = dummyHead;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        // 目前这个pre 就是index位置的前一个节点
        pre.next = new Node(e, pre.next);
        size++;
    }

    /**
     * 在链表的末尾添加元素
     *
     * @param e
     */
    public void addLast(E e) {
        add(size, e);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node pre = dummyHead.next;
        for (int i = 0; i <size; i++) {
            sb.append(pre.e).append("->");
            pre = pre.next;
        }
        sb.append("NULL");
        return sb.toString();
    }


}

 输出：

4.链表的遍历查询和修改

跟新链表中的元素

链表的删除

 

package com.wx.test01.data;

/**
 * Created by wangxiang on 2021/5/25
 */
public class LinkedList<E> {

    /**
     * 设计成私有的内部类
     */
    private class Node {
        public E e;
        /**
         * 设计成公有的属性，方便外部类操作，且不需要get set方法
         */
        public Node next;

        public Node(E e, Node node) {
            this.e = e;
            this.next = node;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    /**
     * 整条链表的虚拟头节点
     */
    private Node dummyHead;
    /**
     * 链表的容量
     */
    int size;

    public LinkedList() {
        dummyHead = new Node();
        size = 0;
    }

    /**
     * 返回
     *
     * @return
     */
    public int getLinkedSize() {
        return this.size;
    }

    /**
     * 往链表的首部添加元素
     *
     * @param e
     */
    public void addFirstNode(E e) {
        add(0, e);
    }

    /**
     * 往链表的中间添加元素
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed!.Illegal index.");
        }
        Node pre = dummyHead;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        // 目前这个pre 就是index位置的前一个节点
        pre.next = new Node(e, pre.next);
        size++;
    }

    /**
     * 在链表的末尾添加元素
     *
     * @param e
     */
    public void addLast(E e) {
        add(size, e);
    }

    /**
     * 链表的遍历查询
     *
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed!.Illegal index.");
        }
        Node pre = dummyHead.next;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        return pre.e;
    }

    /**
     * 获得链表的第一个元素
     *
     * @return
     */
    public E getFirst() {
        return get(0);
    }

    /**
     * 获得链表的最后一个元素
     *
     * @return
     */
    public E getLast() {
        return get(size - 1);
    }


    /**
     * 修改链表中的元素
     *
     * @param index
     * @param e
     */
    public void set(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed!.Illegal index.");
        }
        Node pre = dummyHead.next;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        pre.e = e;
    }

    /**
     * 链表中是否包含一个元素
     *
     * @param e
     * @return
     */
    public boolean contains(E e) {
        Node pre = dummyHead.next;
        for (int i = 0; i < size; i++) {
            if (pre.e.equals(e)) {
                return true;
            }
            pre = pre.next;
        }
        return false;
    }

    /**
     * 从链表中删除一个元素
     *
     * @param e
     */
    public void remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed!.Illegal index.");
        }
        //删除元素的时候这里需要注意一下。要找到的是这个元素的前一个元素
        Node pre = dummyHead;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        Node removeE = pre.next;
        pre.next = removeE.next;
        removeE.next = null;
        size--;

    }


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Node pre = dummyHead.next;
        for (int i = 0; i < size; i++) {
            sb.append(pre.e).append("->");
            pre = pre.next;
        }
        sb.append("NULL");
        return sb.toString();
    }


}

时间复杂度分析

 

 

 

 

 

 

时空恋旅人
关注
专栏目录
创建和遍历链表
02-18
简单实用的创建和遍历链表代码
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
链表的遍历
2401_83430041的博客
04-13 342
链表的遍历
链表的创建与遍历
数据库天地
08-18 323
链表，简而言之，就是基于链式储存结构下的线性表。链表包括单向链表、双向链表以及循环链表。 链表是一种很常用的数据结构，其定义如下： /** * 单向链表的定义 * 定义说明：包括数据域和指针域 */ typedef int ElemType; typedef struct node { ElemType data; struct node *next; ...
遍历链表
weixin_42900834的博客
02-18 4314
1.如果链表中的数据不连续，只需要把链表中的头节点拿出来（point=head,定义指针指向链表的头），利用指针，可以遍历整个链表。 2.代码实现 #include <stdio.h> struct Test { int data;//定义结构体的数据 struct Test *next;//定义结构体的指针 }; void printlink(struct Test *head) { struct Test *point;//对链表进行索引
链表_数据结构--链表_
10-01
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。与数组不同，链表的元素不是在内存中连续存储，而是通过节点之间的引用连接起来。每个节点通常包含两个部分：数据...
数据结构-循环链表-C语言实现约瑟夫圈-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及使用循环链表实现的约瑟夫圈的main.c文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 此外循环...
2.C-数据结构-线性表-链表源码
最新发布
09-07
2.C-数据结构-线性表-顺序表源码
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
单向链表(一) 结构体、创建链表、遍历链表
07-31
单向链表(一) 结构体、创建链表、遍历链表
遍历一个链表
我的网络笔记本
12-05 738
for (map = config_maps; map; map = map->next)
链表遍历，链表查找和统计节点，链表插入新节点，链表删除节点，链表修改指定节点,链表头插法，尾插法总结
wei_Embedded_z的博客
08-26 373
链表遍历，链表查找和统计节点，链表插入新节点，链表删除节点，链表修改指定节点,链表头插法，尾插法总结 1.链表静态增加和动态遍历 2.统计链表节点各数及链表查找 3.链表从指定节点后方插入新节点 4.链表从指定节点前方插入新节点 5.链表删除指定节点 6.头插法动态创建链表 7.尾插法动态创建链表
单链表的遍历
m0_57248752的博客
03-13 2248
单链表的简单介绍和遍历
链表（四）遍历链表
m0_60977861的博客
03-17 7592
从链表头开始，涉及整个链表，在每个结点上操作的过程称为遍历链表 假设链表的链表头指针是namelist，要遍历链表，则需要另一个指针ptr指向链表的开头。 listnode* ptr = head; 然后可以使用表达式*ptr或者结构指针操作符->处理由ptr指向的结点。 需要打印节点上的值 cout << ptr->name << endl; 一旦该节点打印完毕，那么指针将会移动到下一个节点 ptr = ptr -> next1; 以上语句
自定义链表 遍历
无名万物
09-19 233
定义节点 1、单向链表，每个节点都有一个数据域和一个指针域，数据域存储该节点的数据，指针域指向下一个节点。节点定义如下： class ListNode&lt;T&gt;{ T val; ListNode next; public ListNode(T val){ this.val = val; } } 主函数 public class ListNodeDemo{ public s...
算法基础-链表的遍历
liukunc9的博客
08-14 551
java链表的遍历
数据结构与算法（六）--链表的遍历，查询和修改，删除操作
学习不止境的博客
09-22 1077
我们了解了链表的概念以及链表底层的搭建以及向链表中添加元素的操作。本次我们继续学习链表剩余的操作：遍历，查询和修改、删除操作。
链表的遍历、创建、插入、删除
qq_41603966的博客
07-27 634
链表的遍历、创建、插入、删除 首先创建一个结构体类型： struct Student{ int num; char name[128]; struct Student *next; }; 在主函数main中定义顶一个head作为链表的头指针，用来做遍历、创建、插入、删除 int main() { struct Student *head; head=initStudent(head); lian...
数据结构-链表合并示例与解析
在这个示例中，合并节点是数据结构中的一个基本操作，特别是在链表处理中。当有两个链表，每个链表的节点分别包含特定的值（如-7和-2），合并它们意味着创建一个新的链表，其中包含两个原始链表的所有节点，且保持...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

时空恋旅人

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

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

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

打赏作者

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

抵扣说明：

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

余额充值