java 基础数据结构

数据结构, 需要考虑两个方面:

1. 每个元素具体的存储方法 (java中是一个对象)

2. 元素之间的关系如何实现存储 (java中也是一个对象)

另外在java中, 已经可以把跟数据结构有关的一些方法写到一个类里了.

线性表

顺序表

c语言: 借助数组实现

#define INIT_SIZE 100;
typedef struct {
    int elem[INIT_SIZE];    // 用来存储数组元素
    int length;                    // 当前顺序表的长度
} SqList;
// 元素之间的关系隐含在数组这种数据结构中

java语言: 也可以借用数组实现

可以直接借助 ArrayList实现.

链表

c语言:

// 结点
// 结点之间没有明确的关系, 靠一个向后的指针联系
typedef struct LNode {
    int elem;    // 元素
    struct LNode *next;    // 维系关系
} LNode, &LinkList;

java语言:

package DataSturcture;

public class LinkList<T> {
    
    // node object
    private class Node {
        
        public Node() {}
        public Node(T data, Node next){
            this.data = data;
            this.next = next;
        }
    /* private instance variable */
        private T data;        // element;
        private Node next;    // pointer, point next Node
    }
    
    public LinkList() {
        header = null;
        tail = null;
    }
    
    public LinkList(T element) {
        header = new Node(element, null);
        tail = header;
        size++;
    }
    
    public int length() {
        return size;
    }
    
    public T get(int index) {
        return getNodeByIndex(index).data;
    }
    
    private Node getNodeByIndex(int index) {
        if (index < 0 || index > size -1) {
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        
        Node current = header;
        for (int i=0; i<size && current != null; current=current.next) {
            if (i == index) {
                return current;
            }
        }
        return null;
    }
    
    public int locate(T element) {
        Node current = header;
        for (int i=0; i<size && current != null; i++, current=current.next) {
            if (current.data.equals(element)) {
                return i;
            }
        }
        return -1;
    }
    
    public void insert(T element, int index) {
        if (index < 0 || index > size -1) {
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        if (header == null) {
            add(element);
        } else {
            if (index == 0) {
                addAtHeader(element);
            } else {
                Node prev = getNodeByIndex(index - 1);
                prev.next = new Node(element, prev.next);
                size++;
            }
        }
    }
    
    public void add(T element) {
        if (header == null) {
            header = new Node(element, null);
        } else {
            Node newNode = new Node(element, null);
            tail.next = newNode;
            tail = newNode;
        }
        size++;
    }
    
    public void addAtHeader(T element) {
        header = new Node(element, header);
        if (tail == null) {
            tail = header;
        }
        size++;
    }
    
    public T delete(int index) {
        if (index < 0 || index > size -1) {
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        Node del = null;
        if (index == 0) {
            del = header;
            header = header.next;
        } else {
            Node prev = getNodeByIndex(index - 1);
            del = prev.next;
            prev.next = del.next;
            del.next = null;
        }
        size--;
        return del.data;
    }
    
    public T remove() {
        return delete(size - 1);
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public void clear() {
        header = null;
        tail = null;
        size = 0;
    }
    
    public String toString() {
        if (isEmpty()) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            for (Node current=header; current != null; current=current.next) {
                sb.append(current.data.toString() + ", ");
            }
            int len = sb.length();
            return sb.delete(len-2, len).append("]").toString();
        }
    }
    
/* private instance variable */
    private Node header;    // header information
    private Node tail;        // tail information
    private int size;        // count node
    
}

View Code