数据结构数组与顺序表

••• ••
顺序表的插入操作
0 1 2 3 4 5 6 7
listarray 25 34 57 16 48 09 63 i 插入 x = 50
0 1 2 3 4 5 6 7
……
listarray 25 34 57 50 16 48 09 63 ……
AMN
n 1 1 = ∑0 ( n − i ) = n + 1 ( n + L + 1 + 0) n + 1 i= 1 n ( n + 1) n = = ( n + 1) 2 2
前i1页总 元素个数 第i1页的 前i2行总 元素个数 第i2 行 前i3列元 素个数
•
线性表 (Linear List)
定义： 个数据元素的有限序列； 定义：n个数据元素的有限序列； n为线性 表的长度， 时为空表。 表的长度，当பைடு நூலகம்＝0时为空表。 特点： 特点：
除第一个元素外，其他每一个元素有一个且仅 除第一个元素外， 有一个直接前驱。 有一个直接前驱。 除最后一个元素外， 除最后一个元素外，其他每一个元素有一个且 仅有一个直接后继。 仅有一个直接后继。 原则上讲， 原则上讲，线性表中表元素的数据类型可以不相 但采用的存储表示可能会对其有限制。 同。但采用的存储表示可能会对其有限制。
••• •
顺序表结构
数组
listarray
变量 0 1 ... ... size-1
数组下标 MaxSize size
操作算法
初始化操作 插入操作 删除操作 查找操作 排序操作 ......
...
... MaxSize-1
•••
顺序表(SeqList)类的定义 顺序表(SeqList)类的定义
public class SeqList { final int defaultSize = 10; int maxSize; int size; Object[ ] listArray; private void initiate(int sz){ maxSize = sz; size = 0; listArray = new Object[sz]; } public SeqList(int size){ initiate(size); } public SeqList(){ initiate(defaultSize); } public int size(){ return size; } public boolean isEmpty(){ return size == 0; } public int Find ( Object x ) { …… } public void insert(int i,Object obj) { …… } public Object delete(int i) { …… } public Object getData(int i) { …… } public int MoreDataDelete(SeqList L, Object x) { …… } } ••
25 34 57 16 48 i 25 34 57 16 i 25 34 57 16 i 25 34 57 16 i 25 34 57 16 48 48 48 48 i
搜索 50
搜索失败
••• •••
搜索成功的平均比较次数
ACN
=
∑
n −1 i=0
情况i发生 情况 发生 的概率 情况i时的 情况 时的 比较次数
•
顺序表的删除操作成员函数（2） 顺序表的删除操作成员函数（
public int MoreDataDelete(SeqList L, Object x) { int i, j; int tag = 0; for(i = 0; i < L.size; i++){ if(x.equals(L.getData(i))){ L.delete(i); i --; tag = 1; } } return tag; }
顺序表的查找（搜索） 顺序表的查找（搜索）
搜索函数 int Find ( Object x ) 在顺序表中从头向尾查找结点值等于给定值x的结点 在顺序表中从头向尾查找结点值等于给定值 的结点
public int Find ( Object x ) { int i = 0; while ( i < size && !listArray[i].equals(x) ) i++; if ( i >= size ) return -1; else return i; }
l l l l l l l a+i*l l l l
LOC(i) = LOC(i-1)+l = LOC(i-1)+ i*l
•••
二维数组连续存储方式
a [ 0 ][ 0 ] a [1 ][ 0 ] = a [ 2 ][ 0 ] M a [ n − 1 ][ 0 ] a [ 0 ][ 1 ] a [1 ][ 1 ] a [ 2 ][ 1 ] M a [ n − 1 ][ 1 ] L L L O L a [ 0 ][ m − 1 ] a [ 1 ][ m − 1 ] a [ 2 ][ m − 1 ] M a [ n − 1 ][ m − 1 ]
p i× c i
若搜索概率相等，则 若搜索概率相等，
1 n −1 1 ACN = ∑ ( i + 1) = (1 + 2 + L + n ) = n i =0 n 1 (1 + n ) ∗ n 1 + n = ∗ = n 2 2
最好情况，查找目标为第一个元素，比较1次； 最好情况，查找目标为第一个元素，比较1 最坏情况： 最坏情况：搜索不成功 数据比较 n 次。
35 27 49 18 60 54 77 83 41 02 下标，起始下标，元素占用空间，数组占 下标，起始下标，元素占用空间， 用空间，访问数组元素， 用空间，访问数组元素，......
••• ••• •
多维数组及其顺序存储
多维数组是一维数组的推广
a[i]
i 一维数组a[5] 一维数组 i i k 复合线性结构
b[i][j]
c[i][j][k]
j 二维数组b[3][5] 二维数组
j 三维数组c[3][5][4] 三维数组 ••• •
一维数组连续存储方式
LOC(0) , LOC(i) = LOC(0) +i*l, i>0 i=0
0
1
2
3
4
5 6
7
8
9
a 35 27 49 18 60 54 77 83 41 02
••• •
顺序表的插入操作成员函数
public void insert(int i,Object obj) throws Exception{ if (size == maxSize){ throw new Exception("顺序表已满无法插入！"); 顺序表已满无法插入！ 顺序表已满无法插入 } if (i < 0 || i > size){ throw new Exception("参数错误！"); 参数错误！ 参数错误 } for(int j = size; j > i; j--){ listArray[j] = listArray[j-1]; } listArray[i] = obj; size++; }
数据结构
第2章 顺序表与数组
一维数组
数组的定义：存储于一个连续存储 连续存储空间的 数组的定义：存储于一个连续存储空间的 相同类型的数据元素的集合 的数据元素的集合。 相同类型的数据元素的集合。 一维数组：长度（大小） 一维数组：长度（大小）为n的有限序列
下标 0 1 2 3 4 5 6 7 8 9
••• ••
顺序表 (Sequential List)
定义：将线性表中的元素相继存放在一 定义： 个连续的存储空间中。 个连续的存储空间中。可利用一 数组或链表作为其存储结构 作为其存储结构。 维数组或链表作为其存储结构。 特点： 特点：顺序存取 限制： 限制：所有元素有相同数据类型 顺序表的遍历： 顺序表的遍历：
•
顺序表示例（1） 顺序表示例（
public class SeqListTest1{ public static void main(String args[ ]){ SeqList seqList = new SeqList(100); int n = 10; try{ for(int i = 0; i < n; i++){seqList.insert(i,new Integer(i+1));} System.out.println("size1="+seqList.size); seqList.delete(4); System.out.println("size2="+seqList.size); seqList.insert(2,new Integer(22)); System.out.println("size3="+seqList.size); System.out.println(seqList.Find(new Integer(8))); for(int i = 0; i < seqList.size; i++){ System.out.print(seqList.getData(i)+" ");} } catch(Exception e){System.out.println(e.getMessage());} } } •
••
顺序表的删除操作成员函数（1） 顺序表的删除操作成员函数（