数据结构4——单链表的增删改查

爱吃葡萄的皮皮
98 阅读4分钟

增加

按加入顺序排

  1. 遍历找到最后一个节点
  2. 最后一个节点指向加入节点
//    按加入顺序排序
    public void add(HeroNode heroNode){
        HeroNode temp = head;
        while(true){
//            找到最后一个节点
            if (temp.next == null){
                break;
            }
            temp = temp.next;
        }
//        最后的节点指向插入元素
        temp.next = heroNode;
    }

按编号no从小到大排

  1. 遍历找到编号比自己大的节点的前一个节点temp
  2. 加入的节点指向temp.next
  3. temp.next指向加入节点
//按编号从小到大排序
    public void addByOrder(HeroNode heroNode){
//        头节点不能动，声明一个新的节点指向头节点
        HeroNode temp = head;
//        标识是否存在相同编号的元素
        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 = temp.next;
        }
        if (flag){
            System.out.println("加入元素编号已经存在");
        }else {
//            插入元素指向插入位置后面的元素
            heroNode.next = temp.next;
//            插入位置前面的元素指向插入元素
            temp.next = heroNode;
        }
    }

删除

删除一个节点

  1. 找到删除节点的前一个节点temp

  2. temp.next = temp.next.next

  3. 被删除的节点无任何指向，被垃圾回收

//    删除节点
    public void delete(int no){
        HeroNode temp = head;
//        标识是否找到待删除节点
        boolean flag = false;
        while(true){
//            遍历到队尾
            if (temp.next == null){
                break;
            }
//            找到删除元素的前一个元素
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
//            删除元素的前一个节点指向删除节点的后一个节点
            temp.next = temp.next.next;
            System.out.println("删除成功");
        }else{
            System.out.println("删除节点不存在");
        }
    }

修改

//    修改
    public void change(int no,String name){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
//            遍历到队尾
            if (temp.next == null){
                break;
            }
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next.name = name;
        }else {
            System.out.println("未找到该编号节点");
        }
    }

查

//    查找
    public HeroNode getByno(int no){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
//            遍历到队尾
            if (temp.next == null){
                break;
            }
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            return temp.next;
        }else {
            System.out.println("未找到该编号节点");
            return null;
        }
    }

全部代码

package 单链表;
/*
    删除一个节点
        1.找到删除节点的前一个节点temp
        2.temp.next = temp.next.next
        3.被删除的节点无任何指向，被垃圾回收
*/
public class 单链表1 {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1,"a","a");
        HeroNode hero2 = new HeroNode(2,"b","b");
        HeroNode hero3 = new HeroNode(3,"c","c");
        SingleList list = new SingleList();
//        按插入顺序
        System.out.println("按插入顺序");
        list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        list.list();
//        按插入元素编号
        SingleList list1 = new SingleList();
        System.out.println("按插入元素编号");
        list1.addByOrder(hero1);
        list1.addByOrder(hero3);
        list1.addByOrder(hero2);
        list1.addByOrder(hero3);
        list1.list();
//        删除
        System.out.println("我要删除编号为2的元素了");
        list1.delete(3);
        list1.list();
        list1.delete(4);
        list1.list();

//        查找
        System.out.println("我查找了编号1的节点");
        System.out.println(list1.getByno(1));
        System.out.println("我查找了编号5的节点");
        System.out.println(list1.getByno(5));
//        修改
        System.out.println("我修改了编号1的节点");
        list1.change(1,"张狗子");
        System.out.println(list1.getByno(1));
    }
}
class SingleList{
    private HeroNode head = new HeroNode(0,"","");
//    按加入顺序排序
    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;
//        标识是否存在相同编号的元素
        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 = temp.next;
        }
        if (flag){
            System.out.println("加入元素编号已经存在");
        }else {
//            插入元素指向插入位置后面的元素
            heroNode.next = temp.next;
//            插入位置前面的元素指向插入元素
            temp.next = heroNode;
        }
    }
//    删除节点
    public void delete(int no){
        HeroNode temp = head;
//        标识是否找到待删除节点
        boolean flag = false;
        while(true){
//            遍历到队尾
            if (temp.next == null){
                break;
            }
//            找到删除元素的前一个元素
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
//            删除元素的前一个节点指向删除节点的后一个节点
            temp.next = temp.next.next;
            System.out.println("删除成功");
        }else{
            System.out.println("删除节点不存在");
        }
    }

//    查找
    public HeroNode getByno(int no){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
//            遍历到队尾
            if (temp.next == null){
                break;
            }
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            return temp.next;
        }else {
            System.out.println("未找到该编号节点");
            return null;
        }
    }

    //    修改
    public void change(int no,String name){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
//            遍历到队尾
            if (temp.next == null){
                break;
            }
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next.name = name;
        }else {
            System.out.println("未找到该编号节点");
        }
    }

    public void list(){
        if (head.next == null) {
            return;
        }
        HeroNode temp = head.next;
        while(true){
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}
class HeroNode{
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;
    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 + ''' +

                '}';
    }
}
avatar
文章
阅读
粉丝