正文

Java 数据结构线性表之顺序存储详解原理

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0709

线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关

线性表的定义

线性表的逻辑特征：

  • ①有且仅有一个称为开始元素的a1，她没有前趋，仅有一个后继结点a2；
  • ②有且仅有一个称为终端元素的an,他没有后继，只有一个直接前驱a(n-1)；
  • ③其余元素ai(2≤i≤n-1)称为内部元素，他们都有且仅有一个直接前驱a(i-1)和直接后继a(i+1)。

Java 数据结构线性表之顺序存储详解原理

线性表的图像表示

线性表的基本运算

  • 线性表初始化
  • 求表长
  • 按索引值查找元素
  • 按值查找
  • 插入元素
  • 删除

线性表的存储之顺序存储

线性表顺序存储的定义：线性表的顺序存储指的是将线性表的数据元素按其逻辑次序依次存入一组连续的存储单元里，用这种方式存储的线性表称为顺序表。

Java 数据结构线性表之顺序存储详解原理

定义线性表

定义线性表的默认空间大小，定义一个数组，定义数组的长度，初始化一个size用来保存里面元素的个数。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/** 定义线性表默认空间大小 */
private final Integer ListSize=100;
/**定义数组长度*/
private Integer Len;
/** 定义线性表保存的数据类型
 * 使用泛型*/
private Object[] list;
/**存一个当前元素的个数*/
private Integer size=0;
/**定义默认线性表*/
public SeqList(){
    Len = ListSize;
    this.list = new Object[Len];
    size++;
}

初始化线性表

把线性表里面的元素全部置空

?
1
2
3
4
5
6
7
/**清空线性表*/
public void clear(){
    for (int i = 0; i < size; i++) {
        list[i]=null;
    }
    size=0;
}

添加元素

这里采用尾插法，即每次默认将元素放在最后面

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**添加元素到指定位置*/
public void insert(T element , int index){
    if(index>=Len || index<0){
        throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
    }
    Capacity(size+1);
    //将添加元素的元素往后移一位
    for (int i = size-2; i >= index-1; i--) {
        list[i+1]=list[i];
    }
    list[index-1]=element;
    size++;
}
/**添加元素到末尾*/
public void add(T element){
    insert(element,size);
}

查找元素

这个模块分为按索引值查找，和按元素值查找

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**线性表的查找
 * 按索引值查找*/
public T getNode(int index){
    return (T)list[index-1];
}
/**按元素值查找返回索引值*/
public int LocateNode(T t){
    for(int i=0;i<list.length;i++){
        if(list[i].equals(t)){
            return i+1;
        }
    }
    System.out.println("没有找到该元素！");
    return -1;
}

删除元素

删除元素，又分为删除指定元素，和删除最后一个元素

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**删除指定位置的元素*/
public T delete(int index){
    if(!OutIndex(index)){
        throw new IndexOutOfBoundsException("删除位置不在线性表的索引范围内！");
    }
    for (int i = index-1; i < size-1; i++) {
        list[i]=list[i+1];
    }
    /*if(size - index >0){
        System.arraycopy(list,index,list,index-1,size-index);
    }*/
    list[size-1]=null;
    size--;
    return (T) list;
}
/**删除最后一个元素*/
public T remove(){
    return delete(size-1);
}

打印线性表

打印线性表，其实就是重写一个toString方法，将线性表打印出来

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**循环打印线性表*/
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        if(isEmpty()){
            return "[]";
        }
        else {
            sb.append("[");
            for (int i = 0; i < size-1; i++) {
                int a=0;
                if(list[i]!=null){
                    sb.append(list[ i ]);
                }
                else {
                    break;
                }
                sb.append(",");
            }
            sb.append("]");
            sb.deleteCharAt(sb.indexOf(",]"));
        }
        return sb.toString();
    }

实现的完整代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
class SeqList<T>{
    /** 定义线性表默认空间大小 */
    private final Integer ListSize=100;
    /**定义数组长度*/
    private Integer Len;
    /** 定义线性表保存的数据类型
     * 使用泛型*/
    private Object[] list;
    /**存一个当前元素的个数*/
    private Integer size=0;
    /**定义默认线性表*/
    public SeqList(){
        Len = ListSize;
        this.list = new Object[Len];
        size++;
    }
    /**定义自定义长度的线性表*/
    public SeqList(int length){
        Len = length;
        list = new Object[Len];
        size++;
    }
    /**获取当前线性表的长度*/
    public int getLen(){
        return Len;
    }
    /**获取当前线性表元素的个数*/
    public int getSize(){
        return size;
    }
    /**根据元素查找在线性表中的位置，未找到返回-1*/
    public int getIndex(T element){
        for (int i = 0; i < size; i++) {
            if(list[i].equals(element)){
                return i;
            }
        }
        return -1;
    }
    /**判断是否表满或表空*/
    private boolean OutIndex(int index){
        //return size==Len;//不扩容的话，可以这样写，但是怕扩容
        if(index>size || index<0){
            return false;
        }
        else {
            return true;
        }
    }
    /**根据索引值返回元素*/
    private T getElement(int index){
        if(!OutIndex(index)){
            throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
            /* System.out.println("输入索引超过了线性的范围");
            return null; */
        }
        return (T)list[index];
    }
    /**扩容*/
    private T Capacity(int capacity){
        if(capacity<Len){
            Len = Len+(Len+1)/2;
            if(capacity<Len){
                Capacity(Len);
            }
            else {
                list = Arrays.copyOf(list,Len);
                return (T) list;
            }
        }
        return (T)list;
    }
    /**添加元素到指定位置*/
    public void insert(T element , int index){
        if(index>=Len || index<0){
            throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
        }
        Capacity(size+1);
        //将添加元素的元素往后移一位
        for (int i = size-2; i >= index-1; i--) {
            list[i+1]=list[i];
//            System.out.println("i="+i);
        }
        list[index-1]=element;
        size++;
    }
    /**添加元素到末尾*/
    public void add(T element){
        insert(element,size);
    }
    /**判断元素表是否为空*/
    public boolean isEmpty(){
        return size==0;
    }
    /**删除指定位置的元素*/
    public T delete(int index){
        if(!OutIndex(index)){
            throw new IndexOutOfBoundsException("删除位置不在线性表的索引范围内！");
        }
        for (int i = index-1; i < size-1; i++) {
            list[i]=list[i+1];
        }
        /*if(size - index >0){
            System.arraycopy(list,index,list,index-1,size-index);
        }*/
        list[size-1]=null;
        size--;
        return (T) list;
    }
    /**删除最后一个元素*/
    public T remove(){
        return delete(size-1);
    }
    /**清空线性表*/
    public void clear(){
        for (int i = 0; i < size; i++) {
            list[i]=null;
        }
        size=0;
    }
    /**线性表的查找
     * 按索引值查找*/
    public T getNode(int index){
        return (T)list[index-1];
    }
    /**按元素值查找返回索引值*/
    public int LocateNode(T t){
        for(int i=0;i<list.length;i++){
            if(list[i].equals(t)){
                return i+1;
            }
        }
        System.out.println("没有找到该元素！");
        return -1;
    }
    /**循环打印线性表*/
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        if(isEmpty()){
            return "[]";
        }
        else {
            sb.append("[");
            for (int i = 0; i < size-1; i++) {
                int a=0;
                if(list[i]!=null){
                    sb.append(list[ i ]);
                }
                else {
                    break;
                }
                sb.append(",");
            }
            sb.append("]");
            sb.deleteCharAt(sb.indexOf(",]"));
        }
        return sb.toString();
    }
}

测试一下

测试代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) {
    SeqList<String> seqList = new SeqList<String>();
    //添加一个元素
    seqList.add("pier");
    seqList.add("真好看");
    seqList.add("90度点头");
    System.out.println("添加后的线性表为\n\t"+seqList.toString());
    seqList.insert("pipi",1);
    System.out.println("在位置1的地方添加元素后的线性表为\n\t"+seqList.toString());
    seqList.delete(1);
    System.out.println("删除第二个元素后的线性表为\n\t"+seqList.toString());
    System.out.println("pier时第"+seqList.LocateNode("pier")+"个元素");
    System.out.println("第1个元素是"+seqList.getNode(1)+"。");
}

运行结果

Java 数据结构线性表之顺序存储详解原理

到此这篇关于Java 数据结构线性表之顺序存储详解原理的文章就介绍到这了,更多相关Java 数据结构 内容请搜索米米素材网以前的文章或继续浏览下面的相关文章希望大家以后多多支持米米素材网！

原文链接：https://blog.csdn.net/qq_43325476/article/details/120919973