数据结构之（1）数组

最新推荐文章于 2020-02-29 20:12:00 发布

KasierYang

最新推荐文章于 2020-02-29 20:12:00 发布

阅读量617

点赞数

分类专栏：数据结构、算法

本文链接：https://blog.csdn.net/kasieryang/article/details/49760371

版权

数据结构、算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

背景

表现优秀程序，是选择合适的数据结构和优秀的算法的必然结果，作为一名务实、精进的程序员，对数据结构的学习，熟练，自然成了必要的课程。闲话不多说，程序中的数据结构，是与语言无关的，常见的数据结构有：

数组（静态数组、动态数组）、
线性表、链表（单向链表、双向链表、循环链表）
队列
堆
树（二叉树、查找树、平衡树、线索树、线索树）
在接下来的学习中，会对以上各种数据结构进行操作（add/get/delete），并简单的评估其效率（时空复杂度）；在本博客中，尽量精准到概念化、原理画、源码化，所以会有很多概念梳理，原理、源码分析，看到的大神勿喷；

开始

一数组的定义
数组是最简单的数据结构，根据定义方式有：
1.静态数组（Java中的，数组）
数组定义后，其开辟的内存空间大小已定，不能再追加元素

  int  []arr=new int[]{1,2,3,4};//静态初始化
  int []arr1=new  int [10];//动态初始化
  arr1[0]=1;
  arr1[1]=2;
  ....

2.动态数组（Java中的ArrayList）
ArrayList的本质还是数组，因为数组定义后，其开辟的内存空间大小已定，不能再追加元素；ArraList在数组的基础上，使用java.util.Arrays这个工具类，将数组扩容，再将原数组元素，复制到一个新数组；
我们看下面这个方法,ArrayList中add() corecode

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//原数组长度
        int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容后长度
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//返回扩容后的数组
    }

问题来了，那这个Arrays是如何实现，点开Arrays.copyOf(elementData, newCapacity);

 public static <T,U> T[] copyOf(U[] original, int newLength,  Class<? extends T[]> newType) {
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);//获得一个新数组
            //调用native的方法，native的方法是用c写的
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

之分别；根据数据是否有序，又分为：
1.无序数组：数据是没有规律的
2.有序数组；数据经过排序
数组的，add操作速度很快，为：o(1),但是查找和杀出比较慢，为：o(N)
二.数组元素的排序
定义：有数组，int [] arr=new int[]{95, 13, 88, 49, 12, 25, 84, 63, 73, 96, 70, 45, 38, 47, 53, 69, 81, 73, 33, 32},将数组按照由小到的顺序实现排序;
1冒泡排序
分析：将素组中元素，从左到右，一次两两比较大小，比较大的数字，交互到右边
然后在以此，重复N-1次；
代码实现：

    //冒泡排序实现2
    public  static  void bubbleSortImp(){
        int[] newArr = productArray(20);
        int size=newArr.length;
        int  temp;
        for(int  i=size-1;i>0;i--){//指定外层的，遍历
            for(int j=i;j>0;j--){//内层的，相邻数字比较，及当前位置的移动
                temp=newArr[i];
                if(newArr[i]<newArr[j-1]){
                    newArr[i]=newArr[j-1];
                    newArr[j-1]=temp;
                }
            }
        }

        StringBuffer buffer = new StringBuffer();
        buffer.append("NewArray:");
        buffer.append(Arrays.toString(newArr));
        System.out.println(buffer.toString());

    }
结果：
测试数组：OldArray:[95, 13, 88, 49, 12, 25, 84, 63, 73, 96, 70, 45, 38, 47, 53, 69, 81, 73, 33, 32]
排序结果：NewArray:[12, 13, 25, 32, 33, 38, 45, 47, 49, 53, 63, 69, 70, 73, 73, 81, 84, 88, 95, 96]

2.选择排序
分析：将数组中数据，从左到右，依次取数字和左边数字比较，如果左边数字比较小则将当前数组元素和左边数字交换
代码：

    //选择排序实现
    public  static  void selectSortImp(){
        int[] newArr = productArray(20);    
        int  size=newArr.length;
        int  temp;
        for(int i=0;i<size-1;i++){
            temp=newArr[i];
            for(int j=i+1;j<=size-1;j++){

                if(newArr[i]>newArr[j]){
                    newArr[i]=newArr[j];
                    newArr[j]=temp;
                }
            }
        }

        StringBuffer buffer = new StringBuffer();
        buffer.append("NewArray:");
        buffer.append(Arrays.toString(newArr));
        System.out.println(buffer.toString());

    }
结果：

测试数组：OldArray:[12, 57, 86, 75, 50, 13, 4, 55, 81, 62, 91, 61, 67, 14, 66, 53, 42, 78, 12, 44]
排序结果：NewArray:[4, 12, 12, 42, 44, 61, 66, 78, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 91]

3.插入排序
分析：
代码实现：

// 插入排序实现
    public static void insertSortImp() {
        int[] newArr = productArray(20);
        int size = newArr.length;
        int j = 0;
        long  start=System.currentTimeMillis();
        for (int i = 1; i < size; i++) {
            int temp = newArr[i];
            j = i;
            while (j >0 && newArr[j - 1]>= temp) {//找到打破有序的元素
                newArr[j] = newArr[j - 1];//交互
                j--;
            }
                newArr[j] = temp;//将j号元素插入部分有序的最后位置


        }
        long  end=System.currentTimeMillis();
        StringBuffer buffer = new StringBuffer();
        System.out.println("insertSortImp".concat("\n"));
        buffer.append("NewArray:");
        buffer.append(Arrays.toString(newArr));
        System.out.println(buffer.toString());
        System.out.println("CostTime=".concat(String.valueOf(end-start)));

    }
测试数组：OldArray:[17, 29, 21, 30, 75, 83, 95, 52, 96, 46, 9, 43, 16, 71, 8, 68, 0, 66, 90, 92]
排序结果：NewArray:[0, 8, 9, 16, 17, 21, 29, 30, 43, 46, 52, 66, 68, 71, 75, 83, 90, 92, 95, 96]

对象的排序

以上我们操作的都是基本数据类型，但是实际开发中我们经常要操作对象类型数据
，对一组对象进行排序，
例如：将十个人，按照年龄大小排序，并且输出排序结果；
分析：我们要实现这两个接口的一个：1.Comparable
Comparator，使用的时候是这样实现的，comparetor要实现的方法：

@Override
            public int compare(Person o1, Person o2) {
                // TODO Auto-generated method stub
                //此处person类，按照年龄，从大到小，注意返回值
                if (o1.getAge() > o2.getAge()) {
                    return 1;
                } else {
                    return 0;
                }

            }

Comparable与之类似

@Override
    public   int compareTo(Person o) {
        if(this.age>o.age){
            return 1;
        }else{
            return 0;
        }

完整过程：

Person person = new Person();
        person.setAge(20);
        person.setName("yangliang");
        Person person2 = new Person();
        person2.setAge(18);
        person2.setName("beauty");
        Person person3 = new Person();
        person3.setAge(15);
        person3.setName("fdfas");
        ....
        ArrayList<Person> list = new ArrayList<Person>();
        list.add(person);
        list.add(person2);
        list.add(person3);
         ....
        Collections.sort(list, new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                // TODO Auto-generated method stub
                if (o1.getAge() > o2.getAge()) {
                    return 1;
                } else {
                    return 0;
                }

            }
        });
排序结果：
[Person [age=20, name=yangliang], Person [age=18, name=beauty], Person [age=15, name=fdfas]....]

这里我们看到一个Collections,工具类，后面再详细介绍

KasierYang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构之（1）数组

背景表现优秀程序，是选择合适的数据结构和优秀的算法的必然结果，作为一名务实、精进的程序员，对数据结构的学习，熟练，自然成了必要的课程。闲话不多说，程序中的数据结构，是与语言无关的，常见的数据结构有：数组（静态数组、动态数组）、线性表、链表（单向链表、双向链表、循环链表）队列堆树（二叉树、查找树、平衡树、线索树、线索树）在接下来的学习中，会对以上各种数据结构进行操作（add/get/d
复制链接

扫一扫