线性表的链式实现

用链式实现的线性表，公共接口ADT跟上一篇一样

1，有序链表

成员变量和构造函数：

private LinearNode front;
private int count;
    

public LinkedOrderedList()
{
    front = null;
    count = 0;

实现清单（将ADT和有序链表扩展的独有操作分别作了注释）：

package List;

import Bag.LinearNode;

public class LinkedOrderedList implements ListADT {

    private LinearNode front;
    private int count;
    
    
    public LinkedOrderedList()
    {
        front = null;
        count = 0;
    }
    
    
    
    //三种链表的接口公共操作（实现是一样的）
    
    public int size() {
        return count;
    }
    
    public boolean isEmpty() {
        return (count == 0);
    }

    
    public Object first() {
        if(size() == 0){
            System.out.println("链表为空，没有元素");
            return null;
        }
        return front.getElement();
    }

    public Object last() {
        if(size() == 0){
            System.out.println("链表为空，没有元素");
            return null;
        }
        LinearNode last = front;//遍历链表求last的代码
        for(int i = 0;i < count-1;i++)
             last = last.getNext();
        return last.getElement();        
    }


    public Object removeFirst() {
        if(size() == 0){
            System.out.println("链表为空，没有元素");
            return null;
        }
        Object result = front.getElement();
        front = front.getNext();
        count--;
        return result;
    }

    public Object removeLast() {
        if(size() == 0){
            System.out.println("链表为空，没有元素");
            return null;
        }
        LinearNode last = front;
        for(int i = 0;i < count-1;i++)
             last = last.getNext();
        count--;//count-1自动删除最后一个结点
        return last.getElement();
    }
    
    public Object remove(Object element) {
        Object result = null;
        if(size() == 0){//如果为空
            System.out.println("链表为空，没有元素");
            return null;
        }
        else if(front.getElement().equals(element)){//如果是链表的第一个元素
            result = front.getElement();
            front = front.getNext();
            count--;
        }
        else{
            LinearNode pre,current;
            pre = front;
            for(int i = 0;i < count-1;i++)
            {
                current = pre.getNext();
                if(current.getElement().equals(element))
                {
                    result = current.getElement();
                    pre.setNext(current.getNext());//如果current到了最后一个元素，getNext就是null
                    count--;
                    return result;
                }
                pre = pre.getNext();
            }
        }    
            return result;
    }

    
    public boolean contains(Object element) {
        LinearNode temp = front;
        for(int i = 0;i < count;i++){
            if(temp.getElement().equals(element))
                return true;
            temp = temp.getNext(); 
        }
        return false;
    }

    
    
    
    //有序链表扩展的操作
    
    public void add(Comparable element){
        
        LinearNode node = new LinearNode(element); 
        
        LinearNode last = front;
        for(int i = 1;i < count;i++)
            last = last.getNext();
        
        if(size() == 0){//链为空
            front = node;
            count++;
            return;
        }
        else if(element.compareTo(front.getElement()) < 0){//插入在链首
            node.setNext(front);
            front = node;
            count++;
            return;
        }
        else if(element.compareTo(last.getElement()) > 0){//插入在链尾
            last.setNext(node);
            count++;
        }
        else{//插入在链中间
            LinearNode current = front;
            LinearNode next = current.getNext();
            
            for(int i = 0;i < count-1;i++){
                
                if(element.compareTo(next.getElement()) < 0){
                    current.setNext(node);
                    node.setNext(next);
                    count++;
                    return;
                }
                current = next;
                next = next.getNext();            
            }        
        }        
    }
    
    
    
    
    
    public static void main(String[] args) {
        
        LinkedOrderedList list = new LinkedOrderedList();
        
        System.out.println("将0到24打乱顺序加入表，因为是有序表，它将自动排好序");
        for(int i = 20;i < 25;i++)
            list.add(i);
        for(int i = 0;i < 10;i++)
            list.add(i);
        for(int i = 10;i < 20;i++)
            list.add(i);
        
        System.out.println("表的大小为： " + list.size());
        System.out.println("表为空吗？： " + list.isEmpty());
        System.out.println("表的第一个元素为： " + list.first());
        System.out.println("表的最后一个元素为： " + list.last());
        
        System.out.println("\n删除第一个元素");
        list.removeFirst();
        System.out.println("表的大小为： " + list.size());
        System.out.println("表为空吗？： " + list.isEmpty());
        System.out.println("表的第一个元素为： " + list.first());
        System.out.println("表的最后一个元素为： " + list.last());
        
        System.out.println("\n再接着删除最后一个元素");
        list.removeLast();
        System.out.println("表的大小为： " + list.size());
        System.out.println("表为空吗？： " + list.isEmpty());
        System.out.println("表的第一个元素为： " + list.first());
        System.out.println("表的最后一个元素为： " + list.last());
        
        System.out.println("\n再接着删除指定元素20,15,10,5");
        list.remove(20);
        list.remove(10);
        list.remove(15);
        list.remove(5);
        list.remove(23);
        System.out.println("表的大小为： " + list.size());
        System.out.println("表为空吗？： " + list.isEmpty());
        System.out.println("表的第一个元素为： " + list.first());
        System.out.println("表的最后一个元素为： " + list.last());
    }

}

2，无序链表

成员变量，构造函数，公共操作完全一样，扩展的操作：

//无序链表扩展的操作
    
    public void addToFront(Object element){
        LinearNode node = new LinearNode(element);
        node.setNext(front);
        front = node;
        count++;
    }
    
    public void addToRear(Object element){
        LinearNode last = front;
        for(int i = 0;i < count-1;i++)
             last = last.getNext();
        LinearNode node = new  LinearNode(element);
        last.setNext(node);
        count++;
    }
    
    public void addAfter(Object after,Object element){
        LinearNode temp = front;
        LinearNode elenode = new LinearNode(element);
        
        for(int index = 0;index < count;index++){
            
            if(temp.getElement().equals(after) && index != count-1)
            {
                elenode.setNext(temp.getNext());
                temp.setNext(elenode);
                count++;
                return;
            }
            else if(temp.getElement().equals(after) && index == count-1)
            {
                LinearNode last = front;
                for(int i = 0;i < count-1;i++)
                     last = last.getNext();
                last.setNext(elenode);
                count++;
                return;
            }
            
            temp = temp.getNext();    
        }        
    }

3，索引链表

扩展的操作：

//索引链表扩展的操作
    
    public void add(Object element){//在表尾插入
        
        if(size() == 0)
        {
            front = new LinearNode(element);
            count++;
            return;
        }
        
        LinearNode node = new LinearNode(element);
        LinearNode last = front;
        for(int i = 0;i < count-1;i++)
             last = last.getNext();
        last.setNext(node);
        count++;
    }
    
    public void add(int index,Object element){
        LinearNode node = new LinearNode(element);
        if(index == 0)
        {
            node.setNext(front);
            front = node;
            count++;
        }
        else
        {
            LinearNode pre = front;
            for(int i = 0;i < index-1;i++)
                pre = pre.getNext();
            LinearNode current = pre.getNext();
            node.setNext(current);
            pre.setNext(node);
            count++;
        }    
    }
    
    public void set(int index,Object element){//设置某个索引上的元素（覆盖原来的，不需要移动元素）
        LinearNode node = new LinearNode(element);
        LinearNode temp = front;
        for(int i = 0;i < index;i++)
            temp = temp.getNext();
        temp.setElement(element);    
    }
    
    public Object get(int index){//返回某个索引上的元素
        LinearNode temp = front;
        for(int i = 0;i < index;i++)
            temp = temp.getNext();
        return temp.getElement();
    }
    
    public int indexOf(Object element){//返回某个元素的索引
        LinearNode temp = front;
        for(int index = 0;index < count;index++){
            if(element.equals(temp.getElement()))
            return index;
            temp = temp.getNext();
        }
        return -1;
    }
    
    public Object remove(int index){//移除指定索引上的元素
        if(index == 0)
        {
            Object result = front.getElement();
            front = front.getNext();
            count--;
            return result;
        }
        else if(index == count-1)
        {
            LinearNode last = front;
            for(int i = 0;i < count;i++)
                last = last.getNext();
            Object result = last.getElement();
            count--;
            return result;
        }    
        else
        {
            LinearNode pre = front;
            for(int i = 0;i < index-1;i++)
                pre = pre.getNext();
            LinearNode current = pre.getNext();
            Object result = current.getElement();
            pre.setNext(current.getNext());
            count--;    
            return result;
        }    
    }