作业1 OO基础1-2、设计一个带表头的双向链表，要求链表中可以存放任意类型的数据）

作业1 OO基础1-2、设计一个带表头的双向链表，要求链表中可以存放任意类型的数据）

提供以下方法：
（1）insert：在某个位置插入对象；
（2）insert：在链表的最后插入对象；
（2）delete：在某个位置删除对象；
（3）delete：删除链表中与x相同的元素；
（4）size：返回当前链表中对象的个数；
（5）isEmpty：判断链表是否为空；
（6）traverse：遍历链表，打印出所有的元素；
（7）getData：取得某个位置的对象。构造main函数进行测试。（40.0分）

代码

LinkList.java

import java.util.Scanner;

public class LinkList {
    static class Node {
        Object data;
        Node next;
        Node front;

        public Node() {
            data = 0;
            next = null;
            front = null;
        }

        public Node(int data, Node pre, Node next) {
            this.data = data;
            this.front = pre;
            this.next = next;
        }

        public Object getData() {
            return data;
        }

        public void setData(int data) {
            this.data = data;
        }
    }

    public int size;
    public Node head;
    public Node rear;

    public LinkList() {
        this.size = 0;
        head = new Node();
        rear = new Node(0, head, null);
        head.next = rear;
    }

    //insert：在某个位置插入对象
    public void insert(int pos, int data) {
        Node t = new Node(data, null, null);
        Node f = head;
        for (int i = 0; i < pos; i++) {
            f = f.next;
        }
        t.next = f;
        t.front = f.front;
        f.front.next = t;
        f.front = t;
        size++;
    }

    //insert：在链表的最后插入对象；
    public void insert(int data) {
        Node t = new Node(data, null, null);
        rear.front.next = t;
        t.front = rear.front;
        t.next = rear;
        rear.front = t;
        size++;
    }

    //delete：在某个位置删除对象
    public void delete(int pos, LinkList l) {
        Node f = head;
        for (int i = 0; i < pos; i++) {
            f = f.next;
        }
        f.front.next = f.next;
        f.next.front = f.front;
    }

    //delete：删除链表中与x相同的元素
    public void delete(int x) {
        Node f = head.next;
        while (f.next != null) {
            if (f.data.equals(x)) {
                f.front.next = f.next;
                f.next.front = f.front;
            }
            f = f.next;
        }
    }

    //size：返回当前链表中对象的个数
    public int size() {
        return size;
    }

    //isEmpty：判断链表是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    //traverse：遍历链表，打印出所有的元素
    public void traverse() {
        Node f = head.next;
        while (f.next != null) {
            System.out.print(f.data + " ");
            f = f.next;
        }
        System.out.println();
    }

    //getData：取得某个位置的对象
    public Object getData(int pos) {
        Node f = head;
        for (int i = 0; i < pos; i++) {
            f = f.next;
        }
        return f.data;
    }

    public static void main(String[] args) {
        LinkList ls = new LinkList();
        Scanner scanner = new Scanner(System.in);
        System.out.print("请依次输出数据（输入0时停止）：");
        while (true) {
            int s = scanner.nextInt();
            if (s == 0) {
                break;
            } else {
                ls.insert(s);
            }
        }
        System.out.println("链表大小：" + ls.size());//输出链表大小

        System.out.println("链表是否为空：" + ls.isEmpty());//判断链表是否为空

        System.out.print("链表中的所有元素：");
        ls.traverse();//打印出所有元素

        System.out.print("在链表最后插入11：");
        ls.insert(11);//在最后插入11
        ls.traverse();

        System.out.print("在位置2上插入44：");
        ls.insert(2, 44);//在位置2上插入44
        ls.traverse();

        System.out.print("删除位置4上的数：");
        ls.delete(4, ls);//删除位置4上的数
        ls.traverse();

        System.out.print("删除链表中所有的2：");
        ls.delete(2);//删除链表中所有的2
        ls.traverse();
        System.out.println("获得位置2上的数：" + ls.getData(2));//获得位置2上的数


    }
}