常见数据结构之线性表

Posted 2021-01-30 turbosha

线性表

线性表（List）:由零个或多个数据元素组成的有限序列。

线性结构是最简单，也是最常用的数据结构之一。

线性结构的特点是：在数据元素的有限集中，除第一个元素无直接前驱，最后一个元素无直接后驱外，每个元素数据有且仅有一个直接前驱元素和一个直接后续元素。

线性表---顺序存储结构（Java代码实现）

线性表的顺序存储结构：指的是用一段地址连续的存储单元依次存储线性表的数据元素。

 　　说白了，就是在内存中找了块地方，通过占位的形式，把一定的内存空间给占了，然后把相同数据类型的元素依次存放在这块空地。可用一维数组来实现顺序存储结构。

描述顺序存储结构需要三个属性：

• 存储空间的起始位置：数组data，它的存储位置就是存储空间的位置
• 线性表的最大存储容量：数组长度MaxSize
• 线性表的当前长度：length

package ch01;

/**
 * 线性表：顺序存储结构
 */
public class MyArray {
    private long[] arr;
    //表示有效数据的长度
    private int elements;
    
    public MyArray() {
        arr = new long[50];
    }
    
    public MyArray(int maxsize) {
        arr = new long[maxsize];
    }
    
    /**
     * 添加数据
     */
    public void insert(long value) {
        arr[elements] = value;
        elements++;
    }
    
    /**
     * 显示数据
     */
    public void display() {
        System.out.print("[");
        for(int i = 0; i < elements; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println("]");
    }
    
    /**
     * 查找数据
     */
    public int search(long value) {
        int i;
        for(i = 0; i < elements; i++) {
            if(value == arr[i]) {
                break;
            }
        }
        
        if(i == elements) {
            return -1;
        } else {
            return i;
        }
        
    }
    
    /**
     * 查找数据，根据索引来查
     */
    public long get(int index) {
        if(index >= elements || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            return arr[index];
        }
    }
    
    /**
     * 删除数据
     */
    public void delete(int index) {
        if(index >= elements || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            for(int i = index; i < elements; i++) {
                arr[index] = arr[index + 1];
            }
            elements--;
        }
    }
    
    /**
     * 更新数据
     */
    public void change(int index, int newvalue) {
        if(index >= elements || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            arr[index] = newvalue;
        }
    }
}

View Code

 线性表---链式存储结构（Java代码实现）

单向链表存储结构：单向链表的每个结点包含数据域和指针域，指针域指向后继结点的指针域。

package ch04;

/*
 * 单链表结点，相当于是车厢
 */
public class Node {
    //数据域
    public long data;
    //指针域
    public Node next;

    public Node(long value) {
        this.data = value;
    }

    /**
     * 显示方法
     */
    public void display() {
        System.out.print(data + " ");
    }
}

package ch04;
/*
 * 链表，相当于火车
 */
public class LinkList {
    //头结点
    private Node first;
    
    public LinkList() {
        first = null;
    }
    
    /**
     * 插入一个结点，在头结点后进行插入
     */
    public void insertFirst(long value) {
        Node node = new Node(value);
        node.next = first;
        first = node;
    }
    
    /**
     * 删除一个结点，在头结点后进行删除
     */
    public Node deleteFirst() {
        Node tmp = first;
        first = tmp.next;
        return tmp;
    }
    
    /**
     * 显示方法
     */
    public void display() {
        Node current = first;
        while(current != null) {
            current.display();
            current = current.next;
        }
        System.out.println();
    }
    
    /**
     * 查找方法
     */
    public Node find(long value) {
        Node current = first;
        while(current.data != value) {
            if(current.next == null) {
                return null;
            }
            current = current.next;
        }
        return current;
    }
    
    /**
     * 删除方法，根据数据域来进行删除
     */
    public Node delete(long value) {
        Node current = first;
        Node previous = first;
        while(current.data != value) {
            if(current.next == null) {
                return null;
            }
            previous = current;
            current = current.next;
        }
        
        if(current == first) {
            first = first.next;
        } else {
            previous.next = current.next;
        }
        return current;
        
    }
}

View Code

循环链表存储结构 ：将单向链表中的终端结点由空指针改为指向头结点，就使整个单链表形成了一个环。

 

 

双向链表存储结构：在单向链表的基础上，再设置一个指向前驱结点的指针域。

package ch05;
/*
 * 双向链表结点，相当于是车厢
 */
public class Node {
    //数据域
    public long data;
    //指针域
    public Node next;//指向后继结点指针域
    public Node previous;//指向前驱结点指针域
    
    public Node(long value) {
        this.data = value;
    }
    
    /**
     * 显示方法
     */
    public void display() {
        System.out.print(data + " ");
    }
}

 

 

package ch05;
/*
 * 双向链表
 */
public class DoubleLinkList {
    //头结点
    private Node first;
    //尾结点
    private Node last;
    
    public DoubleLinkList() {
        first = null;
        last = null;
    }
    
    /**
     * 插入一个结点，在头结点后进行插入
     */
    public void insertFirst(long value) {
        Node node = new Node(value);
        if(isEmpty()) {
            last = node;
        } else {
            first.previous = node;
        }
        node.next = first;
        first = node;
    }
    
    /**
     * 插入一个结点，从尾结点进行插入
     */
    public void insertLast(long value) {
        Node node = new Node(value);
        if(isEmpty()) {
            first = node;
        } else {
            last.next = node;
            node.previous = last;
        }
        last = node;
    }
    
    /**
     * 删除一个结点，在头结点后进行删除
     */
    public Node deleteFirst() {
        Node tmp = first;
        if(first.next == null) {
            last = null;
        } else {
            first.next.previous = null;
        }
        first = tmp.next;
        return tmp;
    }
    
    /**
     * 删除结点，从尾部进行删除
     */
    public Node deleteLast() {
        Node tmp = last;
        if(first.next == null) {
            first = null;
        } else {
            last.previous.next = null;
        }
        last = last.previous;
        return last;
    }
    
    /**
     * 显示方法
     */
    public void display() {
        Node current = first;
        while(current != null) {
            current.display();
            current = current.next;
        }
        System.out.println();
    }
    
    /**
     * 查找方法
     */
    public Node find(long value) {
        Node current = first;
        while(current.data != value) {
            if(current.next == null) {
                return null;
            }
            current = current.next;
        }
        return current;
    }
    
    /**
     * 删除方法，根据数据域来进行删除
     */
    public Node delete(long value) {
        Node current = first;
        while(current.data != value) {
            if(current.next == null) {
                return null;
            }
            current = current.next;
        }
        
        if(current == first) {
            first = first.next;
        } else {
            current.previous.next = current.next;
        }
        return current;
        
    }
    
    /**
     * 判断是否为空
     */
    public boolean isEmpty() {
        return (first == null);
    }
}

View Code