数据结构

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

单链表相关


自己写的笔记（单链表带有头节点，头节点不存储数据），方便日后查看！

反转

//单链表反转
    public static void reserveList(Node head) {
        //当前链表为空 或 只有一个节点 直接返回 无需反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        Node temp = head.next;
        Node reserveHead = new Node(0, "");
        Node next;
        //Node cur;
        while (true) {        
            if (temp == null) {
                break;
            }
            next = temp.next;

            temp.next = reserveHead.next;
            reserveHead.next = temp;

            temp = next;

        }

        head.next = reserveHead.next;
    }

逆序打印（栈）

public static void reservePrint(Node head) {
        Stack<Node> stack = new Stack<>();
        Node temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }

            stack.push(temp);
            temp = temp.next;
        }

        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }

    }

两个有序合并为一个有序

public static Node mergeTwoList(Node head1, Node head2) {
        if (head1.next == null && head2.next == null) {
            return null;
        }
        if (head1.next == null) {
            return head2 ;
        }
        if (head2.next == null) {
            return head1 ;
        }
        //合并后单链表头结点
        Node head = head1.next.no < head2.next.no ? head1 : head2;
        Node cur1 = head == head1 ? head1.next : head2.next;
        Node cur2 = head == head1 ? head2.next : head1.next;
        Node pre = null;//cur1前一个元素
        Node next = null;//cur2的后一个元素
        while (cur1 != null && cur2 != null) {
            //第一次进来肯定走这里
            if (cur1.no  <= cur2.no ) {
                pre = cur1;
                cur1 = cur1.next;
            } else {
                next = cur2.next;
                pre.next = cur2;
                cur2.next = cur1;
                pre = cur2;
                cur2 = next;
            }
        }
        pre.next = cur1 == null ? cur2 : cur1;
        return head;

    }

统计有效节点个数



public int getSize(){
        if (head.next == null) {
            return 0;
        }
        Node temp = head;
        int length = 0;
        while (true) {
            if (temp.next == null) {
                break;
            }
            length++;
            temp = temp.next;
        }
        return length;
    }

查找倒数第k个节点

public Node getConvertNode(int k){
        //int index = getSize() - k;
        Node temp = head.next;
        if (k < 0 || k > getSize()) {
            return null;
        }

        for (int i = 0; i < getSize() - k; i++) {
            temp = temp.next;
        }
        return temp;

    }

完整版

总代码
package test;

import java.util.Stack;

public class Link {
    public static void main(String[] args) {
        //Node node1 = new Node(1, "宋江");
        Node node1 = new Node(1, "林冲");
        Node node2 = new Node(2, "林冲");
        Node node3 = new Node(3, "林冲");
        Node node4 = new Node(4, "林冲");
        Node node5 = new Node(5, "林冲");
        Node node6 = new Node(6, "林冲");
        Node node7 = new Node(7, "林冲");
        LinkedList linkedList1 = new LinkedList();
        LinkedList linkedList2 = new LinkedList();
        linkedList1.addByOrder(node2);
        linkedList1.addByOrder(node3);
        linkedList1.addByOrder(node4);
        linkedList1.addByOrder(node7);

        linkedList2.addByOrder(node1);
        linkedList2.addByOrder(node3);
        linkedList2.addByOrder(node5);
        linkedList2.addByOrder(node6);
//        show(linkedList1.getHead());
//        show(linkedList2.getHead());
        Node head = mergeTwoList(linkedList1.getHead(), linkedList2.getHead());
        //reserveList(linkedList.getHead());
        //linkedList.reserve();
        //System.out.println(linkedList.getConvertNode(3));
        //linkedList.delete(4);
        //linkedList.show();
       // System.out.println(linkedList.getSize());

        //reservePrint(linkedList.getHead());
        show(head);
    }

    //单链表反转
    public static void reserveList(Node head) {
        //当前链表为空 或 只有一个节点 直接返回 无需反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        Node temp = head.next;
        Node reserveHead = new Node(0, "");
        Node next;
        //Node cur;
        while (true) {
//            if (temp.next == null) {
//                break;
//            }
//            temp.next.next = reserveHead.next;
//            reserveHead.next = temp;
//            //temp.next = reserveHead.next.next;
//            temp = temp.next;
            if (temp == null) {
                break;
            }
            next = temp.next;

            temp.next = reserveHead.next;
            reserveHead.next = temp;

            temp = next;

        }

        head.next = reserveHead.next;
    }

    //逆序打印链表
    public static void reservePrint(Node head) {
        Stack<Node> stack = new Stack<>();
        Node temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }

            stack.push(temp);
            temp = temp.next;
        }

        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }

    }

    public static Node mergeTwoList(Node head1, Node head2) {
        if (head1.next == null && head2.next == null) {
            return null;
        }
        if (head1.next == null) {
            return head2 ;
        }
        if (head2.next == null) {
            return head1 ;
        }
        //合并后单链表头结点
        Node head = head1.next.no < head2.next.no ? head1 : head2;
        Node cur1 = head == head1 ? head1.next : head2.next;
        Node cur2 = head == head1 ? head2.next : head1.next;
        Node pre = null;//cur1前一个元素
        Node next = null;//cur2的后一个元素
        while (cur1 != null && cur2 != null) {
            //第一次进来肯定走这里
            if (cur1.no  <= cur2.no ) {
                pre = cur1;
                cur1 = cur1.next;
            } else {
                next = cur2.next;
                pre.next = cur2;
                cur2.next = cur1;
                pre = cur2;
                cur2 = next;
            }
        }
        pre.next = cur1 == null ? cur2 : cur1;
        return head;

    }

    public static Node mergeTwoList1(Node head1, Node head2) {
        if (head1.next == null && head2.next == null) {
            return null;
        }
        if (head1.next == null) {
            return head2;
        }
        if (head2.next == null) {
            return head1;
        }

        Node head = head1.next.no > head2.next.no ? head2 : head1;
        Node cur1 = head == head2 ? head2.next : head1.next;
        Node cur2 = head == head2 ? head1.next : head2.next;
        Node pre = null;
        Node next = null;
        while (cur1 != null && cur2 != null) {
            if (cur1.no < cur2.no) {
                pre = cur1;
                cur1 = cur1.next;
            } else {
                next = cur2.next;
                pre.next = cur2;
                cur2.next = cur1;
                pre = cur2;
                cur2 = next;
            }
        }
        pre.next = cur1 != null ? cur1 : cur2;
        return head;

    }
    //显示链表
    public static void show(Node head){
        Node temp = head;
        if (temp.next == null) {
            System.out.println("链表为空！");
            return;
        }
        while (true) {
            if (temp.next == null) {
                break;
            }
            System.out.println(temp.next);
            temp = temp.next;
        }
    }
}
//定义链表类
class LinkedList{
    //头节点
    private Node head = new Node(0, "");

    public Node getHead() {
        return head;
    }

    //1.加入数据
    public void add(Node node){
        Node temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = node;
    }
    

    public void addByOrder(Node newNode){
        Node temp = head;
        boolean flag = false;//是否存在
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > newNode.no) {
                break;
            } else if (temp.next.no == newNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("编号为" + newNode.no + "已存在");
        } else {
            newNode.next = temp.next;
            temp.next = newNode;
        }
    }
    //3.修改数据   根据no修改
    public void update(Node newNode) {
        Node temp = head;
        boolean flag = false;//是否找到
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == newNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            //temp.next.no = newNode.no;
            temp.next.name = newNode.name;
        } else {
            System.out.println("要修改的信息不存在！");
        }
    }
    //4.删除数据
    public void delete(int no) {
        Node temp = head;
        boolean flag = false;//是否找到
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (false) {
            temp.next = temp.next.next;
        } else {
            System.out.println("没有找到要删除的编号为" + no + "的节点");
        }
    }
    //5.显示
    public void show(){
        Node temp = head;
        if (temp.next == null) {
            System.out.println("链表为空！");
            return;
        }
        while (true) {
            if (temp.next == null) {
                break;
            }
            System.out.println(temp.next);
            temp = temp.next;
        }
    }
    //6.统计有效节点的个数
    public int getSize(){
        if (head.next == null) {
            return 0;
        }
        Node temp = head;
        int length = 0;
        while (true) {
            if (temp.next == null) {
                break;
            }
            length++;
            temp = temp.next;
        }
        return length;
    }
    //7.查找倒数第K个节点
    public Node getConvertNode(int k){
        //int index = getSize() - k;
        Node temp = head.next;
        if (k < 0 || k > getSize()) {
            return null;
        }

        for (int i = 0; i < getSize() - k; i++) {
            temp = temp.next;
        }
        return temp;

    }
    //8.单链表的反转
    public void reserve(){
        if (head.next == null || head.next.next == null) {
            return;
        }
        Node reserveHead = new Node(0, "");
        Node temp = head.next;
        Node next;
        while (true) {
            if (temp == null) {
                break;
            }
            next = temp.next;
            temp.next = reserveHead.next;
            reserveHead.next = temp;
            temp = next;
        }

        head.next = reserveHead.next;

    }

}
//定义节点类
class Node{
    public int no;
    public String name;
    public Node next;
    public Node(int no, String name) {
        this.no = no;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}
weixin_44347932
关注
专栏目录
数据结构——线性表的查找
Labrador_Katie的博客
02-22 5136
查找查找的概念线性表的查找顺序查找（线性查找）折半查找（二分或对分查找）分块查找 查找的概念 主关键字：可唯一地标识一个记录的关键字就是主关键字 次关键字：用以识别若干记录的关键字就是次关键字 对查找表经常进行的操作： 查询某个“特定的”数据元素是否在查找表中 检索某个“特定的”数据元素的各种属性 在查找表中插入一个数据元素 删除查找表中的某个数据元素 查找表可以分为两类： 静态查找表：   仅作“查询”（检索）操作的查找表 动态查找表：   作“插入”和“删除”操作的查找表   有时在查询之后，还需
数据结构和算法PDF文档
06-02
1000多页的算法题解，包含数据结构，排序，查找，递归，回溯算法，二叉树，动态规划，贪心算法，双指针，滑动窗口，前缀和等。
专升本数据结构复习
emmmheng的博客
03-03 1万+
数据结构知识点总汇 主要参考书目： 程海英老师的《数据结构（C语言版）》教材 严蔚敏，李冬梅，吴伟民．《数据结构（C语言版）》 说明：这是本人专升本上岸一年后写的，本篇包含知识点和例题总结。因为是当时自己手码的，所以知识点有冗余和顺序错位。如果发现有错误之处，欢迎评论区留言，看到后及时改正，谢谢！最后祝大家好好学习，积极向上，早日上岸！ ① 数据结构(逻辑结构)其4类基本结构：集合、线性结构、树形结构、图状结构 和 网状结构。 ② 物理结构(存储结构)其4种存储结构：顺序存储结构、链式存储结构、索引存储
索引数据结构
swadian2008的博客
04-03 4007
目录 1、二叉树 2、红黑树 3、hash表 4、B树(B+树) 5、MySQL中的数据库索引 具备充当索引的数据结构有以下几种：二叉树、红黑树、hash表、B树(B+树)。 而我们数据库最终使用的是B+树(B+树的改进，叶子节点间添加了双向指针，便于范围查找)。 数据结构可视化网站：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html 1、二叉树 二叉树特点是每个节点最多只能有两棵子树，且有左右之分。如果是顺序的.
数据结构--二叉树遍历(详细过程)
热门推荐
m0_56283131的博客
04-21 3万+
详细到啰嗦的程度，完全0基础都可完成。
数据结构知识总结
weixin_46678423的博客
08-21 1646
1.数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和运算等的学科。 2.数据结构被形式地定义为（D, R），其中D是数据元素的有限集合，R是D上的关系有限集合。 3.数据结构包括数据的逻辑结构、数据的存储结构和数据的运算这三个方面的内容。 4.数据结构按逻辑结构可分为两大类，它们分别是线性结构和非线性结构。 5.线性结构中元素之间存在一对一关系，树形结构中...
Matlab基本数据结构
MTALAB的博客
02-01 2944
matlab基本数据结构和操作
BUAA 数据结构总结
Schrodinger007的博客
07-05 1万+
概要 2021春 数据结构课程 上机作业编程题 各章知识点总结 期中期末考试题 编程代码超详细注释 目录 BUAA 数据结构总结——第1节 BUAA 数据结构总结——第2节 BUAA 数据结构总结——第3节 BUAA 数据结构总结——第4节（栈和队） BUAA 数据结构总结——第5节（树） BUAA 数据结构总结——第6节（查找与排序） BUAA 数据结构总结——第7节（图） BUAA 数据结构总结——大作业（文本摘要生成） 2020级期末考试 ......
数据结构——排序之冒泡排序
Renswc的博客
03-22 4980
冒泡排序（BubbleSort）是一种计算机科学领域的较简单的排序算法。它的基本思想是通过重复遍历待排序的数据集，并依次比较相邻的两个数据项，如果它们的顺序错误则进行交换。这个过程会持续重复直到所有相邻的数据项都已经交换完毕，此时说明该数据集已经排好序。冒泡排序的名称来源于排序过程中，较小的数据项会被逐渐“浮”到数组顶部，这个过程就像碳酸饮料中二氧化碳气泡最终会上浮到顶部的现象一样。因此，这种排序算法因其这一特性而得名。冒泡函数的核心思想。
【数据结构】数据结构总结 & 应用场景
学习 & 分享 ~
10-27 4351
内存中数据的存储形式分为连续存储和离散存储两种，分别对应了数组和链表。数组：元素在内存中连续存储，即内存地址连续，所以查找数据效率高，但需要预先申请一块连续的内存空间，且运行期间数组大小无法动态增加减少。在插入、删除元素时效率比较低，伴随着后面元素位置的移动。数组的应用场景：当数据量比较小，数据规模已知且需要经常访问元素时用数组更合适。链表：动态申请 / 删除内存空间，对于元素的增删比较灵活，不需要预先知道数据规模，但无法随机查找。另外有序数组可以通过二分法来查找目标，但链表只能用顺序查找。链表应用场景：对
数据结构（期末总复习）
star_seaa的博客
12-08 4547
数据结构（期末总复习）
最值得收藏的 数据结构 全部知识点思维导图整理(王道考研), 附带经典题型整理.emmx
03-27
用mindmaster打开文件, 本文的思维导图根据王道的数据结构书本整理而来并标记出重点内容，包括了知识点和部分课后习题
长沙理工大学数据结构真题+答案【2006-2020长沙理工大学数据结构初试真题+答案】
10-03
长沙理工大学数据结构真题+答案【2006-2020长沙理工大学数据结构初试真题+答案 长沙理工大学考研数据结构真题，包含近十年初试真题+答案，和近几年复试真题。本人花钱购买的，已上岸。考试代码850；真题加答案
《趣学数据结构》课件.rar
10-03
《趣学数据结构》课件.rar 《趣学数据结构》课件.rar《趣学...《趣学数据结构》课件.rar《趣学数据结构》课件.rar《趣学数据结构》课件.rar《趣学数据结构》课件.rar《趣学数据结构》课件.rar《趣学数据结构》课件.rar
C++数据结构与算法 （第4版）
01-06
根据提供的文件信息，这里主要关注的是“C++数据结构与算法（第4版）”这一主题，虽然实际内容并未给出具体章节或知识点，但我们可以基于标题、描述以及部分已知内容来推测书中可能涵盖的关键知识点。 ### C++数据...
C语言-数据结构 折半查找
BamBoo_Bean的博客
10-12 214
C语言-数据结构 折半查找
【数据结构-栈】【差分思想-延迟更新优化】力扣1381. 设计一个支持增量操作的栈
sjsjs11的博客
10-11 760
第二次将前k+3个元素增加了val2，也就是add[k+2]=val2，那么他们共同覆盖的范围是不是前k+1个元素，那么也就是说，前k+1个元素增量是val1+val2，在第k+2到k+3个元素，增量是val2。这时候假设我们进行三次pop()操作，那么stk[k+2] += add[k+2]，然后add[k+2]将增量传给add[k+1]（使用+=），这时候stk[k+1] += add[k+1]，依旧是加上val2。// 返回 2 --> 返回栈顶值 2，栈变为 [1]// 栈变为 [1, 2, 3]
数据结构 - 链表
IT规划师
10-12 1181
本文介绍了链表的基本概念、节点和头指针的定义，链表的分类及实现方式。通过自申请内存空间和维护，实现了单链表的操作，包括初始化、插入、查找、更新、移除和销毁等操作，并提供了代码示例。
数据结构：B树
最新发布
盒马的博客
10-15 628
讲解以C++实现的数据结构B树
数据结构基础概念解析
"数据结构概念名词解释大全" 数据结构是计算机科学中不可或缺的一部分，它主要研究数据的组织方式，以及如何高效地存储和处理这些数据。以下是对标题和描述中涉及的一些关键概念的详细解释： 1. **数据**：数据是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值