数据结构之顺序表（数组实现与链表实现）

最新推荐文章于 2024-04-06 16:41:23 发布

xiaoyuxianshenging

最新推荐文章于 2024-04-06 16:41:23 发布

阅读量464

点赞数 1

分类专栏：数据结构

本文链接：https://blog.csdn.net/xiaoyuxianshenging/article/details/78254144

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

数组实现：

package ArrayListTest;
//线性表之数组描述
public interface LinearList<T> {

	//线性表的主要操作
	
	//判断线性表是否为空
	public boolean isEmpty();
	//判断线性表的大小
	public int size();
	//通过一个索引查找此元素
	public Object get(int index);
	//通过给定元素获得此索引
	public int index(T element);
	//按给定索引插入一个新元素
	public void insert(int index,T element);
	//按给定索引删除一个元素
	public void delete(int index);
	//清空线性表
	public void clear();
	//返回顺序表中要查找元素第一次出现该元素的索引
	public int indexOf(T element);
	//返回顺序表中所有元素
	public String toString();
}

package ArrayListTest;


public class ArrayListImplementsLinearList<T> implements LinearList<T>{

	private int DEFAULT_SIZE = 16;
	//对象数组
	private Object[] slist;
	//保存顺序表中元素的当前个数  
	private int size = 0;

	//创造一个默认构造函数，并给数组一个定值
	public ArrayListImplementsLinearList(){
		slist = new Object[DEFAULT_SIZE];
	}
	//创建容量为size的空表
	public ArrayListImplementsLinearList(int size) {
		this();
		this.slist = new Object[size];
		this.size = 0;
	}

	//判断线性表是否为空
	public boolean isEmpty() {
		if(size == 0){
			return true;
		}
		return false;
	}

	//返回线性表的长度
	public int size() {
		
		return size;
	}

	//通过一个索引查找此元素
	public Object get(int index) {
		//先判断索引是否超过原数组索引
		if(index <= size-1||index >= 0){
			return this.slist[index];
		}
		return null;
	}

	//通过给定元素获得此索引
	public int index(T element) {
		//循环遍历数组中是否包含此元素，并将该元素的索引返回
		for(int i = 0;i<this.size;i++){
			if(this.slist[i].equals(element)){
				return i;
			}
		}
		return -1;
	}

	//按给定索引插入一个新元素
	public void insert(int index, T element) {
		if(index < 0 || index > size){
			System.out.println("插入的索引有误！");
		}
		//若数组满，并在原来数组长度的基础上扩容2倍。
		if(this.size==slist.length){
			//需要创建一个数组，用来存放原数组中的内容
			Object[] temp = this.slist;
			//再创建一个数组长度是以前两倍的新数组
			this.slist = new Object[temp.length*2];
			//将原来数组中的内容复制到新的数组中
			for(int i = 0;i<temp.length;i++){
				this.slist[i] = temp[i];
			}
		}
		//因为插入元素操作，会将你插入的元素位置后的所有元素都向后移位
		for(int j = this.size-1;j>=index;j--){
			this.slist[j+1] = this.slist[j];
		}
		this.slist[index] = element;
		size++;
		
	}

	//按给定索引删除一个元素
	//此方法与插入方法相逆,元素向前移
	public void delete(int index) {
		if(index < 0 || index > size){
			System.out.println("删除的索引有误！");
		}
		for(int j = index;j<size-1;j++){
			this.slist[j] = this.slist[j+1];
		}
		this.slist[size-1] = null;
		size--;
	}

	//清空线性表
	public void clear() {
		
		this.size = 0;
		this.slist=null;
	}
	//返回顺序表中要查找元素第一次出现该元素的索引
	public int indexOf(T element){
		if(element == null){
			return -1;
		}
		for(int i = 0;i<this.size-1;i++){
			if(this.slist[i].equals(element)){
				return i;
			}
		}
		return -1;
	}
	//返回顺序表中所有元素
	public String toString(){
		String str = "(";
		if(size > 0)
			str += (String) this.slist[0];
		for(int i = 1;i<size;i++){
			str += "," + (String) this.slist[i];
		}
		
		return str + ")";
	}
	public static void main(String[] args){
		ArrayListImplementsLinearList<String> al = new ArrayListImplementsLinearList<String>(16);
		
		System.out.println("al is empty:" + al.toString());
		Object[] array = {12, 34, 56, 2, 3};
		for(int j = 0;j<array.length;j++){
			al.insert(j, array[j].toString());
		}
		System.out.println(al.toString());
		int i = al.size();
		System.out.println(i);
		al.delete(1);
		System.out.println(al.toString());
		al.insert(2, "44");
		System.out.println(al.toString());
	}

}

链表实现（单链表）：

package LinkedListTest;

import org.junit.Test;

import LinkedListTest.LinkedListAlone.Node;

//线性表之链表---单链表Java实现
//单链表：
//创建空链表
//创建带有元素的链表
//返回链表的长度
//判断链表是否为空
//往头部插入和尾部插入
//根据索引查找链表节点
//根据索引往链表插入一个元素
//根据索引查找链表中元素
//根据查找元素得到其索引
//删除指定索引处的元素
//清除线型表
//打印线型表
public class LinkedListAlone<T> {
	//定义一个内部类Node，代表链接的节点
	public class Node{
		private T data;
		private Node next;
		//无参构造函数
		public Node(){
			
		}
		//有参数的构造函数
		public Node(T data,Node next){
			this.data = data;
			this.next = next;
		}
	}

	private Node header;//保存头节点
	private Node tail;//保存尾节点
	private int size;//保存已有的节点数
	
	//创建空链表
	public LinkedListAlone(){
		header = null;
		tail = null;
	}
	//创建一个带有数据的链表
	public LinkedListAlone(T element){
		header = new Node(element, null); 
		tail = header;
		size++;
	}
	//返回链表的长度
	public int length(){
		return size;
	}
	//判断链表是否为空
	public boolean isEmpty(){
		return size == 0;
	}
	//头部插入
	public void addHeader(T element){
		Node newHeader = new Node(element,null);
		newHeader.next = header;
		header = newHeader;
		//如果插入前为空链表
		if(tail == null){
			tail = header;
		}
		size++;
	}
	//尾部插入
	public void add(T element){
		//先判断一下是否为空链表
		if(header == null){
			Node header = new Node(element,null);
			tail = header;
		}else{
			//该链表不为空
			Node newNode = new Node(element,null);
			//尾节点指向新节点
			tail.next = newNode;
			//使新节点作为尾节点
			tail = newNode;
		}
		size++;
	}
	//根据索引查找链表节点
	public Node getNodeByIndex(int index){
		if(index < 0&&index > size-1){
			throw new IndexOutOfBoundsException("索引超出线性表范围");
		}
		//从header开始遍历
		Node current = header;
		for(int i = 0;i<size && current!=null;i++,current=current.next){
			if(i == index){
				return current;
			}
		}
		return null;
	}
	//根据索引往链表插入一个元素
	public void insert(T element,int index){
		//判断索引范围是否正确
		if(index < 0&&index > size-1){
			throw new IndexOutOfBoundsException("索引超出线性表范围");
		}else{
			//如果是空链表
			if(0 == index){
				addHeader(element);
			}else{
				//插入一个新的节点，需要找到该节点的前一个节点，将这个节点的指针指向新插入的节点上
				Node upNode = getNodeByIndex(index - 1);
				Node newHeader = new Node(element,upNode.next);
				upNode.next = newHeader;
				size++;
			}
		}
	}
	//根据索引查找链表中元素
	public T get(int index){
		return getNodeByIndex(index).data;
	}
	//根据查找元素得到其索引
	public int getValueOfIndex(T element){
		Node current = header;
		for(int i = 0;i<size && current!=null;i++,current=current.next){
			if(current.data.equals(element)){
				return i;
			}
		}
		return 0;
	}
	//删除指定索引处的元素
	public void delete(int index){
		if(index < 0&&index > size-1){
			throw new IndexOutOfBoundsException("索引超出线性表范围");
		}else{
			Node del = null;
			if(0 == index){
				//删除的是头节点
				del = header;
				header = header.next;
			}else{
				//删除的不是头节点
				//获得要删除的节点的上一个节点
				Node upNode = getNodeByIndex(index - 1);
				del = upNode.next;
				upNode.next = del.next;
				del.next = null;
			}
			size--;
		}
	}
	//清除线型表
	public void clear(){  
        //将header,tail置为null  
        header = null;  
        tail = null;  
        size = 0;  
    }
	//打印线型表
	public String toString(){ 
		if(isEmpty()){
			return "[]";
		}else{
			StringBuilder sb = new StringBuilder("[");  
            for(Node current = header; current != null; current = current.next){  
                sb.append(current.data.toString() + ",");  
            }  
               
            int len = sb.length();  
               
            return sb.delete(len-1, len).append("]").toString();  
		}
	}
	
	//测试类
	public static void main(String[] args){
		// 测试构造函数  
		LinkedListAlone<String> list = new LinkedListAlone("好");  
        System.out.println(list); 
        // 测试添加元素  
        list.add("ni");  
        list.add("没");  
        System.out.println(list);
        // 在头部添加  
        list.addHeader("五月");  
        System.out.println(list);
        // 在指定位置添加  
        list.insert("摩卡", 2);  
        System.out.println(list); 
        // 获取指定位置处的元素  
        System.out.println("第2个元素是（从0开始计数）：" + list.get(2));
        // 返回元素索引  
        System.out.println("摩卡在的位置是：" + list.getValueOfIndex("摩卡"));
        // 获取长度  
        System.out.println("当前线性表的长度：" + list.length());  
   
        // 判断是否为空  
        System.out.println(list.isEmpty());
        // 删除指定位置处元素  
        list.delete(3);  
        System.out.println("删除第4个元素后：" + list);
        // 清空  
        list.clear();  
        System.out.println(list); 
	}
}

双链表：

package LinkedListTest;

import LinkedListTest.LinkedListAlone.Node;

//线性表之链表---双向链表Java实现
//双向链表：
//创建空链表
//创建带有元素的链表
//返回链表的长度
//判断链表是否为空
//往头部插入和尾部插入
//根据索引查找链表节点
//根据索引往链表插入一个元素
//根据索引查找链表中元素
//根据查找元素得到其索引
//删除指定索引处的元素
//清除线型表
//打印线型表
public class LinkedListDouble<T> {
	//定义一个内部类Node，代表链接的节点
	public class Node{
		private T data;
		private Node prev;
		private Node next;
		//无参构造函数
		public Node(){
			
		}
		//有参数的构造函数
		public Node(T data,Node prev,Node next){
			this.data = data;
			this.prev = prev;
			this.next = next;
		}
	}

	private Node header;//保存头节点
	private Node tail;//保存尾节点
	private int size;//保存已有的节点数
	
	//创建空链表
	public LinkedListDouble(){
		header = null;
		tail = null;
	}
	//创建一个带有数据的链表
	public LinkedListDouble(T element){
		header = new Node(element,tail.next,null); 
		tail = new Node(element,header.next,null);
		size++;
	}
	//返回链表的长度
	public int length(){
		return size;
	}
	//判断链表是否为空
	public boolean isEmpty(){
		return size == 0;
	}
	//头部插入
	public void addHeader(T element){
		Node newHeader = new Node(element,null,header);
		header.prev = newHeader;
		header = newHeader;
		//如果插入前为空链表
		if(tail == null){
			tail = header;
		}
		size++;
	}
	//尾部插入
	public void add(T element){
		//先判断一下是否为空链表
		if(header == null){
			Node header = new Node(element,null,null);
			tail = header;
		}else{
			//该链表不为空
			Node newNode = new Node(element,tail,null);
			//尾节点指向新节点
			tail.next = newNode;
			//使新节点作为尾节点
			tail = newNode;
		}
		size++;
	}
	//根据索引查找链表节点
	public Node getNodeByIndex(int index){
		if(index < 0&&index > size-1){
			throw new IndexOutOfBoundsException("索引超出线性表范围");
		}
		if(index < size/2){
			//从header开始遍历
			Node current = header;
			for(int i = 0;i<size/2 && current!=null;i++,current=current.next){
				if(i == index){
					return current;
				}
			}
		}else{
			//从tail开始遍历
			Node current = tail;
			for(int i = size-1;i>=size/2 && current!=null;i--,current=current.prev){
				if(i == index){
					return current;
				}
			}
		}
		return null;
	}
	//根据索引往链表插入一个元素
	public void insert(T element,int index){
		//判断索引范围是否正确
		if(index < 0&&index > size-1){
			throw new IndexOutOfBoundsException("索引超出线性表范围");
		}else{
			//如果是空链表
			if(0 == index){
				addHeader(element);
			}else{
				//插入一个新的节点，需要找到该节点的前一个节点，将这个节点的指针指向新插入的节点上

				Node upNode = getNodeByIndex(index - 1);
				//待插入索引处节点
				Node insertNode = upNode.next;
				Node newHeader = new Node(element,upNode.next,insertNode.prev);
				upNode.next = newHeader;
				insertNode.prev = newHeader;
				size++;
			}
		}
	}
	//根据索引查找链表中元素
	public T get(int index){
		return getNodeByIndex(index).data;
	}
	//根据查找元素得到其索引
	public int getValueOfIndex(T element){
		Node current = header;
		for(int i = 0;i<size && current!=null;i++,current=current.next){
			if(current.data.equals(element)){
				return i;
			}
		}
		return 0;
	}
	//删除指定索引处的元素
	public void delete(int index){
		if(index < 0&&index > size-1){
			throw new IndexOutOfBoundsException("索引超出线性表范围");
		}else{
			Node del = null;
			if(0 == index){
				//删除的是头节点
				del = header;
				header = header.next;
			}else{
				//删除的不是头节点
				//获得要删除的节点的上一个节点
				//在此判断删除的节点是否是尾节点
				Node upNode = getNodeByIndex(index - 1);
				del = upNode.next;
				if(del.next!=null){
					//删除的节点不是尾节点
					del.next.prev = upNode.next;
					upNode.next = del.next;
				}else{
					tail = upNode;
					del.prev = null;
					del.next = null;
				}
			}
			size--;
		}
	}
	//清除线型表
	public void clear(){  
        //将header,tail置为null  
        header = null;  
        tail = null;  
        size = 0;  
    }
	//打印线型表
	public String toString(){ 
		if(isEmpty()){
			return "[]";
		}else{
			StringBuilder sb = new StringBuilder("[");  
            for(Node current = header; current != null; current = current.next){  
                sb.append(current.data.toString() + ",");  
            }  
               
            int len = sb.length();  
               
            return sb.delete(len-1, len).append("]").toString();  
		}
	}
	
	//测试类
	public static void main(String[] args){
		// 测试构造函数  
		LinkedListAlone<String> list = new LinkedListAlone("好");  
        System.out.println(list); 
        // 测试添加元素  
        list.add("ni");  
        list.add("没");  
        System.out.println(list);
        // 在头部添加  
        list.addHeader("五月");  
        System.out.println(list);
        // 在指定位置添加  
        list.insert("摩卡", 2);  
        System.out.println(list); 
        // 获取指定位置处的元素  
        System.out.println("第2个元素是（从0开始计数）：" + list.get(2));
        // 返回元素索引  
        System.out.println("摩卡在的位置是：" + list.getValueOfIndex("摩卡"));
        // 获取长度  
        System.out.println("当前线性表的长度：" + list.length());  
   
        // 判断是否为空  
        System.out.println(list.isEmpty());
        // 删除指定位置处元素  
        list.delete(3);  
        System.out.println("删除第4个元素后：" + list);
        // 清空  
        list.clear();  
        System.out.println(list); 
	}
}