数据结构学习之:数组

定义

数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按无序的形式组织起来的一种形式。 这些无序排列的同类数据元素的集合称为数组。

特点

  • 数组是一块连续的内存空间,以下标来描述空间的位置。下标从0开始,最大下标为数组长度-1,数组中的元素存储在一个连续性的内存块中,并通过索引来访问;
  • 数组的元素都是变量,变量的类型为定义数组时的类型。数组中的所有元素都具有相同类型;
  • 数组创建后会对每个元素进行初始化。int初始化为0 、double初始化为0.0、 引用类型初始化为null;
  • 数组创建后,不能改变。

java实现数组

  • 简单数组

     /**
      * 1) 数组的插入、删除、按照下标随机访问操作;
      * 2)数组中的数据是int类型的;
      *
      * Author: Zheng
      * modify: xing, Gsealy
      */
     public class Array {
         //定义整型数据data保存数据
         public int data[];
         //定义数组长度
         private int n;
         //定义中实际个数
         private int count;
     
         //构造方法,定义数组大小
         public Array(int capacity){
             this.data = new int[capacity];
             this.n = capacity;
             this.count=0;//一开始一个数都没有存所以为0
         }
     
         //根据索引,找到数据中的元素并返回
         public int find(int index){
             if (index<0 || index>=count) return -1;
             return data[index];
         }
     
         //插入元素:头部插入,尾部插入
         public boolean insert(int index, int value){
             //数组中无元素 
     
             //if (index == count && count == 0) {
             //    data[index] = value;
             //    ++count;
             //    return true;
             //}
     
             // 数组空间已满
             if (count == n) {
                 System.out.println("没有可插入的位置");
                 return false;
             }
             // 如果count还没满,那么就可以插入数据到数组中
             // 位置不合法
             if (index < 0||index > count ) {
                 System.out.println("位置不合法");
                 return false;
             }
             // 位置合法
             for( int i = count; i > index; --i){
                 data[i] = data[i - 1];
             }
             data[index] = value;
             ++count;
             return true;
         }
         //根据索引,删除数组中元素
         public boolean delete(int index){
             if (index<0 || index >=count) return false;
             //从删除位置开始,将后面的元素向前移动一位
             for (int i=index+1; i<count; ++i){
                 data[i-1] = data[i];
             }
             //删除数组末尾元素  这段代码不需要也可以
             /*int[] arr = new int[count-1];
             for (int i=0; i<count-1;i++){
                 arr[i] = data[i];
             }
             this.data = arr;*/
     
             --count;
             return true;
         }
         public void printAll() {
             for (int i = 0; i < count; ++i) {
                 System.out.print(data[i] + " ");
             }
             System.out.println();
         }
     
         public static void main(String[] args) {
             Array array = new Array(5);
             array.printAll();
             array.insert(0, 3);
             array.insert(0, 4);
             array.insert(1, 5);
             array.insert(3, 9);
             array.insert(3, 10);
             //array.insert(3, 11);
             array.printAll();
         }
     }
    
  • 可扩容数组

     public class GenericArray<T> {
         private T[] data;
         private int size;
     
         // 根据传入容量,构造Array
         public GenericArray(int capacity) {
             data = (T[]) new Object[capacity];
             size = 0;
         }
     
         // 无参构造方法,默认数组容量为10
         public GenericArray() {
             this(10);
         }
     
         // 获取数组容量
         public int getCapacity() {
             return data.length;
         }
     
         // 获取当前元素个数
         public int count() {
             return size;
         }
     
         // 判断数组是否为空
         public boolean isEmpty() {
             return size == 0;
         }
     
         // 修改 index 位置的元素
         public void set(int index, T e) {
             checkIndex(index);
             data[index] = e;
         }
     
         // 获取对应 index 位置的元素
         public T get(int index) {
             checkIndex(index);
             return data[index];
         }
     
         // 查看数组是否包含元素e
         public boolean contains(T e) {
             for (int i = 0; i < size; i++) {
                 if (data[i].equals(e)) {
                     return true;
                 }
             }
             return false;
         }
     
         // 获取对应元素的下标, 未找到,返回 -1
         public int find(T e) {
             for ( int i = 0; i < size; i++) {
                 if (data[i].equals(e)) {
                     return i;
                 }
             }
             return -1;
         }
     
     
         // 在 index 位置,插入元素e, 时间复杂度 O(m+n)
         public void add(int index, T e) {
             checkIndex(index);
             // 如果当前元素个数等于数组容量,则将数组扩容为原来的2倍
             if (size == data.length) {
                 resize(2 * data.length);
             }
     
             for (int i = size - 1; i >= index; i--) {
                 data[i + 1] = data[i];
             }
             data[index] = e;
             size++;
         }
     
         // 向数组头插入元素
         public void addFirst(T e) {
             add(0, e);
         }
     
         // 向数组尾插入元素
         public void addLast(T e) {
             add(size, e);
         }
     
         // 删除 index 位置的元素,并返回
         public T remove(int index) {
             checkIndexForRemove(index);
     
             T ret = data[index];
             for (int i = index + 1; i < size; i++) {
                 data[i - 1] = data[i];
             }
             size --;
             data[size] = null;
     
             // 缩容
             if (size == data.length / 4 && data.length / 2 != 0) {
                 resize(data.length / 2);
             }
     
             return ret;
         }
     
         // 删除第一个元素
         public T removeFirst() {
             return remove(0);
         }
     
         // 删除末尾元素
         public T removeLast() {
             return remove(size - 1);
         }
     
         // 从数组中删除指定元素
         public void removeElement(T e) {
             int index = find(e);
             if (index != -1) {
                 remove(index);
             }
         }
     
         @Override
         public String toString() {
             StringBuilder builder = new StringBuilder();
             builder.append(String.format("Array size = %d, capacity = %d \n", size, data.length));
             builder.append('[');
             for (int i = 0; i < size; i++) {
                 builder.append(data[i]);
                 if (i != size - 1) {
                     builder.append(", ");
                 }
             }
             builder.append(']');
             return builder.toString();
         }
     
     
         // 扩容方法,时间复杂度 O(n)
         private void resize(int capacity) {
             T[] newData = (T[]) new Object[capacity];
     
             for (int i = 0; i < size; i++) {
                 newData[i] = data[i];
             }
             data = newData;
         }
     
         private void checkIndex(int index) {
             if (index < 0 || index > size) {
                 throw new IllegalArgumentException("Add failed! Require index >=0 and index <= size.");
             }
         }
     
         private void checkIndexForRemove(int index) {
             if(index < 0 || index >= size) {
                 throw new IllegalArgumentException("remove failed! Require index >=0 and index < size.");
             }
         }
     }
    

算法实现可参考:https://github.com/wangzheng0822/algo

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值