JAVA数据结构与算法学习记录——线性表

*个人学习用，可能有错误！

线性表：每个元素通过唯一的一个前驱元素和后继元素连接而成的数据结构。

线性表常用两种存储结构（顺序存储结构、链式存储结构）。

区别：顺序表是在数组的基础上设置基本运行方法，链表是构造一个链表类并在内部设置方法。

顺序存储

顺序表

class spListClass{
	final int inCapacity=10;
	int [] data;
	int capacity;
	int size;//实际容量
	//创建初始化为10的线性表
	public spListClass() {
		data=new int [inCapacity];
		capacity=inCapacity;
		size=0;
	}
	
	//创建一个指定容量大小的线性表、
	public spListClass(int capacity) {
		this.capacity=capacity;
		data=new int[capacity];
		}
						//基本算法
	
	//构建一个更新顺序表的方法
	public void updateCapacity(int newCapacity){
		 int [] newData=new int[newCapacity];
		 for(int i=0;i<size;i++) {
			 newData[i]=data[i];
		 }
		 data=newData;
		 capacity=newCapacity;
	
	}
	
	//由数组a建立线性表的相应存储结构、
	public void createList(int[] arr ) {
		//判断数组大小是否合法、若大于capacity则扩大2倍data数组
		while(arr.length>capacity) {
			capacity=capacity*2;
			updateCapacity(capacity);
		}
		
		if(arr.length==0) {
			System.out.println("数组大小不合法");
		}
		
		for(int i=0;i<arr.length;i++) {
			data[i]=arr[i];
		}
		size=arr.length;

	}
	
	//将元素e添加到线性表末尾、
	public void  Add(int e) {
		//判断顺序表是否已满  size=capacity、
		if(size==capacity) {
			updateCapacity(2*capacity);
		}
		data[size]=e;
		size++;
	}
	
	//求线性表的长度 、
	public int Size() {
		return size;
	}
	
	//设置线性表的长度为nlen、
	public void setSize(int nlen) {
	//判断nlen是否合法、
		if(nlen==0||nlen>capacity) {
			throw new IllegalArgumentException("参数范围错误");
		}
		size=nlen;
		}
	
	// 求线性表中序号为i的元素
	public int getElem(int i) {
		if(i>size) {
			throw new IllegalArgumentException("参数范围错误");
		}
		return data[i-1];
	}
	
	//设置线性表中序号为i的元素为e、
	public void setElem(int i,int e) {
		if(i>size-1) {
			throw new IllegalArgumentException("参数范围错误");
		}
		data[i-1]=e;
	}
	
	//求线性表中第一个值为e、的元素的序号、没有则返回-1、
	public int getNo(int e) {
		int count=-1;
		for(int i=0;i<size;i++) {
			count++;
			if(data[i]==e) {
				break;
			}
		}
		return count;
	}
	
	//交换线性表中序号i和序号为j的元素、
	public void swap(int i,int j) {
		int temp=data[i-1];
		data[i-1]=data[j-1];
		data[j-1]=temp;
	}
	
	//在线性表中插入元素e作为第i个元素、
	public void insert(int i,int e) {
		//判断数组是否还有空位、
		i=i-1;
		if(size==capacity) {
			updateCapacity(2*capacity);
		}
		for(int j=size;j>=i;j--) {
			data[j+1]=data[j];
		}
		data[i]=e;
		size++;
	}
	
	//在线性表中删除第i个数据元、
	public void delete(int i) {
		i=i-1;
		for(int j=i;j<size;j++) {
			data[j]=data[j+1];
		}
		size--;
	}
	
	//将线性表转化为字符串、
	public String toString() {
		String S="";
		for(int i=0;i<size;i++) {
			S=S+data[i]+" ";
		}
		return S;
	}
}

 顺序表优点：因为基于数组，可以得到指点每个元素。

链式存储

链表是什么？

链表是一种线性表的储存结构，可以通过构造链表类存储。

单链表

节点类

//构建节点类

class linkNode(){

        int data//存储数据，任何类型都可以

        linkNode next;//后继节点

        public linkNode(){

        

        }

        public linkNode(int data){

        this.data=data;

}

        //重构toString 方法

        public String toString(){

        String S=data+"";

        return S;

}

}

构建链表类

class linkListClass{
	
	//构造头节点
	linkNode head=new linkNode();
	
	//用尾差法创建链表、
	public void createListR(int arr[]) {
		linkNode temp=head;
		//头节点不能动，用临时变量temp、
		for(int i=0;i<arr.length;i++) {
			linkNode S=new linkNode(arr[i]);
			temp.next=S;
			temp=S;
		}
		//尾节点后面的next为null、
		temp.next=null;
	}
	
	//获取链表大小Size、、链表通过遍历实现、
	public int Size() {
		linkNode temp=head;
		int count=0;
		while(temp.next!=null) {
			count++;
			temp=temp.next;
		}
		return count;
	}
	
	//得到链表中指定节点、
	public linkNode getNode(int i) {
		linkNode temp=head;
		for(int j=0;j<i;j++) {
			temp=temp.next;
		}
		return temp;
	}
	
	//删除链表中指定的节点、、
	public void delete(int i) {
		if(i==0&&i>Size()) {
			throw new  IllegalArgumentException("错误，i参数范围错误");
		}
		
		linkNode temp=getNode(i-1);
		temp.next=temp.next.next;
	}
	
	//在链表中的指定位置后面插入节点、
	public void insert(int i,linkNode temp) {
		
		linkNode prior=getNode(i);
		linkNode later=getNode(i+1);
		
		prior.next=temp;
		temp.next=later;
	}
	
	//展示链表、
	public String display() {
		String S="";
		linkNode temp=head;
		while(temp.next!=null) {
			temp=temp.next; 
			S=S+temp.toString()+" "; 
		}
		return S;
	}
	
	
}

双链表

节点类中多加一个前驱节点prior

class linkNode{
    int data;
    linkNode prior;
    linkNode next;
    public linkNode(){
}

    public linkNode(int data){
    this.data=data;
    }
}

lass linkListClass{
    //构造一个头节点
    linkNode head=new linkNode();
    
    //根据数组a[]建立一个双节点
    public void createList(int [] a){
     linkNode temp=head;
    for(int i=0;i<a.length;i++){
    linkNode s=new linkNode(a[i]);
    temp.next=s;
    s.prior=temp;
    temp=s;
}
    temp.next=null;
    } 

    //获取指点节点
    public linkNode getNode(int i){
    linkNode temp=head;
    for (int j=0;j<i;j++){
    temp=temp.next;
    }
    return temp;
}

    //在第i个节点后插入一个新节点
    public void insert(int i){
    linkNode temp=new linkNode();
    linkNode t1=getNode(i);
    linkNode t2=getNode(i+1);
    t1.next=temp;
    temp.prior=t1;
    t2.prior=temp;
    temp.next=t2;
    }   

    //删除第n个节点
    public void delete(int n){
    linkNode t1=getNode(n-1);
    linkNode t2=getNode(n+1);
    t1.next=t1.next.next;
    t2.prior=t2.prior.prior;
}
   //重构toString方法
    public String toString() {
    	String S="";
    	linkNode temp=head;
    	while(temp.next!=null) {
    		S=S+" ";
    	}
    	return S;
    }

}