數據結構之線性表

線性表

線性表的基本概念

• 對於同一個線性表，其每一個數據元素的值雖然不同，但必須具有相同的數據類型；
• 數據元素之間具有一種線性的或“一對一”的邏輯關系。
1. 第一個數據元素沒有前驅，這個數據元素被稱為開始節點；
2. 最后一個數據元素沒有后繼，這個數據元素被稱為終端節點；
3. 除了第一個和最后一個數據元素外，其他數據元素有且僅有一個前驅和一個后繼。

 

線性表的抽象數據類型描述

基本操作如下：

1. 線性表的置空操作clear()：將一個已經存在的線性表置為空表。
2. 線性表判空操作isEmpty()：判斷線性表是否為空，若為空，則返回true；否則，返回為false。
3. 求線性表的長度操作length()：求線性表中的數據元素的個數並返回其值。
4. 取元素操作get(i)：讀取並返回線性表中的第i個數據元素的值。其中i的取值范圍為0≤i≤length()-1。
5. 插入操作insert(i,x)：在線性表的第i個數據元素之前插入一個值為x的數據元素。其中i的取值范圍為0≤i≤length()。當i=0時，在表頭插入x；當i=length()時，在表尾插入x。
6. 刪除操作remove(i)：刪除並返回線性表中第i個數據元素。其中i的取值范圍為0≤i≤length()-1。
7. 查找操作indexOf(x)：返回線性表中首次出現的指定的數據元素的位序號，若線性表中不包含此數據元素，則返回-1。

線性表的抽線數據類型用Java接口描述如下：

 

/**
 * 
 * @author Accper
 * 
 */
public interface IList {
    // 線性表置空操作
    public void clear();

    // 判斷線性表是否為空操作
    public boolean isEmpty();

    // 獲取線性表中元素的長度操作
    public int length();

    // 獲取指定位置上面的元素操作
    public Object get(int i);

    // 在指定位置上面插入元素的操作
    public void insert(int i, Object x);

    // 刪除指定位置上面的元素的操作
    public void remove(int i);

    // 查找指定元素的位置首次出現的位置操作
    public int indexOf(Object x);

    // 顯示線性表中的內容操作
    public void display();
}

 

 

線性表的順序存儲及實現

1. 順序表的定義
• 所謂順序表就是順序存儲的線性表。順序存儲是用一組地址連續的存儲單元依次存放線性表中各個元素的存儲結構。
2. 順序表的特點：
• 在線性表中邏輯上相鄰的數據元素，在物理存儲上也是相鄰的。
• 存儲密度高，但要預先分配“足夠應用”的存儲空間，這可能會造成存儲空間的浪費。
• 便於隨機存儲。
• 不便於插入和刪除操作，這是因為在順序表上進行的插入和刪除操作會引起大量數據元素的移動。
3. 順序存儲結構類的描述

 

/**
 * 
 * @author Accper
 * 
 */
public class SqList implements IList {
    // 線性表存儲空間
    private Object[] listElem;
    // 線性表的當前長度
    private int curLen;

    // 順序表類的構造函數，構造一個存儲空間容量為maxSize的線性表
    public SqList(int maxSize) {
        // TODO Auto-generated constructor stub
        curLen = 0;
        listElem = new Object[maxSize];
    }

    // 將一個已經存在的線性表置成空表
    public void clear() {
        // TODO Auto-generated method stub
        // 置順序表的當前長度為0
        curLen = 0;
    }

    // 判斷線性表中的數據元素的個數是否為0，若為0則返回true，否則返回false
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return curLen == 0;
    }

    // 求線性表中的數據元素的個數並返回其值
    public int length() {
        // TODO Auto-generated method stub
        // 返回順序表的當前長度
        return curLen;
    }

    // 讀取到線性表中的第i個數據元素並由函數返回其值，其中i的取值范圍為0≤i≤length()-1，若i不在此范圍則拋出異常
    public Object get(int i) {
        // TODO Auto-generated method stub
        if (i < 0 || i >= curLen) {
            throw new RuntimeException("第" + i + "個元素不存在");
        }
        return listElem[i];
    }

    // 在線性表的第i個數據元素之前插入一個值位x的數據元素
    public void insert(int i, Object x) {
        // TODO Auto-generated method stub
        // 判斷表是否滿了
        if (curLen == listElem.length) {
            throw new RuntimeException("存儲空間已經滿了，無法插入新的元素");
        }
        // 插入的位置不合法
        if (i < 0 || i > curLen) {
            throw new RuntimeException("插入的位置不合法");
        }
        // 必須要從最后一個元素開始依次逐個后移動，直到第i個數據元素移動完畢為止。
        for (int j = curLen; j > i; j--) {
            listElem[j] = listElem[j - 1];
        }
        listElem[i] = x;
        curLen++;
    }

    public void remove(int i) {
        // TODO Auto-generated method stub
        if (i < 0 || i > curLen - 1) {
            throw new RuntimeException("刪除的位置不合法");
        }
        for (int j = i; j < curLen; j++) {
            listElem[j] = listElem[j+1];
        }
        curLen--;
    }

    // 返回線性表中首次出現指定的數據元素的位序號，若線性表中不包含此數據元素，則返回-1
    public int indexOf(Object x) {
        // TODO Auto-generated method stub
        for (int i = 0; i < curLen; i++) {
            if (listElem[i].equals(x)) {
                return i;
            }
        }
        return -1;
    }

    // 輸出線性表中的數據元素
    public void display() {
        // TODO Auto-generated method stub
        for (int i = 0; i < curLen; i++) {
            System.out.print(listElem[i] + " ");
        }
        System.out.println();
    }

    // 測試
    public static void main(String[] args) {
        SqList sqList = new SqList(10);
        sqList.insert(0, "a");
        sqList.insert(1, "z");
        sqList.insert(2, "d");
        sqList.insert(3, "m");
        sqList.insert(4, "z");
        int order = sqList.indexOf("z");
        if (order!=-1) {
            System.out.println("順序表中第一次出現的值為z的數據元素的位置為："+order);
        }else {
            System.out.println("順序表中不包括z元素");
        }
    }
}

 

線性表的鏈式存儲及實現

1. 結點類的描述

/**
 * 
 * @author Accper
 *
 */
public class Node {
    // 存放結點的值
    private Object data;
    // 后繼結點的引用
    private Node next;

    // 無參數時的構造函數
    public Node() {
        // TODO Auto-generated constructor stub
        this(null, null);
    }

    // 帶有一個參數時的構造函數
    public Node(Object data) {
        this(data, null);
    }

    // 帶有兩個參數時的構造函數
    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

單鏈表類的描述

/**
 * 
 * @author Accper
 *
 */
public class LinkList implements IList {
    // 單鏈表的頭指針
    private Node head;

    // 單鏈表的構造函數
    public LinkList() {
        // TODO Auto-generated constructor stub
        // 初始化頭結點
        head = new Node();
    }

    public LinkList(int n, boolean Order) {
        // 初始化頭結點
        this();
        if (Order) {
            // 用尾插法順序建立單鏈表
            create1(n);
        } else {
            // 用頭插法順序建立單鏈表
            create2(n);
        }
    }

    // 用頭插法順序建立單鏈表
    private void create2(int n) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < n; i++) {
            insert(0, sc.next());
        }
    }

    // 用尾插法順序建立單鏈表
    private void create1(int n) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < n; i++) {
            insert(length(), sc.next());
        }
    }

    // 將一個已經存在的帶頭結點的單鏈表置成空表
    @Override
    public void clear() {
        // TODO Auto-generated method stub
        head.setData(null);
        head.setNext(null);
    }

    // 判斷帶頭結點的單鏈表是否為空
    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return head.getNext() == null;
    }

    // 求帶頭結點的單鏈表的長度
    @Override
    public int length() {
        // TODO Auto-generated method stub
        // 初始化，p指向頭結點，length為計數器
        Node p = head.getNext();
        int length = 0;
        // 從頭結點開始向后查找，直到p為空
        while (p != null) {
            // 指向后繼結點
            p = p.getNext();
            // 長度加1
            length++;
        }
        return length;
    }

    // 讀取帶頭結點的單鏈表中的第i個結點
    @Override
    public Object get(int i) {
        // TODO Auto-generated method stub
        Node p = head.getNext();
        int j = 0;
        while (p != null && j < i) {
            p = p.getNext();
            j++;
        }
        // i小於0或者大於表長減1
        if (j > i || p == null) {
            throw new RuntimeException("第" + i + "個元素不存在");
        }
        return p.getData();
    }

    // 在頭結點的單鏈表中的第i個結點之前插入一個值為x的新結點
    @Override
    public void insert(int i, Object x) {
        // TODO Auto-generated method stub
        Node p = head;
        int j = -1;
        // 尋找第i個結點的前驅
        while (p != null && j < i - 1) {
            p = p.getNext();
            j++;
        }
        if (j > i - 1 || p == null) {
            throw new RuntimeException("插入位置不合法");
        }
        Node s = new Node(x);
        // 修改鏈，使新結點插入到單鏈表中
        s.setNext(p.getNext());
        p.setNext(s);
    }

    // 刪除帶頭結點的單鏈表中的第i個結點
    @Override
    public void remove(int i) {
        // TODO Auto-generated method stub
        Node p = head;
        int j = -1;
        while (p.getNext() != null && j < i - 1) {
            p = p.getNext();
            j++;
        }
        if (j > i - 1 || p.getNext() == null) {
            throw new RuntimeException("刪除位置不合法");
        }
        // 修改鏈指針，使待刪除結點從單鏈表中脫離
        p.setNext(p.getNext().getNext());
    }

    // 查找指定單鏈表中元素的位置，若在單鏈表中值發回該位置，如果不在單鏈表中則返回-1
    @Override
    public int indexOf(Object x) {
        // TODO Auto-generated method stub
        Node p = head.getNext();
        int j = 0;
        while (p != null && p.getData().equals(x)) {
            p = p.getNext();
            j++;
        }
        if (p == null) {
            return -1;
        } else {
            return j;
        }
    }

    // 輸出單鏈表中的所有結點
    @Override
    public void display() {
        // TODO Auto-generated method stub
        // 取出帶頭結點的單鏈表中的首結點
        Node p = head.getNext();
        while (p != null) {
            // 輸出結點的值
            System.out.print(p.getData() + " ");
            // 取下一個結點
            p = p.getNext();
        }
        System.out.println();
    }

    // 測試
    public static void main(String[] args) {
        int n = 10;
        LinkList L = new LinkList();
        for (int i = 0; i < n; i++) {
            L.insert(i, i);
        }
        System.out.println("請輸入i的值：");
        int i = new Scanner(System.in).nextInt();
        if (0 < i && i <= n) {
            System.out.println("第" + i + "個元素的前驅是:" + L.get(i - 1));
        } else {
            System.out.println("第" + i + "個元素的直接前驅不存在");
        }
    }
}