数据结构之线性表（1）顺序存储结构

线性表的顺序存储结构：顺序表

特点：逻辑上相邻的元素在物理位置上是相邻的。就是说开辟了一块连续的内存空间来存储这些数据。学过C语言的同学们都知道，符合开辟连续内存空间的特点的结构是数组。可以随机访问。

 

      算法我们在代码中进行实现，要点记录在注释中！！！上代码 

首先，把定义的顺序表结构附上，注意其中有清除数据，获取数据，获取数据长度，以及判断是否为空的基本方法！！！ 他们是删除和插入的基础。

package com.datastruct.struct.linerlist;
//定义顺序表结构
public class SeqList1 {
	public static int MAXSIZE = 10;//最大长度
	private int[] element;//存放数据的数组，顺序表的实际存储结构
	private int size;     //存放数据的长度。
	
	public SeqList1(){
		element = new int[MAXSIZE];
		//由于java中整形数组默认值所以会出现0,所以赋初值为-1，方便计算长度。
		initElement();
	}
	//get set 方法
	public int[] getElement() {
		return element;
	}

	public int getSize() {
		size = 0;
		for(int i :element){
			if(i != -1){
				size ++;
			}
		}
		return size;
	}
	
	//初始化元素表
	public void initElement(){
		for(int i = 0 ;i < MAXSIZE; i++ ){
			element[i] = -1;
		}
	}
	//清除顺序表内容
	public void clear(){
		initElement();
	}
	//判断表数据是否为空
	public boolean isEmpty(){
		return getSize()==0;
	}
	//根据下标获取某个元素
	public int getOneElementByIndex(int index){
		return this.getElement()[index];
	}
}

然后，把插入和删除元素的过程附上

package com.datastruct.linerList;

import org.junit.Test;

import com.datastruct.struct.linerlist.SeqList1;

public class TestSeqList {
	//遍历顺序表
	@Test
	public void testQueryAll(){
		//生成顺序表对象，并赋值
		SeqList1 l = new SeqList1();
		l.getElement()[0] = 0;
		l.getElement()[1] = 1;
		l.getElement()[2] = 2;
		l.getElement()[3] = 3;
		l.getElement()[4] = 4;
		l.getElement()[5] = 5;
		//遍历顺序表所有元素
		for(int i = 0;i < l.getSize();i++){
			System.out.println(l.getElement()[i]+" ");
		}
		System.out.println();//打印结果：0 1 2 3 4 5  
		
		//查找指定元素
		int i ;
		for(i = 0;i < l.getSize();i++){
			if(l.getElement()[i] == 3){
				break;
			}
		}
		if(i < l.getSize()){
			System.out.println("找到 :" + l.getElement()[i]);
		}else{
			System.out.println("未找到");
		}
		System.out.println();//打印结果：找到 :3
		
		//到以上为止，我们发现这种结构似曾相识，而且还更加方便：ArrayList
		//java中的Arraylist跟我们定义的SeqList1这个类一样，是一种顺序表结构。当然他的最大长度理论上是整数的最大值，你可以看做他没有长度限制，是一种特殊顺序表
	}
	//插入元素到顺序表
	@Test
	public void testInsert(){
		//生成顺序表对象，并赋值
			SeqList1 l = new SeqList1();
			l.getElement()[0] = 0;
			l.getElement()[1] = 1;
			l.getElement()[2] = 2;
			l.getElement()[3] = 3;
			l.getElement()[4] = 4;
			l.getElement()[5] = 5;
		//前提1.表不满 size < MAXSIZE
		//前提2.在合适的位置插入。0<=i<=l.size，理论上可以在任何存在数据的位置插入，以及在表的末尾插入数据。
			
		//设：插入位置为i,元素为X
		// 1. 从位置i开始后面的位置（包含i位置）上的元素后移一个位置
	    // 2. 将元素X 放入位置i
		// 3. 表长度 + 1
		int  i = 2 ;
		int  X = 9 ;
		//遍历顺序表
		queryArray(l);
		if(l.getSize() == l.MAXSIZE || i < 0 || i > l.getSize()){
			System.out.println(false+"不符合插入前提");
		}else{
			int j;
			for(j = l.getSize() ; j > i ; j--){
				l.getElement()[j] = l.getElement()[j-1];
			}
			l.getElement()[j] = X;
		}
		
		//遍历顺序表
		queryArray(l);
	}
	public void queryArray(SeqList1 array){
		for(int i = 0;i < array.getSize();i++){
			System.out.print(array.getElement()[i]+" ");
		}
		System.out.println();
	}
	//删除元素
	@Test
	public void testDelete(){
		//生成顺序表对象，并赋值
		SeqList1 l = new SeqList1();
		l.getElement()[0] = 0;
		l.getElement()[1] = 1;
		l.getElement()[2] = 2;
		l.getElement()[3] = 3;
		l.getElement()[4] = 4;
		l.getElement()[5] = 5;
		
		//前提1.表不为空
		//前提2.合理的删除范围 0<=i<l.size
		 
		//设：删除的元素位置为i
		// 1.取出位置为i的元素
		// 2.将位置i之后位置上的元素向前移动一个位置
		// 3.表长度-1
		
		int i = 3;
		int x = 0;
		//遍历顺序表
			queryArray(l);
		if(l.getSize() == 0 || i < 0 || i >=l.getSize()){
			System.out.println(false+"不符合插入前提");
		}else{
			x = l.getElement()[i];
			int j;
			for(j = i;j<l.getSize();j++){
				l.getElement()[j] = l.getElement()[j+1];
			}
			l.getElement()[j] = -1;
		}
		System.out.println(x);
		//遍历顺序表
			queryArray(l);
	}
	//此处列举插入和删除，其他顺序表的算法在SeqList1类中作为类方法。
}

 最后是算法的复杂度分析：直接贴教材，有兴趣的朋友可以打印下用时来验证下，算法的复杂度问题，后面会详细分析。