第二章 线性表

2.1线性表类型定义

　　线性表描述：A=（a1,a2,...an）;A为线性表的名称，a_i为线性表 的数据元素。

　　线性表的离散定义：B=<A,R>,A包含n个结点（a₁,a₂,...a_n）,R中只包含一个关系，即线性关系，R={(a_i-1,a_i)|i=1,2,....,n},

　　一般的线性表的操作可以包含以下几种：

　　* public linklist()  建立一个空的线性表。

　　* public linklist(collection c)  将collection c中的数据依次建立一个线性表。

　　* public object getfirst()  返回线性表的第一个元素。

　　* public object getlast()  返回线性表的最后一个元素 。

 　  * public object removefirst()  删除线性表的第一个元素，并返回该值。

　　* public object removelast()  删除线性表的最后一个元素 ，并返回该值。

　　* public void addfirst(object o)  将object o插入到链表的开头位置。　　

　　* public object addlast(object o)  将object o插入到链表的末尾位置

　　* public boolean contains(object o)  检查object o是否存在链表中，如果存在返回true，不存在返回false

　　* public int size() 返回线性表的元素个数

　　* public boolean add(object o)  将object o插入到链表的末尾位置,并返回true

　　* public boolean remove(object o) 将链表中第一次出现的元素删除，成功返回true，否则false；

　　* public addall(collection c) 将collection c中的数据依次插入到链表的末尾

　　* public addall(int index,collection c) 将collection c中的数据依次插入到链表的index位置，并将index位置之后的元素依次插入到collection c之后，链接成一个完整的线性表

　　* public void clear() 删除线性表中的所有元素

　　* public object get(int index) 返回线性表的index位置的元素

　　* public object set(int index, object element) 以object element取代线性表index位置的元素

　　* public void add（int index，object element） 将object element插入到线性表index位置之后。

　　* public object remove（int index） 删除线性表中的index位置的元素

　　* public int indexof（object o）返回object o在线性表中第一次出现的位置，若不存在返回-1

　　* public int lastindexof（object o）返回object o在线性表中最后一次出现的位置，若不存在返回-1

　　* public listiterator listiterator（int index）返回线性表index位置开始的元素的内容

　　使用抽象数据类型（ADT）定义线性表如下：

　　ADT list{

　　　　数据对象：D={ai|ai属于元素集合，i=1,2,....n,n>=0}

　　　　数据关系：R={<a_i-1,a_i>|a_i-1,a_i属于元素集合，i=1,2,....n,}

　　　　基本操作：{

　　　　就是以上的那些操作

　　　　}

　　}

2.2 线性表的顺序表示和实现

　　线性表的存储结果分为书序存储和非顺序存储。顺序存储也称为向量存储或一维数组存储。

　　1.顺序表（向量存储，一维数组存储），线性表中节点存放的物理顺序和逻辑顺序完全一致。

　　

　　2.顺序表基本运算的实现

　　线性表顺序存储的结构容易实现存取数据元素，插入或删除数据元素比较繁琐

　　下面在数组中指定位置增加一个元素（java代码）：

package com.datastruture.chapeter02;

import java.util.Arrays;

/**
 * 
 * @ClassName: MyArray 
 * @Description: 数组的一些小练习
 * @author mao
 * @date 2017年3月19日 下午9:47:58 
 *
 */
public class MyArray {
    
    public static void main(String[] args) {
        
        int[] arr = new int[10];
        arr[0] = 0;
        arr[1] = 1;
        arr[2] = 2;
        arr[3] = 3;
        System.out.println(Arrays.toString(arr));
        int ele = 7;
        int index = 2;
        addElement(ele,arr,index);
        System.out.println(Arrays.toString(arr));
        
    }
    
    /**
     * 
     * @Title: addElement 
     * @Description:  在数组指定位置增加一个元素
     * @param @param ele 增加的元素
     * @param @param arr 目标数组
     * @param @param index 指定的位置
     * @return void   
     * @throws
     */
    public static void addElement(int ele, int[] arr,int index) {
        //数组的长度不能改变，所以这种模拟不太合适，因为最后一个元素没有了
        if(index>arr.length||index<0){
            System.out.println("下标不合法");
        }else{
            for (int i = arr.length-1; i >= index; i--) {
                arr[i]=arr[i-1];
            }
            arr[index]= ele;
        }
    }

    
    
}

　结果（注：插入后应该修改线性表的长度，但上面是java代码，数组的长度一旦定义就不能改变了）：

　　下面在数组中指定位置删除一个元素（java代码）：

/**
     * 
     * @Title: deleteElement 
     * @Description:  删除指定位置的元素
     * @param @param arr 目标数组
     * @param @param index  指定位置
     * @return void   
     * @throws
     */
    public static void deleteElement(int[] arr, int index) {
        
        if(index>arr.length||index<0){
            System.out.println(index+"不存在！");
        }else if(arr.length<0){
            System.out.println("数组为空");
        }else{
            //删除和增加的操作正好相反，删除是把后边的一个值赋给前面一个值，i++循环
            //增加是把前边的一个值赋给后面的一个值，且i--循环
            for (int i = index; i < arr.length-1; i++) {
                arr[i]=arr[i+1];
            }
        }
        
    }

　　结果：

在顺序存储的线性结构的线性表中插入或删除一个数据元素，平均约移动表中一半元素。若表长为n，则插入和删除算法的时间复杂度为O(n);

2.3 线性表的链式存储结构

2.3.1 单向链表

其中data是数据域，存放数据元素的值，next是指针域，存放相邻的下一个节点的地址，单向链表是指节点中的指针域只有一个沿着同一个方向的链式存储结构。