数据结构 实验一（顺序表、单链表）

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

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

元素一次移动到位

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

package com.demo;
public class SeqList <T> extends Object{
 
    private Object[] element;
    private int size;
    private static final int capacity=10;
    public SeqList (int length) {
        if(length<capacity)
        	length=capacity;
        this.element = new Object[length];
        this.size = 0;
    }
    public SeqList() {
    	this(capacity);
    }
    // 在顺序表的末尾添加元素
    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();
    }
 
}

测试代码

package com.demo;

	public class SeqListText {
	    public static void main(String[] args) {
	    	SeqList<Integer> list = new SeqList<>(10);
	        list.add(4);
	        
	        list.add(2);
	        
	        list.add(9);
	        
	        list.add(1);
	        
	        list.add(7);
	 
	        list.add(5);
	 
	        list.add(2);
	 
	        list.add(6);
	 
	        list.add(2);
	 
	        list.add(8);
	 
	        list.print(); //输出刚才添加的数据 
	 
	        list.removeAll(2);
	 
	        list.print(); // 除去2后的数据
	 
	        list.replaceFirst(7, 6);
	 
	        list.print(); //把7替换成6之后的数据 
	 
	        System.out.println(list.searchLast(4)); // 输出关键字为4的索引号 
	 
	        System.out.println(list.searchLast(8)); // 输出关键字为8的索引号
	 
	    }
	 
	}

 运行结果

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

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

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

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

package com.demo;  
  
// 定义单链表类  
public class SinglyList<T> extends Object{  
    public Node<T> head; 
    int size = 0;  
  
    // 定义单链表节点类  
    public static class Node<T> {  
       public T data;  
       public Node<T> next;  
  
        Node(T data, Node<T> next) {  
            this.data = data;  
            this.next = next;  
        }

		public Node() {
			this(null,null);
		}
    }  
  
    // 构造方法，创建一个空链表  
    public SinglyList() {  
    	this.head=new Node<T>();
    }  
  
    // 在链表末尾添加一个元素  
    public void add(T element) {  
        if (head == null) {  
            head = new Node<T>(element, null);  
        } else {  
            Node<T> p = head;  
            while (p.next != null) {  
                p = p.next;  
            }  
            p.next = new Node<T>(element, null);  
        }  
        size++;  
    }  
  
    // 返回链表的长度  
    public int size() {  
        return size;  
    }  
  
    // 返回最后一个结点  
    public Node<T> last() {  
        if (head == null) {  
            return null;  
        }  
        Node<T> p = head;  
        while (p.next != null) {  
            p = p.next;  
        }  
        return p;  
    }  
  
    // 返回 p 结点的前驱结点  
    public Node<T> prev(Node<T> p) {  
        if (head == null || p == null) {  
            return null; // 如果链表为空或节点为空，返回 null  
        }  
        if (p == head) {  
            return null; // 如果 p 是头节点，它没有前一个节点  
        }  
        Node<T> current = head;  
        while (current.next != null && current.next != p) {  
            current = current.next;  
        }  
        // 当循环结束时，current 指向 p 的前一个节点，或者current 是链表的最后一个节点且 p 不在链表中  
        return (current.next == p) ? current : null;  
    }  
  
    // 返回从第 i 个结点开始，长度为 len 的子表，深拷贝  
    public SinglyList<T> subList(int i, int len) {  
        if (i < 0 || i > size || len <= 0 || i + len > size) {  
            throw new IndexOutOfBoundsException();  
        }  
        SinglyList<T> sublist = new SinglyList<T>();  
        Node<T> 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;  
    }  
} 

 测试代码

package com.demo;

import com.demo.SinglyList.Node;

public class SinglyListTest {  
    public static void main(String[] args) {  
        SinglyList<Integer> list = new SinglyList<Integer>();  
        list.add(1);  
        list.add(2);  
        list.add(3);  
        list.add(4);  
        list.add(5);  
  
        System.out.println("Size: " + list.size());  

        Node<Integer> last = list.last();
 
        System.out.println("last element: " + last.data);
    }
}

 运行结果