数据结构(三) - 单向有序链表

单向列表在开发中属于常见的一种数据结构.其实他就是把一个元素按照某种排序规则串接在另一个元素后面.如何实现?

第一步 : 创建对象类

package com.xbb.demo.linked;

public class HeroNode {

    /**
     * 编号
     */
    private int id;
    /**
     * 英雄名称
     */
    private String name;
    /**
     * 下一个英雄串接位置
     */
    private HeroNode next;
    /**
     * 构造方法
     * @param id
     * @param name
     */
    public HeroNode(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public HeroNode getNext() {
        return next;
    }
    public void setNext(HeroNode next) {
        this.next = next;
    }
    @Override
    public String toString() {
        return "id = " + id + ", name = " + name;
    }
}

第二步 : 列表功能实现 :

package com.xbb.demo.linked;

/**
 * 有序单向链表实现
 */
public class SingleLinkedListOrderDemo {

    /**
     * 第一步
     *  初始化一个头节点.不放具体数据
     */
    private HeroNode firstHear = new HeroNode(0,null);

    /**
     * 第一种方法
     *  添加原理
     *  不直接添加.而是查找适合的位置.并且标记出适合新元素位置前后两个元素
     */
    public void add(HeroNode heroNode){
        try{
            // 始终保留第一个元素.
            HeroNode first = firstHear;
            // 循环获取当前对象与要插入的对象进行比较
            HeroNode temp = firstHear;
            // 新元素所在位置前后的两个元素
            HeroNode before = null;
            HeroNode after = null;
            while(true){
                // 如果到了链表的最后一个元素.退出循环
                if (temp.getNext() == null){
                    break;
                }else{
                    // 获取下一个元素.
                    temp = temp.getNext();
                    // 如果新元素的ID大于当前循环到的元素ID,则说明新元素应该排在当前元素的后面.标记当前循环元素为before
                    if (heroNode.getId() > temp.getId()){
                        before = temp;
                    // 如果新元素的ID小于当前循环到的元素ID,则说明新元素应该在当前循环元素的前面.标记当前循环元素为after
                    }else if (heroNode.getId() < temp.getId()){
                        // 如果当前循环元素的ID大于标记为后面的元素,则说明原排序正常.不需要更换
                        if (after != null && temp.getId() > after.getId() ){
                            continue;
                        }
                        after = temp;
                    }else{
                        // 如果新元素与链表中已经存在的元素相同时.报错
                        throw new Exception("元素相同");
                    }
                }
            }
            // 当没有找到适合当前元素前面和后面的元素时.说明当前要加入的元素为第一个元素.
            // 该判断只会在第一个元素进入的时候成立
            if (before == null && after == null){
                temp.setNext(heroNode);
            // 当新元素适合位置前面为空时.说明该元素应该在第一个.所以把新元素接在第一位.后面的跟在新元素后面
            }else if (before == null && after != null){
                first.setNext(heroNode);
                heroNode.setNext(after);
            // 当新元素适合位置的前面有值.后面没值时.说明该位置为最后一个位置.直接跟在before后面就可以.
            }else if (before != null && after == null){
                before.setNext(heroNode);
            // 当新元素适合位置前后都不为空时,进行位置替换
            }else if (before != null && after != null){
                before.setNext(heroNode);
                heroNode.setNext(after);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 第二种方法
     * 通过判断当前循环元素的下一个元素进行
     * @param heroNode
     */
    public void add2(HeroNode heroNode){
        HeroNode temp = firstHear;
        while(true){
            if (temp.getNext() == null){
                break;
            }else {
                if (temp.getNext().getId() > heroNode.getId()){
                    break;
                }
            }
            temp = temp.getNext();
        }
        heroNode.setNext(temp.getNext());
        temp.setNext(heroNode);
    }

    /**
     * 删除某个元素
     * @param heroNode
     */
    public void delete(HeroNode heroNode){
        HeroNode temp = firstHear;
        HeroNode before = null;
        while (true){
            if (temp.getNext() == null){
                break;
            }else{
                before = temp;
                temp = temp.getNext();
                if (temp.getId() == heroNode.getId()){
                    break;
                }
            }
        }
        before.setNext(temp.getNext());
    }
    /**
     * 输出 :
     */
    public void list(){
        HeroNode temp = firstHear;
        while (temp.getNext() != null){
            temp = temp.getNext();
            System.out.println(temp.toString());
        }
    }
}

测试 :

/**
     * 有序测试
     */
    @org.junit.Test
    public void teseOrder() {
        SingleLinkedListOrderDemo singleLinkedListDemo = new SingleLinkedListOrderDemo();
        HeroNode no1 = new HeroNode(7,"张雪峰");
        HeroNode no2 = new HeroNode(5,"李瑞鹏");
        HeroNode no3 = new HeroNode(3,"惠茂阳3");
        HeroNode no4 = new HeroNode(9,"惠茂阳9");
        HeroNode no5 = new HeroNode(8,"惠茂阳8");
        HeroNode no6 = new HeroNode(1,"惠茂阳1");
        HeroNode no7 = new HeroNode(4,"惠茂阳4");
        singleLinkedListDemo.add(no1);
        singleLinkedListDemo.add(no2);
        singleLinkedListDemo.add(no3);
        singleLinkedListDemo.add(no4);
        singleLinkedListDemo.add(no5);
        singleLinkedListDemo.add(no6);
        singleLinkedListDemo.add(no7);
        singleLinkedListDemo.list();
    }

更多数据结构与算法知识