（四）链表和递归

最新推荐文章于 2022-12-09 21:12:58 发布
最新推荐文章于 2022-12-09 21:12:58 发布
阅读量221 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_35395498/article/details/109439389
版权

目录

1.链表

1.1概述

1.2在链表中添加元素

1.3使用链表的虚拟头节点

1.4遍历链表，查询和修改

1.5链表中删除元素

2.递归

2.1 概述

2.2 递归实现链表中所有元素

​

1.链表

1.1概述

一种线性数据结构，数据存储在 Node 节点中
public class LinkedList<E> {

    private class Node{
        
        public E e;
        
        public Node next;

        
    }
}

1.2在链表中添加元素

public class LinkedList<E> {

    private class Node{
        /**
         * 链表中的元素e
         */
        public E e;
        /**
         * 指向的下一个节点
         */
        public Node next;

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

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

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

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

    /**
     * 头节点
     */
    private Node head;
    /**
     * 实际元素个数
     */
    int size;

    public LinkedList(){
        head = null;
        size = 0;
    }

    /**
     * 获取链表中的元素个数
     * @return
     */
    public int getSize(){
        return size;
    }

    /**
     * 返回链表是否为空
     */
    public Boolean isEmpty(){
        return size == 0;
    }

    /**
     * 在链表头添加新元素e
     * @param e
     */
    public void addFirst(E e){
        head = new Node(e,head);
        size ++;
    }

    /**
     * index 位置新增元素 e
     * @param index
     * @param e
     */
    public void add(int index,E e){
        if (index > size){
            throw new RuntimeException("add fail.index iLLegal");
        }
        if (index == 0){
            addFirst(e);
        }else {
            Node prev = head;
            // 找到前一个节点的位置
            for (int i = 0; i < index - 1; i++) {
                prev = prev.next;
            }
            prev.next = new Node(e,prev.next);
            size++;
        }
    }

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

1.3使用链表的虚拟头节点

public class LinkedList<E> {

    private class Node {
        /**
         * 链表中的元素e
         */
        public E e;
        /**
         * 指向的下一个节点
         */
        public Node next;

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

        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(null, null);
        size = 0;
    }

    /**
     * 获取链表中的元素个数
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 返回链表是否为空
     */
    public Boolean isEmpty() {
        return size == 0;
    }

    /**
     * index 位置新增元素 e
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {
        if (index > size) {
            throw new RuntimeException("add fail.index iLLegal");
        }

        Node prev = dummyHead;
        // 找到前一个节点的位置
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        prev.next = new Node(e, prev.next);
        size++;
    }

    /**
     * 在链表头添加新元素e
     *
     * @param e
     */
    public void addFirst(E e) {
        add(0,e);
    }

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

}

1.4遍历链表，查询和修改

public class LinkedList<E> {

    private class Node {
        /**
         * 链表中的元素e
         */
        public E e;
        /**
         * 指向的下一个节点
         */
        public Node next;

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

        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(null, null);
        size = 0;
    }

    /**
     * 获取链表中的元素个数
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 返回链表是否为空
     */
    public Boolean isEmpty() {
        return size == 0;
    }

    /**
     * index 位置新增元素 e
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {
        if (index > size) {
            throw new RuntimeException("add fail.index iLLegal");
        }

        Node prev = dummyHead;
        // 找到前一个节点的位置
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        prev.next = new Node(e, prev.next);
        size++;
    }

    /**
     * 在链表头添加新元素e
     *
     * @param e
     */
    public void addFirst(E e) {
        add(0, e);
    }

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

    /**
     * 获取链表中第index位置的元素
     *
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("add fail.index iLLegal");
        }
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.e;
    }

    /**
     * 获取链表中第1个元素
     *
     * @return
     */
    public E getFirst() {
        return get(0);
    }

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

    /**
     * 修改index位置的元素为e
     *
     * @return
     */
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("set fail.index iLLegal");
        }
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.e = e;
    }

    /**
     * 链表中是否包含元素e
     *
     * @param e
     * @return
     */
    public Boolean contains(E e) {
        Node cur = dummyHead.next;
        while (cur != null) {
            if (cur.e.equals(e)) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        Node cur = dummyHead.next;
        while (cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL");
        return res.toString();
    }

    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < 5; i++) {
            linkedList.addFirst(i);
            System.out.println(linkedList);
        }
        linkedList.add(2,66666);
        System.out.println(linkedList);
    }
}

1.5链表中删除元素

 /**
     * 删除index位置的索引
     * @param index
     * @return
     */
    public E remove(int index){
        if (index < 0 || index >= size) {
            throw new RuntimeException("remove fail.index iLLegal");
        }
        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
           prev = prev.next;
        }
        Node retNode = prev.next;
        prev.next = retNode.next;
        retNode.next = null;
        size --;
        return retNode.e;
    }

    /**
     * 删除链表中的第一个元素，返回删除元素
     * @return
     */
    public E removeFirst(){
        return remove(0);
    }

    /**
     * 删除链表中的最后一个元素，返回删除元素
     * @return
     */
    public E removeLast(){
        return remove(size - 1);
    }

2.递归

2.1 概述

本质上，将原来的问题，转换为更小的同一问题，递归就是自己调自己
举例 ：数组求和

常规的for循环：
public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        System.out.println(sum);
    }

使用递归实现：
public static int sum(int[] arr){
        return sum(arr,0);
    }

    private static int sum(int[] arr, int l) {
        if (l == arr.length) {
            return 0;
        }
        return arr[l] + sum(arr, l + 1);
    }

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        System.out.println(sum(arr));//6
    }

2.2 递归实现链表中所有元素

//  递归实现删除链表中的所有元素元素 
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return null;
        }
        head.next = removeElements(head.next, val);
        return head.val == val ? head.next : head;
    }

 

法毅的博客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构和算法：链表栈递归
12-23
链表栈递归。 给定两个链表，分别表示两个非负整数。它 们的数字逆序存储在链表中，且每个结点只 存储一个数字，计算两个数的和，并且返回 和的链表头指针
四向链表的创建、打印预览，遍历。任意节点出发遍历整个链表(不重复)
最新发布
fyJixiang的博客
11-07 919
力扣里没有的算法题。一些企业可能会考。
手写单链表翻转（递归和非递归）
10-25
单链表翻转支持从任意位置翻转链表。分为递归和非递归两种方法，
来啊~手写个链表啊~
将懒惰进行到底
11-01 417
【Java数据结构】链表
Zincy星辰
03-18 1810
1. 概况 链表在逻辑上是连续的，在物理上不一定连续。 分类： 单向、双向 带头、不带头 循环、非循环 2. 思路 data：数值域，里面存储的数据 next：引用变量 -> 下一个节点的地址 尾巴节点：当这个节点的next域为null的时候 头节点：整个链表当中的第一个节点 单向不带头非循环链表： 单向带头非循环链表： 单向不带头循环链表： 3. 定义链表节点 class Node { public int val; public...
手写一个简单的单链表
fj_xiang的博客
05-11 511
先创建一个简单的实体类 class Data{ private int id; private String name; private Data next; //代表下一个节点，如果没有下一个节点，则为空 public Data(int id, String name) { super(); this.id = id; this.name = name; } public int getId() { return id; } public void setId(int
JavaSE进阶（七）——手写链表
老程的小白博客空间
12-02 447
本篇笔记单纯炫技，其中***可能会有一些思想和逻辑***，能吃到多少就是你们自己的事了，录视频授课也需要至少两个课时（可能还不够），众所周知，我懒！所以……嘿嘿。
剑指Offer #03 从尾到头打印链表（递归）
01-20
因为题目要求返回的顺序是从尾到头，所以我们可以采用递归的形式访问链表，在回归的过程才将节点的值存入ArrayList中，以达到逆序的目的。 /** * public class ListNode { * int val; * ListNode next = null; * * ...
如何使用递归和非递归方式反转单向链表
09-05
以下是对使用递归和非递归方式反转单向链表的示例进行了详细的分析介绍，需要的朋友可以过来参考下
c语言链表合并(递归和非递归实现)
07-28
c语言链表合并(递归和非递归实现) 包括链表创建 打印输出 通过测试,可以使用 测试环境:c-free 5.0
二叉树之三叉链表非递归运算
07-31
数据结构源码C语言描述续，前面上传文档描述了二叉树的递归算法，本篇描述了二叉树三叉链表的非递归操作，以及测试程序：
手写简易版链表及原理分析
朴实搬砖人的博客
01-04 683
前言 好多人都觉得为什么要自己写这样的数据结构，变成里面不是有吗？为什么要去写，有这个疑问，其实这个疑问这我的脑海中也存在了很长一段时间，本人是学习java编程的，直接看java的集合框架不行吗？这个时候如果你的水平到了还好。如果没有，你会发现你根本就理解不了编程语言里面数据结构，看了就忘掉了，也理解不了，学习了半个月编程里面的集合发现学不会，还要抱怨怎么可以这样，看了半个月都没有看懂，于是就放...
手写链表
weixin_44861399的博客
03-25 206
文章目录一、链表结构二、插入删除三、边界条件四、示例1. 定义节点：2. 增加节点：3. 删除节点：五、代码实现 一、链表结构 每个节点结构是由数据域和指针域组成，数据域是存放数据的，而指针域存放下一结点的地址。 但是不可能只有一个节点呀，这时候就使用 Class 来声明一个类，为类添加两个属性，一个属性是存放数据的属性data，另一个属性是存放指向下一个结点的指针属性next。这样就可...
手写一个单链表
weixin_44550142的博客
04-15 491
本人文科生,转行做java开发,目前在恶补计算机基础.这篇文章就是一个学习笔记,记录自己学习单链表时的一些理解,有不正确的地方希望直接指出我会改正的,不必喷我,我目前就是小白.欢迎大家批评指正. 我这次实现的是一个带头节点的单链表如下图,其中L代表头节点,L节点本身不存数据,只在自己的next域里存储下一个数据节点的地址.P是一个指针用来操作链表.该单链表不循环,所以最后一个节点的next域是nu...
手写链表（jvav）
Infinite_Power_的博客
12-09 386
闲来无事用Java手写的一个链表系统
Java手写链表
qq_45464560的博客
09-28 2044
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V73ZFeSh-1632464808641)(https://img-mid.csdnimg.cn/release/static/image/mid/ask/081087464236187.jpg “=600 #left”)]
手写一个单向链表
皮皮狗
09-27 741
主要包括单向链表的插入与删除操作 package leetcode.list; /** * @基本功能:手写一个单链表 * @program:summary * @author:peicc * @create:2019-08-17 11:45:53 **/ public class LinkList { ListNode head;//头结点 ListNode ...
手写一个泛型双向链表
AnNanDu的博客
08-31 371
在当前大环境的背景下面试不问点算法都不算个合格的面试了（卷），而与算法紧密相关的数据结构也是经常问到的，像集合、链表、树、图、栈、堆、队列、矩阵等等等等。是不是感觉难度如下：集合：有手就行链表：简简单单队列：基础操作二叉树：也还行吧平衡二叉树：普普通通红黑树：有点难度了堆/栈：难度提升了图：今天是高端局这么一套组合拳下来，还是有点难度的，本篇就先手写简简单单的链表，链表里有单向链表跟双向链表，会双向链表还能不会单向链表吗，直接上双向链表。双向链表的属性内容上节点prev跟下节点next。...
数据结构手写单链表（较简单）
吃苦胆的野狼
11-09 1099
#include #include using namespace std; struct Node { int data ; Node *link ; }; class LinkList { public: LinkList () {} ; bool IsEmpty ( ) {return (first->link != NULL) ?false : true ;}
c++单向链表逆置递归
05-26
在 `reverseList` 函数中，首先判断当前节点是否为尾节点，如果是则更新头结点指针和当前节点的 `next` 指针，递归结束。 否则，先保存下一个节点的指针，然后更新当前节点的 `next` 指针为前一个节点，递归调用 `...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值