数据结构之动态链表及其拓展

最新推荐文章于 2022-09-04 11:58:14 发布

VIP文章暖风吹起云

最新推荐文章于 2022-09-04 11:58:14 发布

阅读量326

点赞数

分类专栏：数据结构文章标签：数据结构链表 java

本文链接：https://blog.csdn.net/qq_42707739/article/details/103582320

版权

上一次我们自己实现了动态数组并且由list接口实现顺序表，顺序栈，循序队列，并根据顺序队列的缺点进行了优化实现了循环队列。
由于数组需要同时开辟大量空间，为了解决这个问题，今天我们来实现动态链表。
喜欢的小伙伴可以关注我哦！！！。

1.链表

1.链表定义
2.链表元素添加
3.链表元素删除
4.源码实现
5.链表测试

2.栈的链式存储结构

3.队列的链式存储结构
4.双端链栈

1.定义
2.实现

5.单向循环链表

1.单向循环链表的定义
2.添加元素
3.删除元素
4.单向循环链表源码
5.测试类

6.单向循环链表应用–约瑟夫环和升级约瑟夫环问题

1.约瑟夫环问题描述
2.代码实现
3.升级约瑟夫环问题描述
4.代码实现

7.魔术师发牌问题

1.问题描述
2.代码实现

一.链表

顾名思义，用链子连起来的表，前一个元素知道后一个连的元素，通过头元素可知道链表的所有元素。
那么我们定义一个结点，包含一个数据域data，和一个指针域，指针域指向下一个结点，在这里插入图片描述
结点相连，组成单链表。

其结点有真实头结点和虚拟头结点的区别，真实头结点：即头结点的数据域存储数据，而虚拟头结点的数据域不存储数据。

在虚拟头结点中，头指针仅仅是一个引用变量，存储头结点地址的指针而已。而尾指针是链表最后一个结点的指针
在这里插入图片描述
1.链表定义
链表的定义在实现list的基础上采用结点。

在链表中对结点进行定义，将结点的定义变成一个类中类，并为链表定义头结点，尾结点，以及记录链表中的元素个数size，

public class LinkedList<E> implements List<E>{
   
	private Node head;//头指针
	private Node rear;//尾指针
	private int size;//链表元素个数(结点个数)
	
	public LinkedList() {
   
		head = new Node();
		rear = head;
		size = 0;
	}
	
	private class Node{
   
		E data;
		Node next;
		Node(){
   
			this(null,null);
		}
		Node(E data,Node next){
   
			this.data = data;
			this.next = next;
		}
		@Override
		public String toString() {
   
			return data.toString();
		}
	}
	}

2.链表元素添加
在对元素插入时，有头插，，尾插，和一般插入，

1.进行头插时，将为该元素创建一个结点，将元素存储在该结点的数据域，将新结点指向头结点的下一个结点，将头结点指向新结点。

Node n =new Node();
		n.data=e;
		n.next = head.next;
			head.next = n;

2.在进行尾插时，同理，为该元素创建一个结点，将尾结点的指向该新结点，并将新结点变为尾结点。在插入第一个结点的时候操作是相同的。

		rear.next = n;
			rear = n;

3.进行一般插入时，需要先找到该结点的头一个结点，和下一个结点，将该结点指向下一个结点，它的头一个结点指向它，即完成添加。

			Node p = head;
			for(int i=0; i<size;i++) {
   
				p=p.next;			
			}
			n.next = p.next;
			p.next =n;

进行插入的方法如下：

public void add(int index, E e) {
   
		// TODO Auto-generated method stub
		if(index<0||index>size) {
   
			throw new IllegalArgumentException("角标越界");
		}
		Node n =new Node();
		n.data=e;
		if(isEmpty()) {
   
			head.next=n;
			rear=n;
		}else if(index==0){
   
			n.next = head.next;
			head.next = n;
		}else if(index==size){
   
			rear.next = n;
			rear = n;
		}else {
   
			Node p = head;
			for(int i=0; i<size;i++) {
   
				p=p.next;			
			}
			n.next = p.next;
			p.next =n;
		}
		size++;
	}

3.元素删除
元素删除，同样也包括头删，尾删，和一般删除，其实一般删除就包含了头删和尾删，但是一般删除需要遍历链表时间复杂度是O(n)，而指定头插和尾插的时间复杂度是O(1)，在链表元素多的情况下，可以有效减少操作。
1.头删，拿出头结点的下一个结点，将该结点的元素取出，使头结点指向头结点的下下一个元素。只有一个元素，头删和尾删是相同的，

	E ret = null;
	if(size == 1) {
   
			ret = rear.data;
			head.next = null;
			rear = head;
		}else if(index==0){
   
			Node del = head.next;
			ret = del.data;
			head.next = del.next;
			del.next = null;
			del = null;

2.尾删，拿出尾结点的元素，将尾结点的的前一个结点指向null，将尾结点指向它的前一个结点。

else if(index == size-1) {
   
			Node p = head;
			while(true) {
   
				if(p.next!=rear) {
   
					p = p.next;
				}else {
   
					break;
				}
			}
			ret = p.next.data;
			p.next = null;
			rear =p ;

3.一般插入，遍历找到该结点的前一个结点和后一个结点，取出该结点的元素，将该结点的前一个结点指向该结点的后一个结点。再断开该结点与后一个结点的联系。

else {
   
			Node p = head;
			for(int i=0; i<index ;i++) {
   
				p = p.next;
			}
			Node del = p.next;
			ret =del.data;
			p.next = del.next;
			del.next = null;
			del = null;//free(del)

删除结点，返回该结点元素实现如下：

public E remove(int index) {
   
		// TODO Auto-generated method stub
		if(isEmpty()) {
   
			throw new IllegalArgumentException("空表");
		}
		if(index<0||index>=size) {
   
			throw new IllegalArgumentException("角标越界");
		}
		E ret = null;
		if(size == 1) {
   
			ret = rear.data;
			head.next = null;
			rear = head;
		}else if(index==0){
   
			Node del = head.next;
			ret = del.data;
			head.next = del.next;
			del.next = null;
			del = null;
		}else if(index == size-1) {
   
			Node p = head;
			while(true) {
   
				if(p.next!=rear) {
   
					p = p.next;
				}else {
   
					break;
				}
			}
			ret = p.next.data;
			p.next = null;
			rear =p ;
		}else {
   
			Node p = head;
			for(int i=0; i<index ;i++) {
   
				p = p.next;
			}
			Node del = p.next;
			ret =del.data;
			p.next = del.next;
			del.next = null;
			del = null;//free(del)
		}
	size--;
	return ret;
	}

4.源码
其它的获取元素个数，判空，查找，返回元素就十分简单了，实现LinkedList code（基于继承前面写的接口实现：https://blog.csdn.net/qq_42707739/article/details/103475097）如下：

package DS02.动态链表;

import DS01.动态数组.List;

import java.util.Iterator;

//用动态链表实现的线性表 链表
public class LinkedList<E> implements List<E> {
   
    private Node head;  //链表的头指针(虚头结点)
    private Node rear;  //链表的尾指针
    private int size;   //链表的元素个数(结点个数)

    public LinkedList(){
   
        head=new Node();
        rear=head;
    }


    private class Node{
   
        E data;     //数据域
        Node next;  //指针域
        Node(){
   
            this(null,null);
        }
        Node(E data,Node next){
   
            this.data=data;
            this.next=next;
        }

        @Override
        public String toString() {
   
            return data.toString();
        }
    }


    @Override
    public int getSize() {
   
        return size;
    }

    @Override
    public boolean isEmpty() {
   
        return size==0&&head==rear;
    }

    @Override
    public void add(int index, E e) {
   
        if(index<0||index>size){
   
            throw new IllegalArgumentException("角标越界");
        }
        Node n=new Node();
        n.data=e;
        if(isEmpty()){
             //空表状态 特殊处理
            head.next=n;
            rear=n;
        }else if(index==0){
        //头插法
            n.next=head.next;
            head.next=n;
        }else if(index==size){
     //尾插法
            rear.next=n;
            rear=n;
        }else{
                     //中间插
            Node p=head;
            for(int i=0;i<index;i++){
   
                p=p.next;
            }
            n.next=p.next;
            p.next=n;
        }
        size++;
    }

    @Override
    public void addFirst(E e) {
   
        add(0,e);
    }

    @Override
    public void addLast(E e) {
   
        add(size,e);
    }

    @Override
    public E get(int index) {
   
        if(isEmpty()){
   
            throw new IllegalArgumentException("空表");
        }
        if(index<0||index>=size){
   
            throw new IllegalArgumentException("角标越界");
        }
        if(index=