算法-线性表-链表

已于 2022-03-08 23:56:33 修改
阅读量491 收藏
点赞数
分类专栏： 算法 文章标签： 链表 算法 数据结构
于 2022-03-07 23:18:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjl77/article/details/123317328
版权

目录

1.2.1 单向链表

1.2.2 双向链表

1.2.3 链表复杂度分析

节点API设计

类名Node<T>
构造方法Node（T t,Node next）;创建Node对象
成员变量

T item:存储数据<br/>

Node next:指向下一个节点

节点类实现

package test.lianbiao;

import org.apache.poi.ss.formula.functions.T;

public class Node {
    public T item;

    public Node next;

    public Node(T item, Node next) {
        this.item = item;
        this.next = next;
    }

}

1.2.1 单向链表

 

1.2.1.2，单向链表代码实现

package test.linear;

import bsh.This;
import org.apache.poi.ss.formula.functions.T;

import java.util.Iterator;


public class LinkList <T> implements  Iterable<T>{
    //记录头结点
    private Node head;
    //记录链表的长度
    private int N;



    private class Node{
        T item;
        Node next;
        public Node(T item,Node next){
            this.item = item;
            this.next = next;

        }
    }

    public LinkList(){
        //初始化头结点
        this.head = new Node(null,null);
        //初始化元素个数
        this.N = 0;
    }

    //清楚链表
    public void clear(){
        head.next = null;
        this.N = 0;
    }

    //获取链表的长度
    public int length(){
        return N;
    }

    //判断链表是否为空
    public boolean isEmpty(){
      return N==0;
    }

    //获取指定位置的元素
    public T get(int i){
        //通过循环，从头结点开始往后找，依次找i次，就可以找到对应的元素
        Node n = head.next;
        for (int  index = 0; index < i; index++) {
            n = n.next;
        }
        return n.item;
    }
    //向链表添加元素
    public void insert(T t){
        Node n = head;
        //找到当前最后一个结点
        while(n.next!=null){
            n = n.next;
        }

        //创建新节点
        Node newNode = new Node(t,null);
        //让当前最后一个结点指向新节点
        n.next = newNode;
        //元素个数加1
        N++;
    }
    //向指定位置i处添加元素t
    public void insert(int i , T t){
        //找到i位置前一个节点
        Node pro = head;
        for (int index = 0; index <= i-1 ; index++) {
            pro =  pro.next;
        }
        //找到i位置的节点
        Node curr = pro.next;
        //创建新节点，并且新节点需要指向原来位置的i节点
        Node newNode = new Node(t,curr);
        //原来i位置的前一个节点要指向新节点即可
        pro.next = newNode;
        N++;
    }

    //删除指定位置i处的元素，并返回被删除的元素
    public T remove(int i ){
        //找到i位置前一个节点
        Node pro = head;
        for (int index = 0; index < i ; index++) {
            pro =  pro.next;
        }
        //找到i位置的节点
        Node curr = pro.next;
        //原来i位置的前一个节点要指向i位置的后一个节点即可
        pro.next = curr.next;
        N--;
        return curr.item;
    }

    //删除指定位置i处的元素，并返回被删除的元素
    public int indexOf(T t){
        //从头结点开始，依次找到每一个节点，取出item，如果相同，就找到了
        Node n = this.head;
        for (int i=0;n.next!=null;i++){
            n=n.next;
            if(n.item.equals(t)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public Iterator<T> iterator() {
        return new Literator();
    }

    private class Literator implements Iterator {
        private Node n;
        public Literator(){
            this.n = head ;
        }
        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }

        @Override
        public void remove() {

        }




    }
}

测试代码

package test.linear;

public class ListListTest {


    public static void main(String[] args) {
        LinkList<String> list1 = new LinkList<>();
        list1.insert("姚明");
        list1.insert("科比");
        list1.insert("麦迪");
        list1.insert(1,"詹姆斯");
        for (String s : list1) {
            System.out.println(s);
        }
        System.out.println("------------------------------------------");

        String geyResult = list1.get(1);
        System.out.println("获取索引1处的结果为"+geyResult);
        //测试删除
        String removeResult = list1.remove(0);
        System.out.println("删除获取索引0处的结果为"+removeResult);


    }
}

执行结果

姚明
詹姆斯
科比
麦迪
------------------------------------------
获取索引1处的结果为詹姆斯
删除获取索引0处的结果为姚明

1.2.2 双向链表

 

 代码实现：

代码有问题，没找到错的地方

package test.linear;

import org.apache.poi.ss.formula.functions.T;

import java.util.Iterator;

public class TwoWayLinkList <T> implements  Iterable<T>{
    //首节点
    private Node head;
    //最后一个节点
    private Node last;
    //链表的长度
    private int N;



    //节点类
    private class Node{
        //存储数据
        public  T item;
        //指向上一个节点
        public Node pre;
        //指向下一个节点
        public Node next;

        public Node(T item, Node pre, Node next){
            this.item = item;
            this.pre = pre;
            this.next = next;
        }
    }

    public TwoWayLinkList(){
        //初始化头结点和尾结点
        this.head = new Node(null,null,null);
        //初始化元素个数
        this.last = null;
        //初始化元素个数
        this.N = 0;

    }

    //清空链表
    public void clear(){
        this.head.next = null;
        this.head.pre = null;
        this.head.item = null;
        this.last = null;
        this.N = 0;
    }

    //获取链表长度
    public int length(){
        return N;
    }
    //判断链表是否为空
    public boolean isEmpty(){
        return N==0;
    }
    //获取第一个元素
    public T getFirst(){
       if(isEmpty()){
           return null;
       }
       return head.next.item;
    }
    //获取最后一个元素
    public T getLast(){
        if(isEmpty()){
            return null;
        }
        return last.item;
    }
    //插入元素
    public void insert(T t){

        if(isEmpty()){
            //如果链表为空
            //创建新节点
            Node newNode = new Node(t,head,null);
            //让新节点成为尾结点
            last = newNode;
            //让头节点指向尾结点
            head.next = last;

        }else{
            //如果链表不为空
            Node olaLast = last;
            //创建新的节点
            Node newNode = new Node(t,olaLast,null);
            //让当前的尾结点指向新节点
            olaLast.next = newNode;
            //让新节点称为尾结点
            last = newNode;
        }
        //元素个数+1
        N++;
    }
    //向指定位置i处插入元素t
    public void insert(int i,T t ){
        //找到i位置的前一个结点
        Node pre = head;
        for(int index=0;index<i;index++){
            pre = pre.next;
        }
        //找到i位置的节点
        Node curr = pre.next;
        //创建新节点
        Node newNode = new Node(t,pre,curr);
        //让i位置的前一个结点的下一个节点变为新的节点
        pre.next = newNode;
        //让i位置的前一个结点变为新结点
        curr.pre = newNode;
        //元素个数加一
        N++;
    }


    //获取指定位置i处的元素
    public T get(int i){
        Node n = head.next;
        for(int index = 0;index<i;index++){
            n = n.next;
        }
        return n.item;
    }

    //找到元素t在链表中第一次出现的位置
    public int indexOf(T t){
        Node n = head;
        for(int index = 0;n.next!=null ;index++){
            n = n.next;
            if(n.next.equals(t)){
                return index;
            }
        }
        return -1;
    }

    public T remove(int i){
        //找到i处元素的前一个节点
        Node pre = this.head;
        for (int index = 0;index < i;index++){
            pre = pre.next;
        }

        //找到i处元素的节点
        Node curr = pre.next;

        //找到i处元素的下一个节点
        Node nextNode = curr.next;

        //前一个节点指向i节点的后一个节点
        pre.next = nextNode;
        //i节点后一个一个节点指向i节点的后一个节点
        nextNode.pre = pre;
        //元素个数减一
        N--;
        return curr.item;
    }

    @Override
    public Iterator<T> iterator() {
        return new TIterator();
    }


    private class TIterator implements Iterator{

        private Node n;

        public TIterator (){
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next==null;
        }

        @Override
        public Object next() {
            n=n.next;
            return n.item;
        }

        @Override
        public void remove() {

        }
    }


}

1.2.2.4 java 中LinkedList实现

java中LinkedList 集合也是使用双向链表实现，并提供了增删盖茶的相关方法。

1.2.3 链表复杂度分析

查询比较多用顺序表，增删操作比较多用链表

1.2.4 链表反转

 下面的代码不知道哪里有问题，执行结果不对，尴尬

 //用来反转整个链表
    public void reverse(){
        if(isEmpty()){
            return;
        }
        reverse(head.next);
    }
    //反转指定的结点，并把反转后的结点返回
    public Node reverse(Node curr){
        if(curr.next == null){
            this.head = curr;
            return curr;
        }
        //递归的反转当前结点curr的下一个结点；返回值就是链表反转后，当前结点的上一个结点
        Node pre = reverse(curr.next);
        //让返回的节点的下一个结点变成当前结点curr;
        pre.next = curr;
        //把当前结点的下一个结点变成null
        curr.next = null;
        return curr;
    }

1.2.5 快慢指针

快满指针指的是定义俩个指针，这俩个指针的移动速度一快一慢，以此来制造自己想要的差值，这个差值可以让我们找到链表上相应的结点。一般情况下，快指针的移动步长为慢指针的俩倍。

 

package test.linear;


import
import org.apache.poi.ss.formula.functions.T;

public class TES1 {
    public static void main(String[] args) {
        Node<String> first = new Node<String>("aa",null);
        Node<String> second = new Node<String>("bb",null);
        Node<String> third = new Node<String>("cc",null);
        Node<String> four = new Node<String>("dd",null);
        Node<String> five = new Node<String>("ee",null);
        Node<String> six = new Node<String>("ff",null);
        Node<String> seven = new Node<String>("gg",null);

        //完成结点之间的指向
        first.next=second;
        second.next=third;
        third.next=four;
        four.next=five;
        five.next=six;
        six.next=seven;

        //查找中间值
        String mid = getMid(first);
        System.out.println("中间值为："+mid);

    }

    /**
     *
     * @param first 链表的首结点
     * @return 链表中中间结点的值
     */
    public static String getMid(Node<String> first){
        //定义俩个指针
        Node<String> fast = first;
        Node<String> slow = first;

        //使用俩个指针遍历链表，当快指针指向的结点没有下一个结点了，就可以结束了。
        while(fast!=null && fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow.item;
    }

    private static class Node<T>{
        T item;
        Node next;
        public Node(T item,Node next){
            this.item = item;
            this.next = next;

        }
    }

}

中间值为：dd

单链表是否有环问题

如果是有环的，那么快指针总会追上慢指针，如果是无环的，那么久永远追不上

 


    public static boolean isCircle(Node<String> first){
        //定义俩个指针
        Node<String> fast = first;
        Node<String> slow = first;

        //使用俩个指针遍历链表，当快指针指向的结点没有下一个结点了，就可以结束了。
        while(fast!=null && fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast.equals(slow)){
                return true;
            }
        }
        return false;
    }

1.2.6 循环链表

jjl77
关注
专栏目录
POI文件excel文件导入导出
it_littlestar的博客
12-13 286
POI依赖的jar包 org.apache.poi poi-ooxml 3.14 前台(使用easyUI框架)//导出 $("#button-export").click(function(){ window.location.href="../../area_batchExport.action";
数据结构与算法系列--线性表
2302_77343936的博客
10-01 541
针对顺序表的缺点，一种改进的思路是让相邻元素间留有足够的余地，即所有的元素都不考虑相邻的位置，哪里有空位就空到哪里，而只是让每个元素都知道它下一个元素在哪儿就可以了，这样，假设我们在表中的第一个元素，我们便知道了第二个元素的内存地址，在第二个元素，知道第三个元素的内存地址，依此类推，通过遍历的形式便可以找到所有元素的内存地址。这种思想便是线性表链式存储结构建立的前提。1.线性链表:采用链式存储结构的线性表。
Java代码实现栈(数组和链表）
MAKEJAVAMAN的博客
08-02 601
文章目录数组实现栈链表实现栈 数组实现栈 import org.apache.poi.ss.formula.functions.T; /** * @Author: jerrold * @Date: 2021/08/02 * @Version 1.0 * @description: 数组实现栈 */ public class MyStack { private int cnt; //当前栈的长度 private int stackSize; //栈的总长度 private
IntelliJ IDEA警告Type parameter ‘T‘ hides visible type ‘org.apache.poi.ss.formula.functions.T‘
少爷晚安
11-07 1039
由于我的代码里引入了包下一个类名为T的类，导致了IDEA提示问题，该T是一个具体的类型名称，不是泛型参数。代码里有一个名为T类或接口，或者您使用的T作为具体类型名称，而不是某个地方作为一个类型参数，则会提示。
java 对象转换成另外一个类对象 泛型
an74520的专栏
02-03 2万+
对象转换成另一个类对象 package com.mw.usims.fts.util; import com.mw.usims.fts.model.BaseModel; import org.apache.poi.ss.formula.functions.T; import java.lang.reflect.Field; import java.lang.reflect.Invocation
使用反射编写POIUtils Excel导入导出工具类
zbingley的博客
03-06 464
直接上代码： package com.limai.baseknowledge.poi; import lombok.extern.slf4j.Slf4j; import org.apache.poi.hssf.usermodel.*; import org.apache.poi.ss.formula.WorkbookDependentFormula; import org.apache.p...
数据结构学习--线性表及其应用--链表
06-25
本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种动态数据结构，它的优点在于内存分配是按需进行的，即每个节点只在需要时才被创建。因此，链表非常适合于数据量变化较大的情况，增删节点非常便捷，...
哈工大数据结构与算法-线性表的链式存储结构与应用.zip
最新发布
06-02
在本课程"哈工大数据结构与算法"中，重点关注了线性表的链式存储结构及其应用。链式存储是线性表的一种非顺序存储方式，与顺序存储（数组）相比，它提供了更大的灵活性。 链式存储的基本思想是用一组任意的存储单元...
基础算法----线性表和栈，队列
04-03
线性表和栈、队列是计算机科学中最基础的数据结构，它们在算法设计和实现中起着至关重要的作用。线性表是一种简单的数据组织形式，它由若干个相同类型元素构成的有限序列，可以顺序存储或链式存储。栈和队列则是...
数据结构与算法-线性表的设计与实现 定义线性表节点的结构.pdf
04-18
线性表的实现可以使用数组、链表、队列等数据结构来实现。在实际应用中，可以根据具体情况选择合适的实现方式。 线性表是一种基本的数据结构，对于软件开发和数据分析具有重要意义。了解线性表的设计与实现可以帮助...
Java之泛型 T与T的用法
weixin_39214481的博客
03-01 952
版权声明：本文为博主yellowcong原创文章，未经博主允许不得转载。 https://blog.csdn.net/yelllowcong/article/details/78537149 &lt;T&gt; T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据， 通过返回值&lt;T...
使用EasyPoi导出Excel
qq_60676778的博客
07-14 1万+
springcloud导出easy poi，简单
java excel通用导入类_使用poi导入excel通用工具类
weixin_29163797的博客
02-16 190
import java.io.File;import java.io.IOException;import java.lang.reflect.Method;import java.lang.reflect.ParameterizedType;import java.text.DecimalFormat;import java.text.SimpleDateFormat;import java.u...
Java-泛型<T> T与T的用法
脑壳疼
09-26 279
Java之泛型<T> T与T的用法 <T> T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据， 通过返回值<T> T和T的两种方法实现 <T> T用法 这个<T> T表示的是返回值T是泛型，T是一个占位符，用来告诉编...
Java之泛型<T> T与T的用法-yellowcong
11-23 3万+
`<T> T`表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的`T`就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据， 通过返回值`<T> T` 和`T`的两种方法实现
poi 用户自定义函数
大熊的专栏
01-11 4658
poi 用户自定义函数
【原创】POI导入导出工具类
weixin_33722405的博客
12-22 321
对于可能存在的问题，欢迎指正，万分感谢。 关于本类线程安全性的解释： 多数工具方法不涉及共享变量问题，至于添加合并单元格方法addMergeArea，使用ThreadLocal变量存储合并数据，ThreadLocal内部借用Thread.ThreadLocalMap以当前ThreadLocal为key进行存储，设置一次变量，则其他线程也会有上次数据的残留，因此在addMergeArea方法中进行...
java读写excel，解决poi包中没有org.apache.poi.ss.usermodel.CellType的问题
热门推荐
我在浪里
08-30 10万+
POI版本为3.8； jar包导入之后XSSFWorkbook可以正常使用了，但出现了The import org.apache.poi.ss.usermodel.CellType cannot be resolved  代码中 cellRowName.setCellType(CellType.STRING); // 设置单元格值的类型 style.setAlignment(HorizontalA...
数据结构与算法-线性表
09-13
数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表的定义是一个有限个相同类型的数据元素的集合，每个数据元素都有一个唯一的前驱和后继。线性表可以用顺序存储结构或链式存储结构来实现。 顺序表是线性表的一种实现方式，它使用连续的存储空间来存储数据元素。顺序表的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以通过下标随机访问表中的任意元素。顺序表的存储位置可以使用简单直观的公式来表示。 链表是线性表的另一种实现方式，它使用一组通过指针连接起来的结点来存储数据元素。每个结点包含两部分：数据域和指针域。数据域用于存储数据元素，指针域用于指向下一个结点。链表的分类较为多样，包括单链表、双向链表和循环链表等。链表的操作相对复杂一些，但它具有灵活性和动态性的优势。 总结来说，数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表可以使用顺序表或链表来实现，顺序表适合于随机访问，而链表适合于插入和删除操作。对于链表来说，需要注意不同类型的链表有不同的操作和特点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值