java数据结构实验1

 实验1线性表的基本操作

1.1顺序表

在顺序表类SeqList中增加以下成员方法:

· public void removeAll(Tkey)//删除所有关键字为key的数据元素，要求所有

元素一次移动到位

public void replaceFirst(TkeyTx)//将第一个关键字为key的元素替换为X public int searchLast(Tkey)/查找最后一个关键字为key的元素，返回其索引号

代码：

以下是修改后的SeqList类的实现：

public class SeqList {

    private Object[] element;

    private int size;

    private final int capacity;



    public SeqList(int capacity) {

        this.capacity = capacity;

        element = new Object[capacity];

        size = 0;

    }



    // 在顺序表的末尾添加元素

    public boolean add(T data) {

        if (size < capacity) {

            element[size++] = data;

            return true;

        }

        return false;

    }



    // 删除所有关键字为key的元素

    public void removeAll(T key) {

        int k = 0;

        for (int i = 0; i < size; i++) {

            if (!element[i].equals(key)) {

                element[k++] = element[i];

            }

        }

        size = k;

    }



    // 将第一个关键字为key的元素替换为X

    public void replaceFirst(T key, T x) {

        for (int i = 0; i < size; i++) {

            if (element[i].equals(key)) {

                element[i] = x;

                return;

            }

        }

    }



    // 查找最后一个关键字为key的元素

    public int searchLast(T key) {

        for (int i = size - 1; i >= 0; i--) {

            if (element[i].equals(key)) {

                return i;

            }

        }

        return -1;

    }



    // 打印顺序表元素

    public void print() {

        for (int i = 0; i < size; i++) {

            System.out.print(element[i] + " ");

        }

        System.out.println();

    }

}

测试代码：

public class Test {

    public static void main(String[] args) {

        SeqList list = new SeqList<>(10);



        list.add(1);

        list.add(2);

        list.add(3);

        list.add(2);

        list.add(4);

        list.add(5);

        list.add(2);

        list.add(6);

        list.add(2);

        list.add(7);



        list.print(); // 1 2 3 2 4 5 2 6 2 7



        list.removeAll(2);

        list.print(); // 1 3 4 5 6 7



        list.replaceFirst(4, 8);

        list.print(); // 1 3 8 5 6 7



        System.out.println(list.searchLast(3)); // 1

        System.out.println(list.searchLast(9)); // -1

    }

}

运行结果：

1.2单链表

在单链表SinglyList中增加以下成员方法:

·public Nodelast()//返回最后一个结点

·public Node prev(Nodep)//返回p结点的前驱结点

·public SinglyListsubList(intiintlen)//返回从第i个结点开始，长度为len的子表，深拷贝

答案：

代码：

public class SinglyList {

    // 单链表的节点类

    private static class Node {

        T data;

        Node next;



        Node(T data, Node next) {

            this.data = data;

            this.next = next;

        }

    }



    private Node head; // 头结点

    private int size; // 链表的长度



    // 构造方法，创建一个空链表

    public SinglyList() {

        head = null;

        size = 0;

    }



    // 在链表末尾添加一个元素

    public void add(T elem) {

        if (head == null) {

            head = new Node(elem, null);

        } else {

            Node p = head;

            while (p.next != null) {

                p = p.next;

            }

            p.next = new Node(elem, null);

        }

        size++;

    }



    // 删除链表中的第一个与elem相等的元素

    public boolean remove(T elem) {

        if (head == null) {

            return false;

        }

        if (head.data.equals(elem)) {

            head = head.next;

            size--;

            return true;

        }

        Node p = head;

        while (p.next != null && !p.next.data.equals(elem)) {

            p = p.next;

        }

        if (p.next != null) {

            p.next = p.next.next;

            size--;

            return true;

        }

        return false;

    }



    // 返回链表的长度

    public int size() {

        return size;

    }



    // 返回最后一个结点

    public Node last() {

        if (head == null) {

            return null;

        }

        Node p = head;

        while (p.next != null) {

            p = p.next;

        }

        return p;

    }



    // 返回p结点的前驱结点

    public Node prev(Node p) {

        if (head == null || p == head) {

            return null;

        }

        Node q = head;

        while (q != null && q.next != p) {

            q = q.next;

        }

        return q;

    }



    // 返回从第i个结点开始，长度为len的子表，深拷贝

    public SinglyList subList(int i, int len) {

        if (i < 0 || i > size || len <= 0 || i + len > size) {

            throw new IndexOutOfBoundsException();

        }

        SinglyList sublist = new SinglyList();

        Node p = head;

        for (int j = 0; j < i; j++) {

            p = p.next;

        }

        for (int j = 0; j < len; j++) {

            sublist.add(p.data);

            p = p.next;

        }

        return sublist;

    }



    // 测试输出

    public static void main(String[] args) {

        SinglyList list = new SinglyList();

        list.add(1);

        list.add(2);

        list.add(3);

        list.add(4);

        list.add(5);



        System.out.println("size: " + list.size());



        Node last = list.last();

        System.out.println("last element: " + last.data);

    }

}

运行结果：