面向对象封装之超级链表（单向链表）

package com.javasc.review;

public class InitSuperList { //超级链表其实就是对常见的已有的数组结构进一步的编程，把常见的业务中需要的功能封装起来，此时就形成超级数组这个类，我们使用这个封装好的类去创建对象，那么这些对象就拥有这种属性。

//由于链表的存储结构是非连续的，那么链表的小的单元节点内，我们需要一部分的空间用来存储数据，另一部分用来保存指向下个节点的位置。

//由于链表的结构特新，我们需要维护一个头节点，依靠这个头节点去查找，操作其他位置的节点。 private InitNode head; //维护超级链表的长度 private int length;

//向超级链表的表头位置插入一个元素（头插元素）
public void addToHeader(int data){
    //如果head节点为空，表示此时链表中没有一个元素，这时只用将head节点修改即可；
    if (length == 0){
        head = new InitNode(data,null);
        length++;

    } else {
        InitNode newNode = new InitNode(data,head);
        head = newNode;
        length++;
        //这两句话可以合并为：head = new InitNode(data,head)，简化代码书写方式；
    }
}
//在下标为index的下一个位置插入一个元素data；
public void addToIndexNext(int index, int data){
    if (length == 0){
        this.addToHeader(data);
    } else {
        InitNode temp = head;
        InitNode newNode = new InitNode(data,null);
        for (int i = 0; i < index; i++) {
            temp = temp.getNodeNext();
        }
        //接下来的两行的顺序不能产生错误，否则，链表会断开；
        newNode.setNodeNext(temp.getNodeNext());
        temp.setNodeNext(newNode);
        length++;

    }
}
//在下标为index的前一个元素位置插入一个元素data;
public void addToIndexFront(int index, int data){
    if (length == 0){
        this.addToHeader(data);
    } else if (index == 0){
        this.addToHeader(data);//由于index==0时，这时addToIndexNext()方法中会产生负数，这时不会移动，所以需要考虑边界问题；
    } else {
        this.addToIndexNext(index - 1,data);//合理利用已有的方法，在下标之前插入元素，等于在先寻找到下标的前一个元素，并使用此番方法；
    }
}

//在链表的表尾处插入一个元素
public void addToRear(int data){
    if (length == 0){
        this.addToHeader(data);
    } else {
        InitNode temp = head;
        InitNode newNode = new InitNode(data,null);
        for (int i = 0; i < length - 1; i++) {
            temp = temp.getNodeNext();
        }
        temp.setNodeNext(newNode);
        length++;
    }
}
//链表的元素从大到小排序，或者链表的元素从小到大排序，
public void sort(int flag){
    //可以选则排序的方式，flag为标志位，为0则为从小到大排序，为1则为从大到小排序
    if (flag == 0){
        InitNode temp = head;
        int num = 0;
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - i - 1; j++) {
                if (temp.getData() > temp.getNodeNext().getData()){
                    num = temp.getData();
                    temp.setData(temp.getNodeNext().getData());
                    temp.getNodeNext().setData(num);
                }
                temp = temp.getNodeNext();
            }
            temp = head;
        }
    } else if (flag == 1){
        InitNode temp = head;
        int num = 0;
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - i - 1; j++) {
                if (temp.getData() < temp.getNodeNext().getData()){
                    num = temp.getData();
                    temp.setData(temp.getNodeNext().getData());
                    temp.getNodeNext().setData(num);
                }
                //(重点！)在内循环中，不能让其一直的下后移动，会产生空指针异常的问题，这时候，当我们一轮比较完成之后，应当让temp重新指向head;
                temp = temp.getNodeNext();
            }
            temp = head;
        }
    } else {
        System.out.println("输入无效");
    }
}
//删除链表指定位置的元素，或者数据
public void delInex(int index){
    if(length == 0){
        System.out.println("链表中已没有元素可以删除！");
    } else if (index == 0){
        head = head.getNodeNext();
        length--;
    } else{
        InitNode temp = head;
        for (int i = 0; i < index - 1; i++) {
            temp = temp.getNodeNext();
        }
        temp.setNodeNext(temp.getNodeNext().getNodeNext());
        length--;
    }
}

//查找指定位置的元素是多少,传入查找位置的下标
public Integer select(int index){
    if(index >= 0 && index < length){
        InitNode temp = head;
        for (int i = 0; i < index ; i++) {
            temp = temp.getNodeNext();

        }
        return temp.getData();
    }
    return null;
}

public static void main(String[] args) {
    InitSuperList initSuperList = new InitSuperList();
    initSuperList.addToHeader(12);
    initSuperList.addToHeader(13);
    initSuperList.addToIndexNext(1,14);
    initSuperList.addToRear(11);
    initSuperList.addToIndexFront(0,15);
    initSuperList.delInex(4);
    initSuperList.sort(0);
    for (int i = 0; i < initSuperList.length; i++) {
        Integer value = initSuperList.select(i);
        System.out.println(value);
    }
}

}