美文网首页
数据结构与算法学习-数组

数据结构与算法学习-数组

作者: Kip_Salens | 来源:发表于2018-11-29 11:21 被阅读0次

    1. 概念

    学习数据结构一般都是从数组开始,以为相对来说简单,而且也最常用。

    Array

    数组是我们在编程中最常用的数据结构,它是线性的数据结构,即在内存中是连续的,所以可以很方便的进行遍历,只要有首地址,就可以根据角标计算出所要拿到的元素的地址:

    arr[i] = arr[0] + K * i;

    K是一个元素所占的字节数,例如在java中,一个 int 元素占有 4 个字节;

    实际上,学到 c 语言的知道,数组也是指针,意思是数组元素的首地址对应于指针。在java中虽然没有指针,但是使用的引用,底层应该也是指针。同时 java 中提供了很多的数据结构,ArrayList 比较常见,是对数组的一种封装,而且提供了很多方法,开发中我们一般直接使用 ArrayList,不使用数组。但是在有些场景下,使用数组会更加高效,对于这两种的选择可以参考下面的几点:

      1. Java ArrayList 无法存储基本类型,比如 int、long,需要封装为 Integer、Long 类,而 Autoboxing、Unboxing 则有一定的性能消耗,所以如果特别关注性能,或者希望使用基本类型,就可以选用数组。
      1. 如果数据大小事先已知,并且对数据的操作非常简单,用不到 ArrayList 提供的大部分方法,也可以直接使用数组。
      1. 当要表示多维数组时,用数组往往会更加直观(个人观点)。比如 Object[][] array;而用容器的话则需要这样定义:ArrayList<ArrayList > array。

    总结一下,对于业务开发,直接使用容器就足够,省时省力。毕竟损耗一些性能,完全不会影响到系统整体的性能。但如果你是做一些非常底层的开发,比如开发网络框架,性能优化需要做到极致,这个时候数组就会优于容器,成为首选。

    2. ArrayList

    在 java 中既然是最常用的,那么也需要了解下其原理,自己动手练习一下。最基本 的也就是增删改查这些方法,再加上它的一些特性,动态扩容,迭代器等。下面我们就来练习一下。

    定义 接口:

    
    public interface RList<T> {
    
        int size();
    
        boolean isEmpty();
    
        boolean contains(T o);
    
        T[] toArray();
    
        boolean add(T o);
    
        boolean remove(T o);
    
        void clear();
    
        T get(int index);
    
        T set(int index, T element);
    
        void add(int index, T element);
    
        T removeByIndex(int index);
    
        int indexOf(T o);
    
        RIterator<T> iterator();
    }
    
    

    定义迭代器:

    
    public interface RIterator<T> {
    
        boolean hasNext();
    
        T next();
    }
    

    具体实现:

    
    public class RArrayList<T> implements RList<T> {
    
        private static final int DEFAULT_CAPACITY = 20;
    
        private T[] items;
        private int capacity;
        private int count;
    
        public RArrayList() {
            this(DEFAULT_CAPACITY);
        }
    
        @SuppressWarnings("unchecked")
        public RArrayList(int capacity) {
            this.capacity = capacity;
            Object[] objects = new Object[capacity];
            items = (T[]) objects;
        }
    
        @Override
        public int size() {
            return count;
        }
    
        @Override
        public boolean isEmpty() {
            return count < 1;
        }
    
        @Override
        public boolean contains(T o) {
            return indexOf(o) > -1;
        }
    
        @Override
        public T[] toArray() {
            if (isEmpty()) {
                return null;
            }
            @SuppressWarnings("unchecked")
            T[] arrayItems = (T[]) new Object[count];
            System.arraycopy(items, 0, arrayItems, 0, count);
            return arrayItems;
        }
    
    
        @Override
        public boolean add(T o) {
            ensureCapacity();
            items[count++] = o;
            return true;
        }
    
        @Override
        public boolean remove(T o) {
            if (isEmpty()) {
                return false;
            }
            int index = indexOf(o);
            if (index < 0) {
                return false;
            }
            for (int i = index; i < count - 1; i++) {
                items[i] = items[i + 1];
                count--;
            }
            return true;
        }
    
        @Override
        public void clear() {
            if (isEmpty()) {
                return;
            }
            for (int i = 0; i < count; i++) {
                items[i] = null;
            }
            count = 0;
        }
    
        @Override
        public T get(int index) {
            checkIndex(index);
            if (isEmpty()) {
                return null;
            }
            return items[index];
        }
    
        @Override
        public T set(int index, T element) {
            checkIndex(index);
            T oldItem = items[index];
            items[index] = element;
            return oldItem;
        }
    
        @Override
        public void add(int index, T element) {
            checkIndex(index);
            ensureCapacity();
            for (int i = count; i > index; i--) {
                items[i] = items[i-1];
            }
            items[index] = element;
            count++;
        }
    
        @Override
        public T removeByIndex(int index) {
            checkIndex(index);
            T oldItem = items[index];
            for (int i = index; i < count - 1; i++) {
                items[i] = items[i + 1];
            }
            items[count - 1] = null;
            count--;
            return oldItem;
        }
    
        @Override
        public int indexOf(T o) {
            if (isEmpty()) {
                return -1;
            }
            int index = -1;
            for (int i = 0; i < count; i++) {
                T item = items[i];
                if (Objects.equals(item, o)) {
                    index = i;
                    break;
                }
            }
            return index;
        }
    
        @SuppressWarnings("unchecked")
        private void ensureCapacity() {
            if (count == capacity) {
                capacity = capacity * 3 / 2;
                T[] newItems = (T[]) new Object[capacity];
                System.arraycopy(items, 0, newItems, 0, count);
                items = newItems;
            }
        }
    
        private void checkIndex(int index) {
            if (index < 0 || index >= capacity) {
                throw new IndexOutOfBoundsException("index is invalid");
            }
        }
    
        @Override
        public RIterator<T> iterator() {
            return new RArrayListIterator();
        }
    
        private class RArrayListIterator implements RIterator<T> {
    
            private int index = 0;
    
            RArrayListIterator() {
            }
    
            @Override
            public boolean hasNext() {
                return index < size();
            }
    
            @Override
            public T next() {
                if (hasNext()) {
                    return items[index++];
                }
                return null;
            }
        }
    }
    

    这样就自己简单实现了ArrayList,对于它的基本原理也有了一定的认识,之后再看看源码。这种数据结构也就掌握了,其实,最重要的还是学习源码中的思想,能够指引我们自己写代码的思路和方式。

    除了实现,还写了测试的代码,当然测试的代码测试的并不全面,可能还存在一定的漏洞,像边界部分的处理。

    
    public class RArrayListTest {
    
        RList<Integer> list;
    
        @Before
        public void init() {
            list = new RArrayList<>(10);
    
            for (int i = 0; i < 10; i++) {
                list.add(i);
            }
        }
    
        @Test
        public void size() {
            Assert.assertEquals(10, list.size());
        }
    
        @Test
        public void isEmpty() {
    
            Assert.assertFalse(list.isEmpty());
    
            RList<Integer> tempList = new RArrayList<>();
            Assert.assertTrue(tempList.isEmpty());
        }
    
        @Test
        public void contain() {
    
            Assert.assertTrue(list.contains(5));
            Assert.assertFalse(list.contains(10));
        }
    
        @Test
        public void toArray() {
            Object[] integers = list.toArray();
            Assert.assertEquals(10, integers.length);
    
            for (int i = 0; i < integers.length; i++) {
                Assert.assertEquals(i, integers[i]);
            }
        }
    
        @Test
        public void get() {
    
            for (int i = 0; i < list.size(); i++) {
                Assert.assertEquals(i, list.indexOf(i));
            }
    
            for (int i = 0; i < list.size(); i++) {
                Assert.assertEquals(i, list.get(i).intValue());
            }
    
        }
    
        @Test
        public void add() {
    
            Assert.assertTrue(list.add(10));
            Object[] integers = list.toArray();
            for (int i = 0; i < integers.length; i++) {
                Assert.assertEquals(i, integers[i]);
            }
            Assert.assertTrue(list.contains(10));
            Assert.assertEquals(11, list.size());
    
            list.add(3, 30);
            integers = list.toArray();
            for (int i = 0; i < integers.length; i++) {
                if (i == 3) {
                    Assert.assertEquals(30, integers[i]);
                } else if (i > 3) {
                    Assert.assertEquals(i - 1, integers[i]);
                } else {
                    Assert.assertEquals(i, integers[i]);
                }
            }
        }
    
        @Test
        public void remove() {
    
            for (int i = 0; i < 3; i++) {
                list.removeByIndex(0);
            }
    
            Assert.assertEquals(7, list.size());
    
            for (int i = 0; i < list.size(); i++) {
                Assert.assertEquals(i + 3, list.get(i).intValue());
            }
    
            Assert.assertTrue(list.remove(8));
            Assert.assertEquals(6, list.size());
            Assert.assertEquals(9, list.get(5).intValue());
        }
    
        @Test
        public void set() {
            for (int i = 0; i < list.size(); i++) {
                list.set(i, i + 1);
                Assert.assertEquals(i + 1, list.get(i).intValue());
            }
        }
    
        @Test
        public void clear() {
            list.clear();
            Assert.assertTrue(list.isEmpty());
        }
    
        @Test
        public void iterator() {
    
            RIterator<Integer> iterator = list.iterator();
            int i = 0;
            while (iterator.hasNext()) {
                Assert.assertEquals(i++, iterator.next().intValue());
            }
        }
    }
    
    

    以上就是对 ArrayList 的简单实现,另外也写了一部分的 C 代码的实现,C 代码部分没有实现迭代器等方法,主要实现了利用数组实现一个list,能够增删改查,能够扩容等操作。有兴趣的可以自己试试,模仿 vector。

    3. 参考代码

    Java 代码

    C 代码

    相关文章

      网友评论

          本文标题:数据结构与算法学习-数组

          本文链接:https://www.haomeiwen.com/subject/ezvxcqtx.html