双链表实现增插删改查 *** 作_随笔

双链表实现增插删改查 *** 作双链表实现增插删改查 *** 作增加元素 *** 作思路

遍历寻找到尾节点（节点next为null），将尾节点next指向参数节点就ok

具体方法

先遍历找到链表的最后节点
new一个新节点（这里因为将新节点作为参数，故无需new）
将上一个节点的next变量指向新节点
将新节点的last变量指向上一个节点

public void append(HeroNode_2 heroNode) {

    //因为头结点不能动，所以需要一个辅助遍历变量temp
    HeroNode_2 temp = head;

    //遍历链表，找到最后一个节点，该节点next变量为null

    //简洁版
    //        while (temp.next != null) {
    //            //让temp指向下一个节点，检测下一个个节点next是不是null
    //            temp = temp.next;
    //        }

    //上一个循环为简洁遍历，看不懂可以参考下面的遍历方法
    while (true) {
        //找到那个节点next变量为null则跳出循环，找不到则继续遍历，将temp指向下一个节点
        if (temp.next == null) {
            break;
        } else {
            temp = temp.next;
        }
    }

    //当退出循环时，temp就指向了最后一个节点
    //将该节点的next指向要添加的那个节点
    temp.next = heroNode;
    heroNode.last = temp;
}

插入元素 *** 作

思路：

1.定位

遍历链表
定位到索引节点的前一个节点

2.修改指针域

将它的next指向新节点
把新节点的last指向该节点
next指向原来前一个节点next指向的节点
将下一个节点的last指向新节点

//插入 *** 作
    public void insert(int index, HeroNode_2 heroNode_2) {
        //定位部分

        //定义一个索引变量与插入索引比较
        int count = 0;
        //定义遍历指针
        HeroNode_2 temp = head;
        while (count != index) {//因为是定位到前一个节点，故减一
            //指针遍历所以节点
            temp = temp.next;
            //当节点next为空但循环还没有结束时，说明索引超出了链表范围，直接结束程序
            if (temp.next == null) {
                System.out.println("插入失败，索引超过定义链表范围！！！");
                return;
            }
            count++;
        }

        //修改指针域，插入新节点

        //缓存定位节点next，因为后面还有将其赋值给新节点next
        HeroNode_2 Next_old = temp.next;
        //将定位节点next指向新节点
        temp.next = heroNode_2;
        //修改新节点的指针
        heroNode_2.next = Next_old;//指向后一个节点
        heroNode_2.last = temp;//指向前一个节点
        //修改后一个节点的last,指向新节点
        temp.next.last = heroNode_2;

        System.out.println("插入成功");
    }

删除元素 *** 作

思路

定位：定位到索引节点的前一个节点
修改指针：
- 将下下个节点的last指向上上个节点，跳过删除节点
- 将索引节点的next指向下下个节点，跳过删除节点

//删除 *** 作
public void delete(int index) {//删除节点的索引
    

    //定位

    //定义一个索引变量与插入索引比较
    int count = 0;
    //定义遍历指针
    HeroNode_2 temp = head;
    while (true) {
        if (count == index) {
            break;
        }
        //当下一个节点next为空但循环还没有结束时，说明索引超出了链表范围，直接结束程序
        if (temp.next.next == null) {
            System.out.println("删除失败，索引超过定义链表范围！！！");
            return;
        }
        //指针遍历所以节点
        temp = temp.next;

        count++;
    }
    //        System.out.println("删除定位节点为 "+temp);
    //修改指针

    //判断删除节点是否是尾节点,是尾节点直接把定位节点next改为null
    if (temp.next.next != null) {
        //将下下个节点的last指向上上个节点，跳过删除节点
        temp.next.next.last = temp;
        //将索引节点的next指向下下个节点，跳过删除节点
        temp.next = temp.next.next;

    } else {
        temp.next = null;
    }
    System.out.println("删除成功");
}

修改元素 *** 作

思路：

定位：遍历找到索引节点位置
修改：修改索引节点数据

//修改 *** 作
public void updata(int index, int id, String name) {
    

    //定位

    //判断变量
    int count = 0;
    //指针指向头节点
    HeroNode_2 temp = head;
    //遍历
    while (count != index) {
        if (temp.next == null) {
            System.out.println("修改失败，索引超过定义链表范围！！！");
        }
        temp = temp.next;
        count++;
    }

    //修改
    temp.id = id;
    temp.name = name;

    System.out.println("修改成功");
}

查看双链表 *** 作

思路：定义节点伪指针，遍历双链表，将team指向的节点数据输出

//显示链表[遍历]
public void list(){
    //先判断链表是否为空，为空直接不用遍历
    if(head.next==null){
        System.out.println("链表为空");
        return;
    }
    //头结点不能动，需要一个辅助变量遍历
    HeroNode temp = head;
    //简洁版
    while (temp.next != null) {
        //让temp指向下一个节点，检测下一个个节点next是不是null
        //这里主要要先改遍历节点在输出，否则会出现输出头结点，不输出尾节点的现象
        temp = temp.next;
        System.out.println(temp);
    }
}

完整代码展示

package 数据结构.链表;



//小知识：类名 变量 = 类；这种不用new的实例化，变量可以作为指针使用（内存地址相同），当变量对象属性改变时，它指向的那个对象属性跟着改变

//编写节点
class HeroNode_2 {
    public int id;//英雄编号
    public String name;//英雄姓名

    public HeroNode_2 last;//指向上一个节点（是个对象）

    public HeroNode_2 next;//指向下一个节点（是个对象）

    //构造器
    public HeroNode_2(int hid, String hname) {
        this.id = hid;
        this.name = hname;
        this.last = null;//这句可以不用写，没有赋值时last本身就是null
        this.next = null;//这句可以不用写，没有赋值时next本身就是null
    }

    //显示方法
    @Override
    public String toString() {
        return "HeroNode_2 英雄编号: " + id + " 英雄姓名: " + name;
    }
}

//创建双链表,管理英雄
class Hero2link {
    //先初始化一个头结点，头结点不能动,且不存放具体数据，因为只能存在一个，故设置其为私有对象
    private HeroNode_2 head = new HeroNode_2(0, "");

    
    public void append(HeroNode_2 heroNode) {

        //因为头结点不能动，所以需要一个辅助遍历变量temp
        HeroNode_2 temp = head;

        //遍历链表，找到最后一个节点，该节点next变量为null

        //简洁版
//        while (temp.next != null) {
//            //让temp指向下一个节点，检测下一个个节点next是不是null
//            temp = temp.next;
//        }

        //上一个循环为简洁遍历，看不懂可以参考下面的遍历方法
        while (true) {
            //找到那个节点next变量为null则跳出循环，找不到则继续遍历，将temp指向下一个节点
            if (temp.next == null) {
                break;
            } else {
                temp = temp.next;
            }
        }

        //当退出循环时，temp就指向了最后一个节点
        //将该节点的next指向要添加的那个节点
        temp.next = heroNode;
        heroNode.last = temp;
    }

    //显示链表[遍历]
    public void list() {
        //先判断链表是否为空，为空直接不用遍历
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //头结点不能动，需要一个辅助变量遍历
        HeroNode_2 temp = head;
        //简洁版
        while (temp.next != null) {
            //让temp指向下一个节点，检测下一个个节点next是不是null
            //这里主要要先改遍历节点在输出，否则会出现输出头结点，不输出尾节点的现象
            temp = temp.next;
            System.out.println(temp);
        }
    }

    //插入 *** 作
    public void insert(int index,HeroNode_2 heroNode_2){
        

        //定位部分

        //定义一个索引变量与插入索引比较
        int count=0;
        //定义遍历指针
        HeroNode_2 temp = head;
        while (count!=index){//因为是定位到前一个节点，故减一
            //指针遍历所以节点
            temp = temp.next;
            //当节点next为空但循环还没有结束时，说明索引超出了链表范围，直接结束程序
            if (temp.next==null){
                System.out.println("插入失败，索引超过定义链表范围！！！");
                return;
            }
            count++;
        }

        //修改指针域，插入新节点

        //缓存定位节点next，因为后面还有将其赋值给新节点next
        HeroNode_2 Next_old = temp.next;
        //将定位节点next指向新节点
        temp.next=heroNode_2;
        //修改新节点的指针
        heroNode_2.next = Next_old;//指向后一个节点
        heroNode_2.last = temp;//指向前一个节点
        //修改后一个节点的last,指向新节点
        temp.next.last = heroNode_2;

        System.out.println("插入成功");
    }

    //删除 *** 作
    public void delete(int index){//删除节点的索引
        

        //定位

        //定义一个索引变量与插入索引比较
        int count=0;
        //定义遍历指针
        HeroNode_2 temp = head;
        while (true){
            if (count==index){
                break;
            }
            //当下一个节点next为空但循环还没有结束时，说明索引超出了链表范围，直接结束程序
            if (temp.next.next==null){
                System.out.println("删除失败，索引超过定义链表范围！！！");
                return;
            }
            //指针遍历所以节点
            temp = temp.next;

            count++;
        }
//        System.out.println("删除定位节点为 "+temp);
        //修改指针

        //判断删除节点是否是尾节点,是尾节点直接把定位节点next改为null
        if (temp.next.next!=null){
            //将下下个节点的last指向上上个节点，跳过删除节点
            temp.next.next.last=temp;
            //将索引节点的next指向下下个节点，跳过删除节点
            temp.next = temp.next.next;

        }else {
            temp.next = null;
        }
        System.out.println("删除成功");
    }

    //修改 *** 作
    public void updata(int index,int id,String name){
        

        //定位

        //判断变量
        int count = 0;
        //指针指向头节点
        HeroNode_2 temp = head;
        //遍历
        while (count!=index){
            if (temp.next==null){
                System.out.println("修改失败，索引超过定义链表范围！！！");
            }
            temp = temp.next;
            count++;
        }

        //修改
        temp.id = id;
        temp.name = name;

        System.out.println("修改成功");
    }

}

public class 双链表实现 {
    public static void main(String[] args) {
        //测试
        //先创建节点
        HeroNode_2 hero1 = new HeroNode_2(1,"宋江");
        HeroNode_2 hero2 = new HeroNode_2(2,"吴用");
        HeroNode_2 hero3 = new HeroNode_2(3,"林冲");
        HeroNode_2 hero4 = new HeroNode_2(4,"武松");

        //创建双链表
        Hero2link hero2link = new Hero2link();

        //添加节点
        hero2link.append(hero1);
        hero2link.append(hero2);
        hero2link.append(hero3);
        hero2link.append(hero4);

        //显示链表信息
        hero2link.list();

        //插入节点
        HeroNode_2 New_hero = new HeroNode_2(3,"张三");
        hero2link.insert(2, New_hero);

        //显示链表信息
        hero2link.list();

        //删除第4个节点
        hero2link.delete(3);//索引从零开始,所以索引为3是第4个节点

        //显示链表信息
        hero2link.list();
    }
}

上一篇：Java版双链表节点如何构造

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5523584.html

双链表实现增插删改查 *** 作

发表评论

评论列表（0条）