单链表应用

最新推荐文章于 2024-04-27 15:13:08 发布
最新推荐文章于 2024-04-27 15:13:08 发布
阅读量444 收藏
点赞数
分类专栏： 数据结构与算法 笔记 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s19862388581/article/details/121744052
版权

一. 链表介绍

  1. 链表是以节点的方式来存储的，是链式存储。
  2. 每个节点包含data域和next域，next域指向下一个节点。
  3. 链表的各个节点不一定是连续存储。
  4. 链表分为带头节点的链表和没有头节点的链表，根据实际需求来确定。

二. 单链表应用实例的代码实现

  1. 节点
package datastructure.linkedlist.simplelinkedlist;

public class HeroNode {

    public int no;   // 编号
    public String name; // 姓名
    public HeroNode next; // 下一个节点

    public HeroNode() {
    }

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

}
  1. 链表
package datastructure.linkedlist.simplelinkedlist;

import java.util.Stack;

// 单链表
public class SimpleLinkedList {

    // 头节点
    private HeroNode head = new HeroNode(0, "");

    // 头结点的get方法
    public HeroNode getHead() {
        return head;
    }

    // 添加节点
    public void add(HeroNode heroNode) {
        HeroNode temp = head;
        // 把要添加的节点添加到链表的最后面
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
    }

    // 按照编号顺序添加节点
    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        // 用来判断节点编号有没有重复  true为重复
        boolean flag = false;
        // 为要添加的节点找合适的位置
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("节点编号重复！");
        } else {
            // 如果节点编号没有重复，就将要添加的节点插入到链表中合适的位置
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 删除节点
    public void delete(int heroNo) {
        HeroNode temp = head;
        // 用来判断链表中有没有要删除的节点
        boolean flag = false;
        // 寻找要删除节点的前一个节点
        while (true) {
            if (temp.next == null) {
                System.out.println("没有要删除的这个节点!");
                break;
            }
            if (temp.next.no == heroNo) {
                // 链表中存在要删除的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            // 把要删除节点的前一个节点的next指向要删除节点的next (断开要删除节点在链表中的连接)
            temp.next = temp.next.next;
        }
    }


    // 修改节点数据
    public void update(HeroNode heroNode) {
        HeroNode temp = head.next;
        // 用来判断有没有找到要修改的节点
        boolean flag = false;
        // 在链表中寻找要修改的节点
        while (true) {
            if (temp == null) {
                System.out.println("没有要修改的这个节点！");
                break;
            }
            if (temp.no == heroNode.no) {
                // 找到要修改的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            // 修改节点的信息 （当前节点中只需要修改name）
            temp.name = heroNode.name;
        }
    }

    // 遍历所有节点
    public void allNode() {
        HeroNode temp = head.next;
        if (temp == null) {
            System.out.println("此链表为空链表！");
            return;
        }
        while (true) {
            System.out.println(temp);
            temp = temp.next;
            if (temp == null) {
                break;
            }
        }
    }

    // 返回单链表的长度
    public int getLength(HeroNode headNode) {
        if (headNode.next == null) {
            return 0;
        }
        // 记录链表的长度
        int length = 0;
        HeroNode temp = headNode.next;
        while (temp != null) {
            length ++;
            temp = temp.next;
        }
        return length;
    }

    // 获取倒数第N个节点
    public HeroNode getLastIndexNode(HeroNode headNode, int index) {
        // 如果链表为空，返回null
        if (headNode.next == null) {
            return null;
        }
        // 如果传入的index不符合要求,
        int length = getLength(headNode);
        if (index <= 0 || index > length) {
            System.out.println("获取失败！");
            return null;
        }
        // 寻找链表中倒数第index个节点并返回+
        HeroNode currentNode = headNode.next;
        for (int i = 0; i < length - index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode;
    }

    // 单链表的反转
    public void reverse(HeroNode headNode) {
        // 头节点不算  如果链表中没有节点或者只有一个节点，直接return
        if (headNode.next == null || headNode.next.next == null) {
            return;
        }
        HeroNode currentNode = headNode.next;
        HeroNode nextNode = null;
        // 创建一个新的头节点 相当于创建一条新的链表
        HeroNode reverseHead = new HeroNode(0, "");
        // 不断地把旧链表的下一个节点 插入到新链表的头节点和第一个节点之间
        while (currentNode != null) {
            nextNode = currentNode.next;        // 记录当前节点的下一个节点
            currentNode.next = reverseHead.next;  // 把新链表接到当前节点的后面（也就是把当前节点接到新链表的第一个节点之前）
            reverseHead.next = currentNode;        // 当前节点接到新链表的头节点之后
            currentNode = nextNode;             // 向下进行
        }
        // 把新链表接到原来链表的头节点上
        headNode.next = reverseHead.next;
    }

    // 单链表的逆序打印的第一种方法  两次反转 遍历打印
    public void reversePrint1(HeroNode headNode) {
        // 反转链表
        reverse(headNode);
        // 打印所有节点
        allNode();
        // 把链表反转回去
        reverse(headNode);
    }

    // 单链表的逆序打印 第二种方法    利用栈stack 不改变原来单链表的数据结构
    public void reversePrint2(HeroNode headNode) {
        if (headNode.next == null) {
            return;
        }
        HeroNode current = headNode.next;
        Stack<HeroNode> stack = new Stack<>();
        // 把每个节点按链表的顺序压入栈中
        while (current != null) {
            stack.push(current);
            current = current.next;
        }
        // 逐个出栈  先进后出
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

    // 有序合并两个有序的单链表
    public void mergeTwoSimpleLinkedList(HeroNode headNode1, HeroNode headNode2) {
        // 如果有一个链表为空或者都为空，说明不用合并 直接return
        if (headNode1.next == null && headNode2.next == null) {
            return;
        } else if (headNode1.next == null) {
            return;
        } else if (headNode1.next == null) {
            return;
        }

        // 把第一个链表接到新链表上
        HeroNode current = headNode1.next;
        HeroNode nextNode = null;
        while (current != null) {
            nextNode = current.next;   // 记录下一个节点
            current.next = null;       // 把当前节点断开连接置为单独的节点
            addByOrder(current);      // 按照顺序添加到新的链表上
            current = nextNode;       // 向下进行
        }

        // 遍历第二个链表有序添加到新链表上
        current = headNode2.next;
        while (current != null) {
            nextNode = current.next;
            current.next = null;
            addByOrder(current);
            current = nextNode;
        }
    }

}
  1. 测试类
package datastructure.linkedlist.simplelinkedlist;

public class SimpleLinkedListDemo {

    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1, "宋江");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义");
        HeroNode heroNode3 = new HeroNode(3, "吴用");
        HeroNode heroNode4 = new HeroNode(4, "林冲");

        /*// 创建一个单链表
        SimpleLinkedList simpleLinkedList = new SimpleLinkedList();
        // 向单链表添加节点
        simpleLinkedList.addByOrder(heroNode1);
        simpleLinkedList.addByOrder(heroNode3);
        simpleLinkedList.addByOrder(heroNode2);
        simpleLinkedList.addByOrder(heroNode4);
        // 遍历单链表
        System.out.println("原单链表是这样的:");
        simpleLinkedList.allNode();*/

        SimpleLinkedList simpleLinkedList1 = new SimpleLinkedList();
        SimpleLinkedList simpleLinkedList2 = new SimpleLinkedList();
        /*simpleLinkedList1.addByOrder(heroNode3);
        simpleLinkedList1.addByOrder(heroNode1);*/
        simpleLinkedList1.addByOrder(heroNode4);
        simpleLinkedList1.addByOrder(heroNode2);
        simpleLinkedList2.addByOrder(heroNode3);
        simpleLinkedList2.addByOrder(heroNode1);
        // 遍历第一个单链表
        System.out.println("第一个链表：");
        simpleLinkedList1.allNode();
        // 遍历第一个单链表
        System.out.println("第二个链表：");
        simpleLinkedList2.allNode();
        // 合并两个链表并遍历
        System.out.println("合并后的链表：");
        SimpleLinkedList simpleLinkedList = new SimpleLinkedList();
        simpleLinkedList.mergeTwoSimpleLinkedList(simpleLinkedList1.getHead(), simpleLinkedList2.getHead());
        simpleLinkedList.allNode();

        /*// 逆序输出链表
        System.out.println("两次反转方法，逆序打印链表。。。");
        simpleLinkedList.reversePrint1(simpleLinkedList.getHead());
        System.out.println("利用栈逆序打印链表。。。");
        simpleLinkedList.reversePrint2(simpleLinkedList.getHead());*/

        /*// 反转单链表
        simpleLinkedList.reverse(simpleLinkedList.getHead());
        // 遍历单链表
        System.out.println("反转之后的链表是这样的:");
        simpleLinkedList.allNode();*/

        /*// 遍历单链表
        simpleLinkedList.allNode();
        // 修改单链表的某个节点
        System.out.println("修改单链表之后：");
        HeroNode heroNode = new HeroNode(2, "小卢");
        simpleLinkedList.update(heroNode);
        // 遍历单链表
        simpleLinkedList.allNode();
        // 删除节点
        simpleLinkedList.delete(3);
        // simpleLinkedList.delete(2);
        // simpleLinkedList.delete(1);
        // simpleLinkedList.delete(4);
        System.out.println("删除节点后：");
        // 遍历节点
        simpleLinkedList.allNode();
        // 查看单链表的节点个数
        int length = simpleLinkedList.getLength(simpleLinkedList.getHead());
        System.out.println("这个链表的节点个数为" + length);
        // 查看倒数第N个节点
        HeroNode currentNode = simpleLinkedList.getLastIndexNode(simpleLinkedList.getHead(), 2);
        System.out.println(currentNode);*/

    }


}
青轴绕指柔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表及其简单应用
weixin_56434818的博客
09-14 618
单链表及其应用 为了便于实现插入、删除等操作，在单链表的第一个节点之前增加一个节点，称为头节点。头节点的数据域可以存放如单链表的长度等信息，头节点的指针域存放第一个节点的地址信息，使其指向第一个节点。（若带头节点的单链表为空链表，则头节点的指针域为空） 储存结构 typedef struct node { int data; node* next; }listNode, *linkList; 其中，listNode是单链表的节点类型，linkList是指向单链表节点的指针类型。 基本运算
单链表实现
wave_xiong的博客
11-05 226
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表有一个个节点（Node）组成 每个节点内都会有存放数值和指针的位置。 根据节点的不同可分为如下几种： 今天主要实现无头单链表的基本功能 // 1、无头单向非循环链表实现 public class SingleLinkedList { //头插法 public void add...
【数据结构与算法】深入浅出：单链表的实现和应用
青竹雾色间.的博客
06-07 5082
在本篇博客中，我们将深入探索一种常见的数据结构——单链表。
单链表的应用
m0_69300400的博客
04-11 1320
一、单链表的逆置 可以把逆置的过程看成是重新逆序建链表的过程。 逆置带头结点的单链表的函数如下： void reserve (struct node * head) { struct node *p, *q; p = head->next; head->next = NULL; q = p->next; while (p!=NULL) { p->next = head->next; head
单链表的基本应用
最新发布
2302_80220453的博客
04-27 553
头节点的删除，意味着需要删除头节点的同时，将下一个节点作为新的头节点，否则链表就找不到了，而删除链表节点，就用malloc对应的free函数，用一个变量记头节点的next作为新的头节点，然后将头节点free掉，不要忘了将其置空，虽然不影响大局，但是好的习惯就在平常养成~在寻找尾节点时，用while循环，可以用cur直接作为判断条件，走到NULL，循环终止，但此时无法找到尾节点的位置，因此我们需要一个prev变量记录cur的前一个位置。链表分为单向，双向，带环，不带环，带头，无头的链表。
单链表的应用实例（增删改查）
weixin_58473601的博客
04-20 852
手写单链表的应用实例（增删改查）
数据结构：链表（一）单向链表的实现及应用
2201_75880188的博客
08-05 553
本文对链表的创建即实现进行阐述，主要围绕更易理解和上手实现的无头单向非循环链表进行详细叙述和讲解。
单链表原理解析及应用
qq_32019367的博客
03-14 568
单链表结构在实际应用中还是很广泛的，而且数据插入和删除的效率相比数组类型要好很多。 目录 一、单链表概念 二、单链表的增改删操作 三、单链表的应用 一、单链表概念 那什么是单链表呢？单链表是一种链式的存储结构，存储的数据以节点的方式来表示，而每个节点由数据域和指针域两部分组成。数据域中保存着被存储的数据，而指针域中保存着下一个节点的地址，这样每个节点就形成了一个链状。 二、单链表的增...
单链表应用——学生成绩管理系统.rar
06-04
在本项目中，"单链表应用——学生成绩管理系统"是一个基于C++实现的数据结构课程设计，旨在利用单链表这一基础数据结构来管理学生成绩。下面将详细阐述单链表的概念、其在学生成绩管理中的应用以及如何通过C++实现这...
单链表应用示例
11-07
单链表应用示例 本文旨在介绍使用单链表实现学生成绩管理系统的设计思想和实现方法。单链表是一种常用的数据结构，它可以用来存储和管理大量的数据。在本例中，我们使用单链表来存储学生的成绩信息，并实现了多种...
单链表及其应用
01-07
利用单链表实现电话本的模拟程序：定义单链表的数据类型，将头插法和尾插法、插入、删除、查找、修改、计数、逆置、输出等操作都定义成子函数的形式，最后在主函数中调用它，并将每一种操作前后的结果输出，以查看每...
单链表综合应用.rar
01-13
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛应用。在这个“单链表综合应用”的示例中，我们将深入探讨C语言如何实现单链表的各种操作，包括增加节点、删除节点、修改节点以及查找节点。这些操作是...
单链表_单链表_
10-01
单链表是一种基础的数据结构，它在计算机科学中被广泛应用于数据存储和处理。这个话题主要涉及单链表的基本概念、实现以及常见的操作，如插入、删除和打印节点。 单链表是由一系列节点组成的数据结构，每个节点包含...
单链表的实现
04-21
单链表是一种基础的数据结构，它在计算机科学中扮演着重要的角色。...在实际编程中，单链表被广泛应用于各种场景，如缓存、队列和表达式解析等。在分析和设计算法时，理解链表的特性和操作能帮助我们做出更高效的选择。
单链表代码
02-01
单链表是一种基础的数据结构，它在计算机科学和编程中有着广泛的应用。在这个"单链表代码"压缩包中，我们可以找到用C语言实现的单链表操作的示例代码，这些代码通常会涵盖单链表的基本操作，如创建、插入、删除节点...
单链表应用实例
jefferyfg的博客
09-25 2604
在学习单链表之前，先简单了解一下链表 链表是有序的链表，但它在内存中是存储如下 链表是以节点的方式来存储的，是链式存储 每个节点包含data域、next域：指向下一个节点 链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头结点的列表，根据实际需求来定 单链表（带头结点）逻辑结构示意图如下： 单链表的应用实例： 使用带head头节点的单向链表实现水浒英雄人物的增删改查操作 ， 1....
数据结构和算法 —— 链表（一）单链表的简介及实例应用
T__F的博客
09-24 556
数据结构和算法 —— 链表（一）单链表的简介及应用实例简介概念特点小结内存布局应用实例第一种实现方式创建结点类创建单链表类测试类结果打印第二种实现方式代码测试类结果打印 简介 概念 来源：[百度百科：链表] 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 特点 来源：[百度百科：链表]
数据结构之用单链表的应用实现
apple_53384397的博客
01-08 744
数据结构单链表
单链表应用实例代码C语言
03-25
以下是一个简单的单链表的应用实例代码，使用C语言实现： ```c #include <stdio.h> #include <stdlib.h> // 定义链表结构体 typedef struct Node { int data; struct Node* next; } node; // 创建新节点 node* create_node(int data) { node* new = (node*)malloc(sizeof(node)); new->data = data; new->next = NULL; return new; } // 在链表末尾插入节点 void insert_node(node** head, int data) { node* new = create_node(data); if (*head == NULL) { *head = new; return; } node* current = *head; while (current->next != NULL) { current = current->next; } current->next = new; } // 删除指定值的节点 void delete_node(node** head, int data) { if (*head == NULL) { return; } if ((*head)->data == data) { node* temp = *head; *head = (*head)->next; free(temp); return; } node* current = *head; while (current->next != NULL && current->next->data != data) { current = current->next; } if (current->next != NULL) { node* temp = current->next; current->next = current->next->next; free(temp); } } // 打印链表 void print_list(node* head) { printf("Linked List: "); while (head != NULL) { printf("%d ", head->data); head = head->next; } printf("\n"); } int main() { node* head = NULL; insert_node(&head, 1); insert_node(&head, 2); insert_node(&head, 3); insert_node(&head, 4); insert_node(&head, 5); print_list(head); delete_node(&head, 3); print_list(head); delete_node(&head, 1); print_list(head); return 0; } ``` 该代码实现了一个单链表的基本操作，包括创建节点、在末尾插入节点、删除指定值的节点和打印链表。可以通过在 `main` 函数中调用这些函数来使用这个单链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值