数据结构与算法-动态数组和单向链表总结

实现链表添加删除操作统一

概述

在前文数据结构与算法-单链表中,我们实现了一个单链表,但是在添加和删除的结点操作中,我们需要特殊处理一个0索引结点,代码如下所示:

@Override
	public void add(int index, E element) {
		/*
		 * 最好:O(1)
		 * 最坏:O(n)
		 * 平均:O(n)
		 */
		rangeCheckForAdd(index);
		
		if (index == 0) {
			first = new Node<>(element, first);
		} else {
			Node<E> prev = node(index - 1);
			prev.next = new Node<>(element, prev.next);
		}
		size++;
	}

	@Override
	public E remove(int index) {
		/*
		 * 最好:O(1)
		 * 最坏:O(n)
		 * 平均:O(n)
		 */
		rangeCheck(index);
		
		Node<E> node = first;
		if (index == 0) {
			first = first.next;
		} else {
			Node<E> prev = node(index - 1);
			node = prev.next;
			prev.next = node.next;
		}
		size--;
		return node.element;
	}

解决方案

概述方案

增加一个虚拟头结点,实现代码的同步操作,从而统一所有结点的处理逻辑,增加虚拟头结点的单向链表如下图所示:

在这里插入图片描述

代码实现

如下所示,除了修改构造函数初始化以及简化add和remove的逻辑以外,别的接口完全不变

package com.study.singlelinkDemo;

/**
 * Created by Zsy on 2020/8/3.
 */
public class SingleLinkedList2<E> extends AbstractList<E> {

    private Node<E> first;

    private static class Node<E> {
        private E element;
        Node<E> next;

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }


    public SingleLinkedList2() {
        this.first = new Node<E>(null, null);
    }


    @Override
    public void clear() {
        this.first = null;
        size = 0;
    }

    @Override
    public E get(int index) {

        return findNode(index).element;
    }

    public Node<E> findNode(int index) {
        rangeCheck(index);
        Node<E> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    @Override
    public E set(int index, E element) {
        rangeCheck(index);
        Node<E> node = findNode(index);
        E oldNode = node.element;
        node.element = element;


        return oldNode;
    }

    @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);


        Node<E> preNode =index==0?first: findNode(index - 1);// 对index=0再执行减法导致的outboundException的处理

        preNode.next = new Node<E>(element, preNode.next);


        size++;

    }

    @Override
    public E remove(int index) {
        rangeCheck(index);
        Node<E> node = findNode(index);

        Node<E> preNode =index==0?first: findNode(index - 1);// 对index=0再执行减法导致的outboundException的处理
        preNode.next=node.next;
//        if (index == 0) {
//            first = first.next;
//        } else {
//            Node<E> preNode = findNode(index - 1);
//            preNode.next = node.next;
//        }
        size--;
        return node.element;
    }

    @Override
    public int indexOf(E element) {

        Node<E> node = first;
        if (element == null) {
            for (int i = 0; i < size; i++) {
                if (node == null) return i;
                node = node.next;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (element.equals(node.element))//防止空指针异常
                    return i;
                node = node.next;
            }
        }

        return ELEMENT_NOT_FOUND;
    }


    @Override
    public String toString() {
        Node<E> node = this.first;
        String statrStr = String.format("size: %d [", size);
        StringBuilder result = new StringBuilder();
        result.append(statrStr);
        for (int i = 0; i < size; i++) {
            if (i != 0) result.append(",");
            result.append(node.element);
            node = node.next;

        }
        result.append("]");
        return result.toString();
    }
}

添加虚拟节点实现链表的优劣

优点

简化操作

缺点

浪费内存

小结

复杂度分析注意事项

  1. 关于复杂度的分析,我们需要从:最好、最坏、平均复杂度三个角度进行分析
  2. 关于复杂度的n并不是循环的参数n,而是该算法的操作数据规模

动态数组和单向链表的复杂度分析

public E get(int index)// 获取对应位置的元素

动态数组的实现代码

由于的动态数组是顺序表,数组底层工作原理是编译器在编译时就把对应索引位置的地址算好了,所以访问任何索引位置的元素都只需要O(1)

 
 public E get(int index){
        return elements[index];
    }

单向链表的实现

最好:查找首元素,O(1)
最坏:查找尾元素,O(n)
平均:1+2+3…n=>O(n/2)=>O(n)

 @Override
    public E get(int index) {

        return findNode(index).element;
    }

public E set(int index,E element) // 修改对应位置的元素

动态数组的实现代码

和get同理,所以复杂度为O(1)

 public E set(int index,E element){
        rangeCheck(index);
        E oldElement=elements[index];
        elements[index]=element;
        return oldElement;
    }

单向链表的实现

最好:修改首元素,O(1)
最坏:修改尾元素,O(n)
平均:1+2+3…n=>O(n/2)=>O(n)

 @Override
    public E set(int index, E element) {
        rangeCheck(index);
        Node<E> node = findNode(index);
        E oldNode = node.element;
        node.element = element;


        return oldNode;
    }

public void add(int index, E element)// 在指定索引位置插入元素

动态数组的实现代码

最好:插入到size位置,O(1)
最坏:插入到O(1),O(n)
平均:1+2+3…n=>O(n/2)=>O(n)

public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacity(size + 1);
        for (int i = size - 1; i >= index; i--) {
            elements[i + 1] = elements[i];
        }
        elements[index] = element;
        size++;

    }

单向链表的实现

最好:插入到size位置,O(1)
最坏:插入到O(1),O(n)
平均:1+2+3…n=>O(n/2)=>O(n)

补充:有些书籍说单向链表插入的时间复杂度为O(1),这些书籍中说的O(1)指的是插入的那一刻的时间复杂度为O(1),因为单向链表添加的一瞬间不需要像动态数组那样挪动大量元素

 @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);


        if (index == 0) {
            first = new Node<E>(element, first);
        } else {
            Node<E> preNode = findNode(index - 1);
            preNode.next = new Node<E>(element, preNode.next);

        }
        size++;

    }

public E remove(int index)// 移除对应位置的元素

动态数组的实现代码

最好:O(1)
最坏:O(n)
平均:O(n)

  public E remove(int index){
        rangeCheck(index);
        E oldElement=elements[index];
        for (int i = index; i <size-1 ; i++) {
            elements[i]=elements[i+1];
        }
        elements[--size]=null;
        return oldElement;
    }

单向链表的实现

最好:O(1)
最坏:O(n)
平均:O(n)

 @Override
    public E remove(int index) {
        rangeCheck(index);
        Node<E> node = findNode(index);
        if (index == 0) {
            first = first.next;
        } else {
            Node<E> preNode = findNode(index - 1);
            preNode.next = node.next;
        }
        size--;
        return node.element;
    }

public void add(E element)// 将元素添加到线性表末尾

动态数组的实现代码

最好:添加到尾部O(1)
最坏:设计扩容的拷贝操作,O(n)
平均:这里平均的复杂度计算有两种理解:

   *  数学计算:扩容前设计操作次数就是1次,而扩容时的操作次数是n,可得计算机式子:1+1+1...+n=2n/n=>2=>O(1)
   * 均摊复杂度:这种理解适合那些连续多次复杂度较低的操作后,出现一次个别复杂度高的情况。使用均摊复杂度分析下方代码的方式也很简单,将扩容操作的复杂度平均给之前的复杂度低的清空,如下图所示:

在这里插入图片描述

    public void add(E element) {
        ensureCapacity(size + 1);
        add(size, element);

    }

单向链表的实现

最好:O(1)
最坏:O(n)
平均:O(n)

public void add(E element) {
		add(size, element);
	}

补充动态数组的缩容

概述

如果空间使用一段时间并扩容无数次且不进行缩容的话,会出现空间浪费的现象,所以我们需要对其进行缩容的操作

代码范例

private void trim() {

        int oldCapacity = elements.length;

        int newCapacity = oldCapacity >> 1;
        if (size > (newCapacity) || oldCapacity <= DEFAULT_CAPACITY) return;


        E[] newElements = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;

        System.out.println(oldCapacity + "缩容为" + newCapacity);
    }

注意事项

如果扩容的倍数和缩容倍数设计不合理的话会出现复杂度震荡,如:当size==capacity进行扩容一次,然后又移除一个元素,如此往复操作,导致在扩容缩容之间来回切换,使得复杂度增加。
建议:扩容时扩容为远容量的两倍,当元素只有原来的四分之一时进行缩小一半的容量的操作。读者可根据自己需求进行修改这些倍数。

1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构算法支撑。2.网上数据结构算法的课程不少,但存在两个问题:1)授课方式单一,大多是照着代码念一遍,数据结构算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了2)说是讲数据结构算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级 3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构算法, 除常用数据结构算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构算法。教程内容:本教程是使用Java来讲解数据结构算法,考虑到数据结构算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。学习目标:通过学习,学员能掌握主流数据结构算法的实现机制,开阔编程思路,提高优化程序的能力。
©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页