链表的基本操作一

最新推荐文章于 2022-12-16 22:14:51 发布
最新推荐文章于 2022-12-16 22:14:51 发布
阅读量149 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_y__d_d/article/details/102518767
版权

 

链表的节点类

class LinkedNode{//节点
    public int data;
    public LinkedNode next = null;
    public LinkedNode(int data){
        this.data = data;
    }
}

 

在链表中插入元素

1.头插法

public void addFirst(int elem){  //1.头插
    LinkedNode node = new LinkedNode(elem);//创建一个节点
    //空链表的情况
    if(this.head == null){
        this.head = node;
        return;
       // node.next = null;
    }
    //非空链表的情况
    node.next = head;
    this.head = node;
    return;
    }

测试：

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.addFirst(1);
        a.addFirst(2);
        a.addFirst(3);
        a.addFirst(4);
        a.addFirst(5);
        a.addFirst(6);
        System.out.println("addFirst");//头插法测试
        a.display();
    }
}

打印链表中的元素 

 

2.尾插法

 public void addLast(int elem){ //2.尾插法
        LinkedNode node = new LinkedNode(elem);//创建节点
        LinkedNode cur = this.head;
        //空链表的情况，直接将新添加的元素跟在head之后
        if(this.head == null){
            this.head = node;
            return;
        }

        //非空链表的情况
        //(1)遍历链表，找到最后一个元素
        //（2）将新的元素添在之后
        while(cur.next != null){
            cur = cur.next;
        }
        cur.next = node;
        return;
    }

 测试：

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.addLast(1);
        a.addLast(2);
        a.addLast(3);
        a.addLast(4);
        a.addLast(5);
        a.addLast(6);
        System.out.println("addLast");//尾插法测试
        a.display();

    }
}

 

测试结果：

 3.获取链表的长度

public int size(){// 获取链表的长度
        LinkedNode node = head;
        while (node != null){
            len++;
            node = node.next;
        }
        System.out.print("链表长度");
        System.out.println(this.len);
        return this.len;
    }

测试：

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.addLast(1);
        a.addLast(2);
        a.addLast(3);
        a.addLast(4);
        a.addLast(5);
        a.addLast(6);
        a.display();
        a.size();//测试获取链表的长度

    }
}

测试结果：

4.判断链表中是否包含某元素

 public boolean contains(int elem){   //        4. 包含元素
        if(head == null){
            return false;
        }
        for(LinkedNode cur = this.head;cur != null;cur = cur.next){
            if(cur.data == elem){
                System.out.println("yes");
                return true;
            }
        }
        return false;
    }

测试1（包含元素的情况）：

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.addLast(1);
        a.addLast(2);
        a.addLast(3);
        a.addLast(4);
        a.addLast(5);
        a.addLast(6);
        a.display();
        a.contains(2);//  测试是否包含某元素
    }

测试结果：

测试2（空链表的情况）：

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.display();
        a.contains(2);//  测试是否包含某元素
    }

测试结果： 

测试3（元素不存在的情况）：

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.addLast(1);
        a.addLast(2);
        a.addLast(3);
        a.addLast(4);
        a.addLast(5);
        a.addLast(6);
        a.display();
        a.contains(100);//  测试是否包含某元素
    }

测试结果: 

5.移除链表中的指定元素

public void remove(int toRemove){// 5. 移除元素
       LinkedNode cur = head;
        if(toRemove == this.head.data){//要删除的元素是头节点
            this.head = this.head.next;
            return;
        }
       while(cur != null){//要移除的元素不是头节点
           LinkedNode prev = cur;
           cur = cur.next;
           if(toRemove == cur.data){
           if(cur.next == null){//要移除的元素在链表末尾
               prev.next = null;
               return;
           } else{//要移除的元素不在末尾
               prev.next = cur.next;
               return;
           }
       }
       }
       return;
    }
}

测试1（删除的元素为头节点）：

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.addLast(1);
        a.addLast(2);
        a.addLast(3);
        a.addLast(4);
        a.addLast(5);
        a.addLast(6);
        a.display();
        a.remove(1);
        a.display();
    }
}

测试结果：

测试2（要删除的元素为末尾元素）：

 

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.addLast(1);
        a.addLast(2);
        a.addLast(3);
        a.addLast(4);
        a.addLast(5);
        a.addLast(6);
        a.display();
        a.remove(6);
        a.display();
    }
}

测试结果：

测试3（要删除的元素在中间位置）：

 

public class Test {
    public static void main(String[] args){
        LinkedList a = new LinkedList();
        a.addLast(1);
        a.addLast(2);
        a.addLast(3);
        a.addLast(4);
        a.addLast(5);
        a.addLast(6);
        a.display();
        a.remove(3);
        a.display();
    }
}

测试结果：

源代码：

 class LinkedNode{//节点
        public int data;
        public LinkedNode next = null;
        public LinkedNode(int data){
        this.data = data;
        }
    }
    public class LinkedList{
        private LinkedNode head = null;//创建头节点
        public int len = 0;


    public void addFirst(int elem){  //1.头插法
        LinkedNode node = new LinkedNode(elem);//创建一个节点
        //空链表的情况
        if(this.head == null){
            this.head = node;
            return;//没有return会怎么样呢
            // node.next = null;
        }
            //非空链表的情况
            node.next = head;
            this.head = node;
            return;//没有return会怎么样
    }




    public void addLast(int elem){ //2.尾插法
        LinkedNode node = new LinkedNode(elem);//创建节点
        LinkedNode cur = this.head;
        //空链表的情况，直接将新添加的元素跟在head之后
        if(this.head == null){
            this.head = node;
            return;
        }

        //非空链表的情况
        //(1)遍历链表，找到最后一个元素
        //（2）将新的元素添在之后
        while(cur.next != null){
            cur = cur.next;
        }
        cur.next = node;
        return;
    }

    
    
        public int size(){// 获取链表的长度
            LinkedNode node = head;
            while (node != null){
                len++;
                node = node.next;
            }
            System.out.print("链表长度：");
            System.out.println(this.len);
            return this.len;
        }



        public boolean contains(int elem){   //        4. 包含元素
            if(head == null){
                return false;
            }
            for(LinkedNode cur = this.head;cur != null;cur = cur.next){
                if(cur.data == elem){
                    System.out.println("yes");
                    return true;
                }
            }
            return false;
        }


        public void remove(int toRemove){// 5. 移除元素
            LinkedNode cur = head;
            //要删除的元素是头节点
            if(toRemove == this.head.data){//要删除的元素是头节点
                this.head = this.head.next;
                return;
            }
            while(cur != null){//要移除的元素不是头节点
                LinkedNode prev = cur;
                cur = cur.next;
                if(toRemove == cur.data){
                    if(cur.next == null){//要移除的元素在链表末尾
                        prev.next = null;
                        return;
                    } else{//要移除的元素不在末尾
                        prev.next = cur.next;
                        return;
                    }
                }
            }
            return;
        }
        
        
        
        
        // n.打印链表
        public void display(){
            System.out.println("打印链表：");
            System.out.print("[");
            for(LinkedNode node = head;node!= null;node = node.next){
                System.out.print(node.data);
                if(node.next != null){
                    System.out.print(" , ");
                }
            }
            System.out.println("]");
        }
}

 

y_y__d_d
关注
专栏目录
详细介绍链表原理即应用(Java语言)
weixin_62638404的博客
12-05 1219
详细介绍了链表，分别自己实现了单链表，双链表，介绍了LinkedList中众多方法的使用，介绍了ArrayList和LinkedList的区别。
Java数据结构线性表中插入、删除、查询、成串、查找等操作
Super灬小蜗的博客
10-13 4407
主要是关于一些对线性表的操作，包括插入、删除、查询、成串、查找等操作，下面是程序代码： SeqLis.java public class SeqList implements LList {               //顺序表类，实现线性表接口 private Object[] element;//对象数组，私有成员     private int len;         //
第六章链表
天青如水的博客
07-03 169
链表简介1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。2、结点包括两个部分：一、存储数据元素的数据域（内存空间），二、存储指向下一个结点地址的指针域。3、相对于线性表顺序结构，操作复杂。双向链表双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接...
数据结构之链表 - （通过代码实现方法，熟悉方法的使用）
最新发布
m0_69119792的博客
12-16 788
本篇通过写自己代码书写一些常用的方法，熟悉方法的使用，以至于使用方法时能够更好的操作。如有错误，请在评论区指正，让我们一起交流，共同进步！本文开始链表：由一个一个节点组成，每个节点分为数据域（储存数据）和地址域（储存地址），连接节点是通过他们的地址。链表特点：物理上不连续（与顺序表不同空间不是连续的），逻辑上连续；
java中线性表删除元素和删除指定元素_线性表的插入和删除（Java版）
weixin_33542015的博客
02-13 1557
1、线性表的定义：(1)、线性表是一种可以在任意位置插入和删除数据元素操作、由n(n≥0)个相同类型数据元素a0, a1,…, an-1组成的线性结构。除了第一个元素没有前驱元素和最后一个元素没有后继元素外，其他元素有且只有一个直接元素和一个直接后继元素。(2)、在逻辑上，线性结构的特点是数据元素之间存在着“一对一”的逻辑关系，这种关系的数据结构通常称为线性结构；同样，任何一个线性结构都可以用线性...
实验二 链表基本操作的实现
12-18
在这个实验“链表基本操作的实现”中，我们将深入理解链表的概念，学习如何创建、插入、删除节点，以及进行其他基本操作。 链表不同于数组，它不连续存储元素，而是通过节点间的指针链接。每个节点包含两部分：数据...
lianbiao.rar_链表基本操作_链表操作
09-24
接下来，我们将深入探讨链表的基本操作，包括链表的创建、删除以及统计链表长度。 1. **链表的创建** 创建链表首先要定义节点结构，一般包括数据域（存储数据）和指针域（指向下一个节点）。例如，我们可以定义一...
链表基本操作源码
12-28
以下是对链表基本操作的详细讲解： 1. **链表的定义** 链表由一系列节点组成，每个节点包含数据和指向下一个节点的指针。对于双向链表，每个节点还包含一个指向前一个节点的指针。在C语言中，链表节点（或称为结点...
单向链表基本操作的递归实现
08-10
在本文中，我们将探讨如何使用递归实现单向链表的一些基本操作。 1. **统计节点个数**：`count_listnode`函数通过递归遍历链表，计算节点总数。在递归调用中，它首先检查当前节点是否非空，然后递增计数器`count`，...
C语言实现链表基本操作
qq_56066173的博客
08-20 4765
如果把数据比喻成珠子，指针就是线，链表通过指针这条线就是把数据这些珠子串起来。
CIDR合并Java_CCF-CIDR合并 java代码（仅供参考）
weixin_29337315的博客
02-26 227
题目：试题编号： 201812-3试题名称：CIDR合并时间限制：1.0s内存限制：512.0MB问题描述：样例输入212样例输出1.0.0.0/82.0.0.0/8样例输入210/910.128/9样例输出10.0.0.0/8样例输入20/1128/1样例输出0.0.0.0/0经过思考，我运用java语言初步实现了CIDR合并的任务，一共包含两个类，一个类是ip地址，一个是主类，直接上代码IPa...
return this 返回的是指向该对象的指针，或返回的是当前该对象的地址。
碉堡飞哥的博客
06-26 1634
return this 返回的是指向该对象的指针，或返回的是当前该对象的地址。 var MarryState = function() { var _currentState = {}, states = { jump: function() { console.log('jump'); }, move: function(...
链表的各种基本操作
热门推荐
lukeye
03-27 1万+
1. 链表定义。#ifndef _LISTNODE_ #define _LISTNODE_ struct ListNode { int m_value; ListNode * m_pNext; }; #endif2. 初始化链表。void InitList(ListNode * L) { L = nullptr; cout << "InitList Success! " &...
链表--单向链表的基本方法
流萤梦的博客
07-20 2794
首先，我们来思考，为什么要使用链表？ 相对于数组来说： 优点：通过索引(数组下标)可以很快地访问数组元素； 缺点：插入/删除元素需要对数组进行调整, 效率低； 而链表： 优点：插入/删除速度很快，而且不用对整个链表进行调整； 缺点：只能进行顺序访问，不能随机访问（像数组一样用下标）； 所以，链表在一些需要快速插入／删除，而不太关心或者不需要随机访问的情况下使用。 链表是由一组节点组成的集合。...
链表的创建与打印
chuancyli的博客
08-01 7793
链表 链表的创建与打印 #include<stdio.h> #include<stdlib.h> typedef struct student{ char name[8]; char num[10]; int score; struct student *next; }NODE; //将struct student 结构类型定义为新的类型名NODE ...
链表（上）
生命不息，博客不止
04-23 1026
链表（上） 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。 相对于数组来讲，链表不需要预先知道数据的大小，它更灵活，可以充分利用计算机的内存空间。缺点是不能像数组一样随机读取数据，而且空间花销也比较大。常见链表有以下几种： 单向链表 单链表（即单向链表）是最简单的链表结构。一个...
单链表（打印头插法\头插法\尾插法\查找是否包含关键字key是否在单链表当中\得到单链表的长度\测试contines和size\任意位置插入,第一个数据结点为0号下标......）
weixin_45894950的博客
11-23 346
单链表 class Node { public int data;//0 public Node next;//null public Node(int data) { this.data =data;//传入的数据 this.next = null;//可写可不写，引用类型默认为null } } class Node { public int data;//0 public Node next;//null
二叉树的基本操作（三种遍历，求结点个数，求叶子结点个数）
y_y__d_d的博客
11-04 5806
目录 创建一个树结点 创建一颗固定的二叉树 先序遍历二叉树 中序遍历二叉树 后序遍历二叉树 求二叉树的结点个数 求叶子结点个数 源代码 创建一个树结点 class Node{//创建一个树结点的基本结构 public char val; public Node left; public Node right; public Nod...
C#语言实现链表的基本操作
知识点一：链表基本概念 链表是一种线性数据结构，其元素在内存中不是连续存放的，而是由一系列节点组成，每个节点都包含数据部分和指向下一个节点的引用（在双向链表中还有指向前一个节点的引用）。链表的优点包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值