单链表的创建遍历和按照顺序插入，删除，修改节点

已于 2024-03-16 21:28:29 修改
阅读量124 收藏
点赞数 1
分类专栏： java数据结构和算法 文章标签： java 算法 数据结构
于 2024-03-16 14:35:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44847284/article/details/136761856
版权

1.单链表创建和遍历

1.1.单链表的尾部添加数据，按添加顺序来添加的子节点
package link;

import org.junit.Test;

//单链表创建和遍历
public class LinkList {

    @Test
    public void test(){
        //创建一个单链表
        SingLinkList singLinkList=new SingLinkList(); //已经加载了头节点
        //创建英雄节点
        HeroNode hero1=new HeroNode(1,"宋江","及时雨");
        HeroNode hero2=new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3=new HeroNode(3,"吴用","智多星");
        HeroNode hero4=new HeroNode(4,"林冲","豹子头");
        HeroNode hero5=new HeroNode(5,"玛丽亚","***");
        //按添加顺序来添加的子节点
        singLinkList.add(hero1);
        singLinkList.add(hero2);
        singLinkList.add(hero3);
        singLinkList.add(hero4);
        singLinkList.add(hero5);

        singLinkList.show();
    }

}

//定义一个单链表
class SingLinkList{
    //定义一个头节点   方便找到初始位置
    HeroNode headNode=new HeroNode(); //头节点 里面不要任何的数据 单纯的定位
    //添加节点
    public  void add(HeroNode node){
        //首先要找到最后一个节点  如果最后一个节点.next==null  那么这个就是最后节点
        HeroNode temp=headNode; //定义一个辅助遍历，因为头节点不能动，类似于指针
        while(true){
            if(temp.next==null){  //找到最后节点
                break;
            }
            temp=temp.next; //依次往后遍历
        }
        temp.next=node;  //头节点 -> node ->....
    }
    //遍历所有节点
    public void show(){
        if(headNode.next==null){
            System.out.println("空数据~~~~~");
            return;
        }
        HeroNode temp=headNode; //定义一个辅助遍历，因为头节点不能动，类似于指针
        while ((temp=temp.next)!=null){
            System.out.println(temp.toString());
        }
    }


}
//定义一个英雄节点
class HeroNode{
    int no;
    String name;
    String nickName; //昵称
    HeroNode next;  //默认是null
    public HeroNode(){}
    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" + "no=" + no + ", name='" + name + '\'' + ", nickName='" + nickName+"}'";
    }
}
1.2.按照no排名顺序添加到单链表,以及删除，修改链表节点
package link;

import org.junit.Test;

//单链表创建和遍历
public class LinkList {

    @Test
    public void test() {
        //创建一个单链表
        SingLinkList singLinkList = new SingLinkList(); //已经加载了头节点
        //创建英雄节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        HeroNode hero5 = new HeroNode(5, "玛丽亚", "***");
        //按添加顺序来添加的子节点
        //        singLinkList.add(hero1);
        //        singLinkList.add(hero2);
        //        singLinkList.add(hero3);
        //        singLinkList.add(hero4);
        //        singLinkList.add(hero5);
        //通过no 排名来添加节点
        singLinkList.addOrderByNo(hero4);
        singLinkList.addOrderByNo(hero2);
        singLinkList.addOrderByNo(hero3);
        singLinkList.addOrderByNo(hero1);
        singLinkList.addOrderByNo(hero5);
        singLinkList.addOrderByNo(hero5);
        singLinkList.show();
        //修改节点
        HeroNode newNode=new HeroNode(5,"超级玛丽亚","******");
        singLinkList.update(newNode);
        System.out.println("修改后的数据:");
        singLinkList.show();
        //删除节点
        singLinkList.delete(3);
        System.out.println("删除后的数据:");
        singLinkList.show();
    }

}

//定义一个单链表
class SingLinkList {
    //定义一个头节点   方便找到初始位置
    HeroNode headNode = new HeroNode(); //头节点 里面不要任何的数据 单纯的定位
    public HeroNode getHeadNode() {
        return headNode;
    }

    //删除节点  1.找到该节点的前一个节点  再temp.next=temp.next.next
    public void delete(int no) {
        HeroNode temp = headNode;
        boolean flag = false;
        while (temp != null) {
            if (temp.next.no == no) {
                flag = true;  //找到该节点
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
            //没有引用的节点，gc(),垃圾回收机制会回收
        } else {
            System.out.println("链表里没有该节点~");
        }
    }

    //修改节点
    public void update(HeroNode node) {
        HeroNode temp = headNode;
        boolean flag = false;
        while (temp != null) {
            if (temp.next.no == node.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next.name = node.name;
            temp.next.nickName = node.nickName;
        } else {
            System.out.println("链表里没有该节点~");
        }
    }


    //按照 no 排名 按顺序来添加
    //1.先判断链表里的no 和node.no 是不是重复
    //2.找到 比no大的节点的前面节点。也就是 temp.next.no>node.no
    public void addOrderByNo(HeroNode node) {
        HeroNode temp = headNode;
        boolean flag = false;
        while (temp!=null) {  //当temp==null 结束循环
            if (temp.next == null) {
                temp.next=node;
                break;
            }
            if (temp.next.no == node.no) {
                flag = true;  //找到了重复的id
                break;
            } else if (temp.next.no > node.no) {
                node.next = temp.next;
                temp.next = node;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("重复%d编号，不能添加!\n", node.no);
        }

    }

    //添加节点
    public void add(HeroNode node) {
        //首先要找到最后一个节点  如果最后一个节点.next==null  那么这个就是最后节点
        HeroNode temp = headNode; //定义一个辅助遍历，因为头节点不能动，类似于指针
        while (true) {
            if (temp.next == null) {  //找到最后节点
                break;
            }
            temp = temp.next; //依次往后遍历
        }
        temp.next = node;  //头节点 -> node ->....
    }

    //遍历所有节点
    public void show() {
        if (headNode.next == null) {
            System.out.println("空数据~~~~~");
            return;
        }
        HeroNode temp = headNode; //定义一个辅助遍历，因为头节点不能动，类似于指针
        while ((temp = temp.next) != null) {
            System.out.println(temp.toString());
        }
    }


}

//定义一个英雄节点
class HeroNode {
    int no;
    String name;
    String nickName; //昵称
    HeroNode next;  //默认是null

    public HeroNode() {
    }

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

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

1.3.求单链表中有效节点的个数
 //求点链表中有效节点的个数
    public  int getLength(HeroNode node){ //传来头节点
        HeroNode temp=node;
        if(temp.next==null){
            return 0;  //没有数据
        }
        int length=0;
        while((temp=temp.next)!=null){
            length++;
        }
        return length;
    }
1.4.查找单链表中的倒数第k个节点
    //查找单链表中的倒数第k个节点
    public HeroNode findNode(HeroNode node,int k){
        HeroNode temp=node.next; //指向第一个有效节点
        //统计传过来的链表的有效个数
        int count=getLength(temp);
        if(count<=0){
            return null;
        }else {
        //倒数k个 =count-k
        int all=count-k;
            while(all>=0){
                temp=temp.next;
                all--;
            }
            return temp;
        }
    }
1.5.单链表的反转
 @Test
    public  void test2(){
        //创建一个单链表
        SingLinkList slist = new SingLinkList(); //已经加载了头节点
        //创建英雄节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        HeroNode hero5 = new HeroNode(5, "玛丽亚", "***");
        slist.add(hero1);
        slist.add(hero2);
        slist.add(hero3);
        slist.add(hero4);
        slist.add(hero5);
        System.out.println("单链表的正序:");
        slist.show();
        System.out.println("下面是单链表的反转:");
         //5.单链表的反转 结构上发生了改变
        HeroNode newNode=slist.reserveNodeList(slist.getHeadNode());
        HeroNode temp=newNode;
        slist.getHeadNode().next=temp.next;
        slist.show();
}
//定义一个单链表
class SingLinkList {
    //定义一个头节点   方便找到初始位置
    HeroNode headNode = new HeroNode(); //头节点 里面不要任何的数据 单纯的定位
    public HeroNode getHeadNode() {
        return headNode;
    }
 //5.单链表的反转 结构上发生了改变
    public  HeroNode  reserveNodeList(HeroNode node){
        HeroNode temp=node.next;
        if(temp==null){
            System.out.println("空链表~");
            return null;
        }
        //定义一个新的表头 , 把老链表的所有节点遍历，依次把节点放到新链表的开始位置。
        HeroNode newNode=new HeroNode();
        HeroNode cur=null;
        while (temp!=null){
            cur=temp.next;   //先用cur保存下一个节点  表头->temp->temp.next
            temp.next=newNode.next; //给新表连接 新表头->temp
            newNode.next=temp;
            temp=cur;   //temp->temp.next
        }
        return newNode;
    }
}
1.6.从尾到头打印单链表(Stack 栈 先进后出)
    



public void StackNode(HeroNode node){
        Stack<HeroNode>stack=new Stack<HeroNode>();
        if (node.next == null) {
            System.out.println("空数据~~~~~");
            return;
        }
        HeroNode temp= node; //定义一个辅助遍历，因为头节点不能动，类似于指针
        while ((temp = temp.next) != null) {
            stack.add(temp);
        }
        System.out.println(stack.toString());
       while(stack.size()>0){
           System.out.println(stack.pop());
       }
    }

1.7.合并两个有序的单链表，合并之后的链表仍然有序
//.todo 合并两个有序的单链表，合并之后的链表仍然有序

2.代码全集

package link;

import org.junit.Test;

import java.util.Stack;

//单链表创建和遍历
public class LinkList {

    @Test
    public void test() {
        //创建一个单链表
        SingLinkList singLinkList = new SingLinkList(); //已经加载了头节点
        //创建英雄节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        HeroNode hero5 = new HeroNode(5, "玛丽亚", "***");
        //按添加顺序来添加的子节点
        //        singLinkList.add(hero1);
        //        singLinkList.add(hero2);
        //        singLinkList.add(hero3);
        //        singLinkList.add(hero4);
        //        singLinkList.add(hero5);
        //通过no 排名来添加节点
        singLinkList.addOrderByNo(hero4);
        singLinkList.addOrderByNo(hero2);
        singLinkList.addOrderByNo(hero3);
        singLinkList.addOrderByNo(hero1);
        singLinkList.addOrderByNo(hero5);
        singLinkList.addOrderByNo(hero5);
        singLinkList.show();
        //修改节点
        HeroNode newNode=new HeroNode(5,"超级玛丽亚","******");
        singLinkList.update(newNode);
        System.out.println("修改后的数据:");
        singLinkList.show();
        //删除节点
        singLinkList.delete(3);
        System.out.println("删除后的数据:");
        singLinkList.show();
    }

    @Test
    public  void test2(){
        //创建一个单链表
        SingLinkList slist = new SingLinkList(); //已经加载了头节点
        //创建英雄节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        HeroNode hero5 = new HeroNode(5, "玛丽亚", "***");
        slist.add(hero1);
        slist.add(hero2);
        slist.add(hero3);
        slist.add(hero4);
        slist.add(hero5);
        //求单链表中有效节点的个数
        int size=slist.getLength(slist.getHeadNode());
        System.out.println("单链表中有效节点的个数:"+size);
        HeroNode node = slist.findNode(slist.getHeadNode(), 3);//倒数第三
        System.out.println("单链表倒数第三个:"+node.toString());
        System.out.println("单链表的正序:");
        slist.show();
        System.out.println("下面是单链表的反转:");
        //5.单链表的反转 结构上发生了改变
        HeroNode newNode=slist.reserveNodeList(slist.getHeadNode());
        HeroNode temp=newNode;
        slist.getHeadNode().next=temp.next;
        slist.show();

        System.out.println("从尾到头打印单链表(Stack 栈 先进后出)");
        //从尾到头打印单链表(Stack 栈 先进后出)
        slist.StackNode(slist.getHeadNode());

    }
}

//定义一个单链表
class SingLinkList {
    //定义一个头节点   方便找到初始位置
    HeroNode headNode = new HeroNode(); //头节点 里面不要任何的数据 单纯的定位

    public HeroNode getHeadNode() {
        return headNode;
    }
    public void StackNode(HeroNode node){
        Stack<HeroNode>stack=new Stack<HeroNode>();
        if (node.next == null) {
            System.out.println("空数据~~~~~");
            return;
        }
        HeroNode temp= node; //定义一个辅助遍历，因为头节点不能动，类似于指针
        while ((temp = temp.next) != null) {
            stack.add(temp);
        }
        System.out.println(stack.toString());
       while(stack.size()>0){
           System.out.println(stack.pop());
       }
    }

    //查找单链表中的倒数第k个节点
    public HeroNode findNode(HeroNode node,int k){
        HeroNode temp=node.next; //指向第一个有效节点
        //统计传过来的链表的有效个数
        int count=getLength(temp);
        if(count<=0){
            return null;
        }else {
        //倒数k个 =count-k
        int all=count-k;
            while(all>=0){
                temp=temp.next;
                all--;
            }
            return temp;
        }
    }

    //5.单链表的反转 结构上发生了改变
    public  HeroNode  reserveNodeList(HeroNode node){
        HeroNode temp=node.next;
        if(temp==null){
            System.out.println("空链表~");
            return null;
        }
        //定义一个新的表头 , 把老链表的所有节点遍历，依次把节点放到新链表的开始位置。
        HeroNode newNode=new HeroNode();
        HeroNode cur=null;
        while (temp!=null){
            cur=temp.next;   //先用cur保存下一个节点  表头->temp->temp.next
            temp.next=newNode.next; //给新表连接 新表头->temp
            newNode.next=temp;
            temp=cur;   //temp->temp.next
        }
        return newNode;
    }


    //求点链表中有效节点的个数
    public  int getLength(HeroNode node){ //传来头节点
        HeroNode temp=node;
        if(temp.next==null){
            return 0;  //没有数据
        }
        int length=0;
        while((temp=temp.next)!=null){
            length++;
        }
        return length;
    }

    //删除节点  1.找到该节点的前一个节点  再temp.next=temp.next.next
    public void delete(int no) {
        HeroNode temp = headNode;
        boolean flag = false;
        while (temp != null) {
            if (temp.next.no == no) {
                flag = true;  //找到该节点
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
            //没有引用的节点，gc(),垃圾回收机制会回收
        } else {
            System.out.println("链表里没有该节点~");
        }
    }

    //修改节点
    public void update(HeroNode node) {
        HeroNode temp = headNode;
        boolean flag = false;
        while (temp != null) {
            if (temp.next.no == node.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next.name = node.name;
            temp.next.nickName = node.nickName;
        } else {
            System.out.println("链表里没有该节点~");
        }
    }


    //按照 no 排名 按顺序来添加
    //1.先判断链表里的no 和node.no 是不是重复
    //2.找到 比no大的节点的前面节点。也就是 temp.next.no>node.no
    public void addOrderByNo(HeroNode node) {
        HeroNode temp = headNode;
        boolean flag = false;
        while (temp!=null) {  //当temp==null 结束循环
            if (temp.next == null) {
                temp.next=node;
                break;
            }
            if (temp.next.no == node.no) {
                flag = true;  //找到了重复的id
                break;
            } else if (temp.next.no > node.no) {
                node.next = temp.next;
                temp.next = node;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("重复%d编号，不能添加!\n", node.no);
        }

    }

    //添加节点
    public void add(HeroNode node) {
        //首先要找到最后一个节点  如果最后一个节点.next==null  那么这个就是最后节点
        HeroNode temp = headNode; //定义一个辅助遍历，因为头节点不能动，类似于指针
        while (true) {
            if (temp.next == null) {  //找到最后节点
                break;
            }
            temp = temp.next; //依次往后遍历
        }
        temp.next = node;  //头节点 -> node ->....
    }

    //遍历所有节点
    public void show() {
        if (headNode.next == null) {
            System.out.println("空数据~~~~~");
            return;
        }
        HeroNode temp = headNode; //定义一个辅助遍历，因为头节点不能动，类似于指针
        while ((temp = temp.next) != null) {
            System.out.println(temp.toString());
        }
    }


}

//定义一个英雄节点
class HeroNode {
    int no;
    String name;
    String nickName; //昵称
    HeroNode next;  //默认是null

    public HeroNode() {
    }

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

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

知识灌溉
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于单链表实现直接插入排序算法详解
sunnyoldboy博客
09-26 8402
插入排序属于稳定排序法，是一种常用的排序算法。直接插入排序算法可以利用静态数组来实现，也可以使用静态链表或者单链表来实现。本文给出了直接插入算法的单链表实现方法。
【数据结构】单链表保持顺序插入详解
这里是Mae。
10-02 1997
单链表的顺序插入 例如： 将 五个数据 （6 4 5 3 1） 插入到单链表使他们从小到大排列 注意：先插入再排序 //头文件 #ifndef LINKLIST_H_INCLUDED #define LINKLIST_H_INCLUDED struct Node{ Node *next; int data; }; class LinkList{ public: LinkList(int *arr,int n); LinkList(); ~LinkList();
单链表的创建示意图, 显示单向链表的分析
qq_39368007的博客
03-20 432
SingleLinkedListDemo.java package com.dym.linkedlist; import java.util.Stack; public class SingleLinkedListDemo { public static void main(String[] args) { //进行测试 //先创建节点 HeroNode hero1 = new HeroNode(1, "宋江", "及时雨"); HeroNode hero2 = new ...
图解Java数据结构和算法
06-21
1.算法是程序的灵魂，优秀的程序在对海量数据处理时，依然保持高速计算，就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少，但存在两个问题：1)授课方式单一，大多是照着代码念一遍，数据结构和算法本身就比较难理解，对基础好的学员来说，还好一点，对基础不好的学生来说，基本上就是听天书了2)说是讲数据结构和算法，但大多是挂羊头卖狗肉，算法讲的很少。 本课程针对上述问题，有针对性的进行了升级 3)授课方式采用图解+算法游戏的方式，让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外，还包括程序员常用10大算法：二分查找算法（非递归）、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题，让你秒杀其他面试小伙伴3.如果你不想永远都是代码工人，就需要花时间来研究下数据结构和算法。教程内容：本教程是使用Java来讲解数据结构和算法，考虑到数据结构和算法较难，授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。学习目标：通过学习，学员能掌握主流数据结构和算法的实现机制，开阔编程思路，提高优化程序的能力。
单链表 -- 直接插入排序
vv_017的博客
05-29 2万+
单链表 – 直接插入排序 直接插入排序就是： 先从待排序的元素中取出第一个元素。 取出的这个第一个元素当作有序区的第一个元素。 接着从待排序的元素中取出第二个元素。 然后将第二个元素插入到有序区中的合适位置，也就是，将第二个元素与第一个元素比较，谁小谁就排在有序区的前面。 接着，在待排序的元素中取第三个元素，然后再在有序区中比较，直至取遍所有待排序的元素。 例题 有一个带头节点的...
单链表的插入删除 遍历等操作
12-05
在计算机科学中，理解并掌握单链表的插入、删除和遍历等操作是至关重要的，因为它们构成了许多高级数据结构和算法的基础。 首先，我们来详细探讨单链表的结构。每个节点通常包含两个部分：数据域和指针域。数据域...
03016202万玥汝第一次实验报告_单链表逆转_单链表后插入新节点_删除结点_查找结点_
10-02
总结来说，单链表逆转涉及改变节点间的指针关系，插入新节点需考虑是否在特定位置还是链表末尾，删除节点需注意调整前后节点的连接，而查找节点则依赖于顺序遍历。这些都是单链表操作的基本技巧，对于理解和运用数据...
单链表顺序查找和插入.docx
01-13
本文主要讨论了在C语言中如何实现单链表的顺序查找和插入操作，适合C语言和数据结构的初学者学习。 首先，我们定义了链表节点的数据类型`ElemType`为整型，通过`typedef`关键字。接着，定义了一个结构体`struct ...
单链表的插入和删除
04-25
在本实验中，我们重点讨论的是如何在单链表中进行插入和删除操作，以及如何创建一个不允许重复元素的单链表。 首先，创建单链表的过程是通过尾插入法实现的。`CreatListR1` 函数首先分配一个头节点，并将其`next`...
单链表的插入和删除实验报告 (2).pdf
07-12
单链表的插入和删除操作的时间复杂度通常是O(n)，因为最坏情况下可能需要遍历整个链表。其中，查找操作的时间复杂度也是O(n)，但可以优化，例如使用哈希表或二分查找等方法。 六、用户交互 在主函数`main()`中，...
单链表按照顺序插入节点
给你更好的
02-22 2080
单链表按照顺序插入节点 按照节点的no值进行排序插入链表 插入时： 定义一个temp辅助节点，插入的位置即：temp之后 如图：插入时，temp为2节点 temp.next = 节点4 因此有： 插入节点.next = temp.next temp.next == 插入节点 package linkedList; public class SingleLinked...
单链表顺序插入节点
莫逸雪的博客
12-23 580
主函数测试： public static void main(String[] args){ Scanner scanner=new Scanner(System.in); //先创建节点 HeroNode hero1=new HeroNode(1,"宋江","及时雨"); HeroNode hero2=new HeroNode(2...
C 单链表的顺序插入
xjd34456的专栏
04-09 583
思路： 向单链表中插入一个新值，需要插入位置前后的两个节点。             从根节点开始遍历，寻找插入的正确位置。 struct node { int v; struct node *p; }; int fun (struct node **rootp,int val) { struct node *current; struct node *previous; str
单链表的直接插入排序
qq_29567701的博客
05-21 4537
单链表的直接插入排序 1、数组的直接插入排序 void InsertSort(int *a, int len) { for (int i = 1; i &amp;lt; len; ++i) { for (int j = 0; j &amp;lt; i; ++j) { if (a[j]&amp;gt;a[i]) { ...
单链表之按值大小顺序插入整数组（C语言实现）
Oscaner
09-06 2462
来源：我的博客站 OceanicKang |《单链表之尾插法（C语言实现）》 1、初始化准备 #include &amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;amp;amp;gt; // 数组结构体 struct Node { int
单链表的基本操作（读取、插入、删除）及优缺点总结
热门推荐
rujin_shi的博客
03-06 4万+
1.单链表的读取 获取链表第i个数据的算法思路： 1. 声明一个指针p指向链表的第一个结点，初始化j从1开始； 2. 当j&lt; i 时，遍历链表，让p的指针向后移动，不断指向下一结点，j累加1； 3. 若到链表末尾p为空，说明第i个元素不存在； 4. 否则查找成功，返回结点p的数据。 /*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/ /*操作结果： 用e返回...
单链表的插入排序
huhubbdd的博客
06-26 925
链表的插入排序，注意对于单链表的插入和删除，找到待插入或者待删除的结点的前驱是很重要的，注释的很清楚了，参考注释，有错误恳请指正！
单链表之按顺序插入
weixin_43621608的博客
05-27 697
void rankNode(Node* head,int data) { //类似于删除节点的操作，定义两个指针，相互递进 Node* findNode=head->next; Node* frontNode = head; while ( findNode->data < data) //不同在于这里指针递进的判断条件为，当前数据小于插入的数据则指针后移 //如果逆向排序的话，判断条件则会相反，以此类推 { frontNode = findNode;
链表——单向链表的创建与顺序插入
LeeBlog
09-03 2364
【简介】 链表是有序的列表，它在内存中是存储如下： 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 【单项链表】 单链表(带头结点) 逻辑结构示意图如下 【实例演示】 使用带head头的单向链表实现 –水浒英雄...
头插法创建单链表、遍历链表、删除链表
最新发布
06-28
遍历链表是指按照一定顺序依次访问链表中的每个节点。具体步骤如下： 1. 从头节点开始，依次访问每个节点。 2. 对于每个节点，输出其数据域的值。 3. 如果该节点的指针域不为空，将指针域指向的下一个节点作为当前...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值