精华内容
下载资源
问答
  • 图解Java数据结构和算法

    万人学习 2019-06-21 10:09:16
    教程内容:本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀...
  • java数据结构算法

    千人学习 2019-11-22 10:12:46
    做一门精致,全面详细的 java数据结构与算法!!! 让天下没有难学的数据结构, 让天下没有难学的算法, 不吹不黑,我们的讲师及其敬业,可以看到课程视频,课件,代码的录制撰写,都是在深夜,如此用心,其心可鉴,他不掉头发,谁...
  • Java数据结构和算法中文第二版源码

    热门讨论 2015-09-01 12:02:09
    Java数据结构的类库 小结 问题 第2章 数组 Array专题Applet Java中数组的基础知识 将程序划分成类 类接口 Ordered专题applet 有序数组的Java代码 对数 存储对象 大O表示法 为什么不用数组表示一切? 小结 问题 实验...
  • Java数据结构

    2021-07-05 20:12:44
    然而为了解决问题,必定会使用到某些数据结构以及设计一个解决这种数据结构的算法。如果说各种编程语言是程序员的招式,那么数据结构和算法就相当于程序员的内功。编程实战算法,不是念PPT,我们讲的就是实战与代码...
  • Java数据结构和算法

    2017-09-09 21:50:29
    Java数据结构和算法 Java数据结构和算法 Java数据结构和算法 Java数据结构和算法 Java数据结构和算法 Java数据结构和算法 Java数据结构和算法 Java数据结构和算法
  • Java数据结构与算法入门

    万次阅读 多人点赞 2018-04-29 11:53:50
    第一部分:Java数据结构要理解Java数据结构,必须能清楚何为数据结构?数据结构:Data_Structure,它是储存数据的一种结构体,在此结构中储存一些数据,而这些数据之间有一定的关系。而各数据元素之间的相互关系,又...

    第一部分:Java数据结构

    要理解Java数据结构,必须能清楚何为数据结构?

    数据结构:

    1. Data_Structure,它是储存数据的一种结构体,在此结构中储存一些数据,而这些数据之间有一定的关系。
    2. 而各数据元素之间的相互关系,又包括三个组成成分,数据的逻辑结构,数据的存储结构和数据运算结构。
    3. 而一个数据结构的设计过程分成抽象层、数据结构层和实现层。

    数据结构在Java的语言体系中按逻辑结构可以分为两大类:线性数据结构和非线性数据结构。

    一、Java数据结构之:线性数据结构

    线性数据结构:常见的有一维数组,线性表,栈,队列,双队列,串。

    1:一维数组

    在Java里面常用的util有:String [],int [],ArrayList,Vector,CopyOnWriteArrayList等。及可以同过一维数组[]自己实现不同逻辑结构的Util类。而ArrayList封装了一些[]的基本操作方法。ArrayList和Vector的区别是:Vector是线程安全的,方法同步。CopyOnWriteArrayList也是线程安全的但效率要比Vector高很多。(PS:如果不懂出门右拐看另一篇chat)。

    数组这种数据结构典型的操作方法,是根据下标进行操作的,所以insert的的时候可以根据下标插入到具体的某个位置,但是这个时候它后面的元素都得往后面移动一位。所以插入效率比较低,更新,删除效率也比较低,而查询效率非常高,查询效率时间复杂度是1。

    2: 线性表

    线性表是有序的储存结构、链式的储存结构。链表的物理储存空间是不连续的,链表的每一个节点都知道上一个节点、或者下一个节点是谁,通常用Node表示。常见的有顺序链表(LinkedList、Linked***),单项链表(里面只有Node类),双向链表(两个Node类),循环链表(多个Node类)等。

    操作方法:插入效率比较高,插入的时候只需要改变节点的前后节点的连接即可。而查询效率就比较低了,如果实现的不好,需要整个链路找下去才能找到应该找的元素。所以常见的方法有:add(index,element),addFirst(element),addLast(element)。getFirst(),getLast(),get(element)等。

    常见的Uitil有:LinkedList,LinkedMap等,而这两个JDK底层也做了N多优化,可以有效避免查询效率低的问题。当自己实现的时候需要注意。其实树形结构可以说是非线性的链式储存结构。

    3: 栈Stack

    栈,最主要的是要实现先进后出,后进先出的逻辑结构。来实现一些场景对逻辑顺序的要求。所以常用的方法有push(element)压栈,pop()出栈。

    java.util.Stack。就实现了这用逻辑。而Java的Jvm里面也用的到了此种数据结构,就是线程栈,来保证当前线程的执行顺序。

    4:队列

    队列,队列是一种特殊的线性数据结构,队列只能允许在队头,队尾进行添加和查询等相关操作。队列又有单项有序队列,双向队列,阻塞队列等。

    Queue这种数据结构注定了基本操作方法有:add(E e)加入队列,remove(),poll()等方法。

    队列在Java语言环境中是使用频率相当高的数据结构,所有其实现的类也很多来满足不同场景。


    使用场景也非常多,如线程池,mq,连接池等。

    5:串

    串:也称字符串,是由N个字符组成的优先序列。在Java里面就是指String,而String里面是由chat[]来进行储存。

    KMP算法: 这个算法一定要牢记,Java数据结构这本书里面针对字符串的查找匹配算法也只介绍了一种。关键点就是:在字符串比对的时候,主串的比较位置不需要回退的问题。

    二、Java数据结构之:非线性数据结构

    非线性数据结构:常见的有:多维数组,集合,树,图,散列表(hash).

    1:多维数组

    一维数组前面咱也提到了,多维数组无非就是String [][],int[][]等。Java里面很少提供这样的工具类,而java里面tree和图底层的native方法用了多维数组来储存。

    2:集合

    由一个或多个确定的元素所构成的整体叫做集合。在Java里面可以去广义的去理解为实现了Collection接口的类都叫集合。

    Collection

    3:树

    树形结构,作者觉得它是一种特殊的链形数据结构。最少有一个根节点组成,可以有多个子节点。树,显然是由递归算法组成。

    树的特点:

    1. 在一个树结构中,有且仅有一个结点没有直接父节点,它就是根节点。
    2. 除了根节点,其他结点有且只有一个直接父节点
    3. 每个结点可以有任意多个直接子节点。

    树的数据结构又分如下几种:

    • 1) 自由树/普通树:对子节点没有任何约束。

      自由树

    • 2) 二叉树:每个节点最多含有两个子节点的树称为二叉树。

      2.1) 一般二叉树:每个子节点的父亲节点不一定有两个子节点的二叉树成为一般二叉树。

      2.2) 完全二叉树:对于一颗二叉树,假设其深度为d(d>1)。除了第d层外,其它各层的节点数目均已达最大值,且第d层所有节点从左向右连续地紧密排列,这样的二叉树被称为完全二叉树;

      2.3) 满二叉树:所有的节点都是二叉的二叉树成为满二叉树。

      二叉树

    • 3) 二叉搜索树/BST:binary search tree,又称二叉排序树、二叉查找树。是有序的。要点:如果不为空,那么其左子树节点的值都小于根节点的值;右子树节点的值都大于根节点的值。

      二叉搜索树

      3.1) 二叉平衡树:二叉搜索树,是有序的排序树,但左右两边包括子节点不一定平衡,而二叉平衡树是排序树的一种,并且加点条件,就是任意一个节点的两个叉的深度差不多(比如差值的绝对值小于某个常数,或者一个不能比另一个深出去一倍之类的)。这样的树可以保证二分搜索任意元素都是O(log n)的,一般还附带带有插入或者删除某个元素也是O(log n)的的性质。

      为了实现,二叉平衡树又延伸出来了一些算法,业界常见的有AVL、和红黑算法,所以又有以下两种树:

      3.1.1) AVL树:最早的平衡二叉树之一。应用相对其他数据结构比较少。windows对进程地址空间的管理用到了AVL树。

      3.1.2) 红黑树:通过制定了一些红黑标记和左右旋转规则来保证二叉树平衡。

      红黑树的5条性质:

      1. 每个结点要么是红的,要么是黑的。
      2. 根结点是黑的。
      3. 每个叶结点(叶结点即指树尾端NIL指针或NULL结点)是黑的。
      4. 如果一个结点是红的,那么它的俩个儿子都是黑的。
      5. 对于任一结点而言,其到叶结点树尾端NIL指针的每一条路径都包含相同数目的黑结点。

      红黑树

    • 4) B-tree:又称B树、B-树。又叫平衡(balance)多路查找树。树中每个结点最多含有m个孩子(m>=2)。它类似普通的平衡二叉树,不同的一点是B-树允许每个节点有更多的子节点。

      B-tree

    • 4) B+tree:又称B+。是B-树的变体,也是一种多路搜索树。

      B+tree

    树总结:
    树在Java里面应用的也比较多。非排序树,主要用来做数据储存和展示。而排序树,主要用来做算法和运算,HashMap里面的TreeNode就用到了红黑树算法。而B+树在数据库的索引原理里面有典型的应用。

    4:Hash

    Hash概念:

    • Hash,一般翻译做“散列”,也有直接音译为“哈希”的,就是把任意长度的输入(又叫做预映射, pre-image),变换成固定长度的输出,该输出就是散列值。一般通过Hash算法实现。

    • 所谓的Hash算法都是散列算法,把任意长度的输入,变换成固定长度的输出,该输出就是散列值.(如:MD5,SHA1,加解密算法等)

    • 简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

    Java中的hashCode:

    • 我们都知道所有的class都是Object的子类,既所有的class都会有默认Object.java里面的hashCode的方法,如果自己没有重写,默认情况就是native方法通过对象的内存的+对象的值然后通过hash散列算法计算出来个int的数字。

    • 最大的特性是:不同的对象,不同的值有可能计算出来的hashCode可能是一样的。

    Hash表:

    • Java中数据存储方式最底层的两种结构,一种是数组,另一种就是链表。而Hash表就是综合了这两种数据结构。

    • 如:HashTable,HashMap。这个时候就得提一下HashMap的原理了,默认16个数组储存,通过Hash值取模放到不同的桶里面去。(注意:JDK1.8此处算法又做了改进,数组里面的值会演变成树形结构。)

    • 哈希表具有较快(常量级)的查询速度,及相对较快的增删速度,所以很适合在海量数据的环境中使用。一般实现哈希表的方法采用“拉链法”,我们可以理解为“链表的数组”。

      哈希表

    一致性Hash:

    • 我们查看一下HashMap的原理,其实发现Hash很好的解决了单体应用情况下的数据查找和插入的速度问题。但是毕竟单体应用的储存空间是有限的,所有在分布式环境下,应运而生了一致性Hash算法。

    • 用意和hashCode的用意一样,只不过它是取模放在不同的IP机器上而已。具体算法可以找一下相关资料。

    • 而一致性Hash需要注意的就是默认分配的桶比较多些,而当其中一台机器挂了,影响的面比较小一些。

    • 需要注意的是,相同的内容算出来的hash一定是一样的。既:幂等性。

    • 一致性Hash

    第二部分:Java基本算法

    理解了Java数据结构,还必须要掌握一些常见的基本算法。 理解算法之前必须要先理解的几个算法的概念:

    空间复杂度:一句来理解就是,此算法在规模为n的情况下额外消耗的储存空间。

    时间复杂度:一句来理解就是,此算法在规模为n的情况下,一个算法中的语句执行次数称为语句频度或时间频度。

    稳定性:主要是来描述算法,每次执行完,得到的结果都是一样的,但是可以不同的顺序输入,可能消耗的时间复杂度和空间复杂度不一样。

    一、二分查找算法

    二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好,占用系统内存较少;其缺点是要求待查表为有序表,且插入删除困难。这个是基础,最简单的查找算法了。

        public static void main(String[] args) {
            int srcArray[] = {3,5,11,17,21,23,28,30,32,50,64,78,81,95,101};
            System.out.println(binSearch(srcArray, 28));
        }
        /**
         * 二分查找普通循环实现
         *
         * @param srcArray 有序数组
         * @param key 查找元素
         * @return
         */
        public static int binSearch(int srcArray[], int key) {
            int mid = srcArray.length / 2;
    //        System.out.println("=:"+mid);
            if (key == srcArray[mid]) {
                return mid;
            }
    
    //二分核心逻辑
            int start = 0;
            int end = srcArray.length - 1;
            while (start <= end) {
    //            System.out.println(start+"="+end);
                mid = (end - start) / 2 + start;
                if (key < srcArray[mid]) {
                    end = mid - 1;
                } else if (key > srcArray[mid]) {
                    start = mid + 1;
                } else {
                    return mid;
                }
            }
            return -1;
        }
    

    二分查找算法如果没有用到递归方法的话,只会影响CPU。对内存模型来说影响不大。时间复杂度log2n,2的开方。空间复杂度是2。一定要牢记这个算法。应用的地方也是非常广泛,平衡树里面大量采用。

    二、递归算法

    递归简单理解就是方法自身调用自身。

        public static void main(String[] args) {
            int srcArray[] = {3,5,11,17,21,23,28,30,32,50,64,78,81,95,101};
            System.out.println(binSearch(srcArray, 0,15,28));
        }
        /**
         * 二分查找递归实现
         *
         * @param srcArray  有序数组
         * @param start 数组低地址下标
         * @param end   数组高地址下标
         * @param key  查找元素
         * @return 查找元素不存在返回-1
         */
        public static int binSearch(int srcArray[], int start, int end, int key) {
            int mid = (end - start) / 2 + start;
            if (srcArray[mid] == key) {
                return mid;
            }
            if (start >= end) {
                return -1;
            } else if (key > srcArray[mid]) {
                return binSearch(srcArray, mid + 1, end, key);
            } else if (key < srcArray[mid]) {
                return binSearch(srcArray, start, mid - 1, key);
            }
            return -1;
        }
    

    递归几乎会经常用到,需要注意的一点是:递归不光影响的CPU。JVM里面的线程栈空间也会变大。所以当递归的调用链长的时候需要-Xss设置线程栈的大小。

    三、八大排序算法

    • 一、直接插入排序(Insertion Sort)
    • 二、希尔排序(Shell Sort)
    • 三、选择排序(Selection Sort)
    • 四、堆排序(Heap Sort)
    • 五、冒泡排序(Bubble Sort)
    • 六、快速排序(Quick Sort)
    • 七、归并排序(Merging Sort)
    • 八、基数排序(Radix Sort)

    八大算法,网上的资料就比较多了。

    吐血推荐参考资料:git hub 八大排序算法详解。此大神比作者讲解的还详细,作者就不在这里,描述重复的东西了,作者带领大家把重点的两个强调一下,此两个是必须要掌握的。

    1:冒泡排序

    基本思想:

    冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

    冒泡排序

    以下是冒泡排序算法复杂度:

    平均时间复杂度最好情况最坏情况空间复杂度
    O(n²)O(n)O(n²)O(1)

    冒泡排序是最容易实现的排序, 最坏的情况是每次都需要交换, 共需遍历并交换将近n²/2次, 时间复杂度为O(n²). 最佳的情况是内循环遍历一次后发现排序是对的, 因此退出循环, 时间复杂度为O(n). 平均来讲, 时间复杂度为O(n²). 由于冒泡排序中只有缓存的temp变量需要内存空间, 因此空间复杂度为常量O(1).

    Tips: 由于冒泡排序只在相邻元素大小不符合要求时才调换他们的位置, 它并不改变相同元素之间的相对顺序, 因此它是稳定的排序算法.

    /**
     * 冒泡排序
     *
     * ①. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
     * ②. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
     * ③. 针对所有的元素重复以上的步骤,除了最后一个。
     * ④. 持续每次对越来越少的元素重复上面的步骤①~③,直到没有任何一对数字需要比较。
     * @param arr  待排序数组
     */
    public static void bubbleSort(int[] arr){
        for (int i = arr.length; i > 0; i--) {      //外层循环移动游标
            for(int j = 0; j < i && (j+1) < i; j++){    //内层循环遍历游标及之后(或之前)的元素
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    System.out.println("Sorting: " + Arrays.toString(arr));
                }
            }
        }
    }
    

    2:快速排序

    快速排序

    快速排序使用分治策略来把一个序列(list)分为两个子序列(sub-lists)。步骤为:

    ①. 从数列中挑出一个元素,称为”基准”(pivot)。

    ②. 重新排序数列,所有比基准值小的元素摆放在基准前面,所有比基准值大的元素摆在基准后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。

    ③. 递归地(recursively)把小于基准值元素的子数列和大于基准值元素的子数列排序。

    递归到最底部时,数列的大小是零或一,也就是已经排序好了。这个算法一定会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。

    代码实现:

    用伪代码描述如下:

    ①. i = L; j = R; 将基准数挖出形成第一个坑a[i]。

    ②.j--,由后向前找比它小的数,找到后挖出此数填前一个坑a[i]中。

    ③.i++,由前向后找比它大的数,找到后也挖出此数填到前一个坑a[j]中。

    ④.再重复执行②,③二步,直到i==j,将基准数填入a[i]中。

    快速排序采用“分而治之、各个击破”的观念,此为原地(In-place)分区版本。

    快速排序 In-place

    /**
     * 快速排序(递归)
     *
     * ①. 从数列中挑出一个元素,称为"基准"(pivot)。
     * ②. 重新排序数列,所有比基准值小的元素摆放在基准前面,所有比基准值大的元素摆在基准后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
     * ③. 递归地(recursively)把小于基准值元素的子数列和大于基准值元素的子数列排序。
     * @param arr   待排序数组
     * @param low   左边界
     * @param high  右边界
     */
    public static void quickSort(int[] arr, int low, int high){
        if(arr.length <= 0) return;
        if(low >= high) return;
        int left = low;
        int right = high;
        int temp = arr[left];   //挖坑1:保存基准的值
        while (left < right){
            while(left < right && arr[right] >= temp){  //坑2:从后向前找到比基准小的元素,插入到基准位置坑1中
                right--;
            }
            arr[left] = arr[right];
            while(left < right && arr[left] <= temp){   //坑3:从前往后找到比基准大的元素,放到刚才挖的坑2中
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = temp;   //基准值填补到坑3中,准备分治递归快排
        System.out.println("Sorting: " + Arrays.toString(arr));
        quickSort(arr, low, left-1);
        quickSort(arr, left+1, high);
    }
    

    以下是快速排序算法复杂度:

    平均时间复杂度最好情况最坏情况空间复杂度
    O(nlog₂n)O(nlog₂n)O(n²)O(1)(原地分区递归版)

    快速排序排序效率非常高。 虽然它运行最糟糕时将达到O(n²)的时间复杂度, 但通常平均来看, 它的时间复杂为O(nlogn), 比同样为O(nlogn)时间复杂度的归并排序还要快. 快速排序似乎更偏爱乱序的数列, 越是乱序的数列, 它相比其他排序而言, 相对效率更高.


    最后,作者希望让大家对《Java数据结构》整体有个全面的了解,知道什么是数据结构,离我们工作中有多远,而不是一个深不可测的神秘物件。里面的细节,篇幅有限可能不能描述完,但是只要同学们的方向没有搞错,那只要针对每个点再详细的看看即可。

    面试和工作,这些都是离不开的,当同学们有个完整的认识之后,一定要在工作中留心,留意每个用到的地方。

    更多精彩教程,请关注公众号:Java开发教程视频      


    展开全文
  • Java 数据结构

    千次阅读 2016-11-17 09:29:05
    Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类: 枚举(Enumeration) 位集合(BitSet) 向量(Vector) 栈(Stack) 字典(Dictionary) 哈希表...

    Java 数据结构

    Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类:

    • 枚举(Enumeration)
    • 位集合(BitSet)
    • 向量(Vector)
    • 栈(Stack)
    • 字典(Dictionary)
    • 哈希表(Hashtable)
    • 属性(Properties)

    以上这些类是传统遗留的,在Java2中引入了一种新的框架-集合框架(Collection),我们后面再讨论。


    枚举(Enumeration)

    枚举(Enumeration)接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。 枚举(The Enumeration)接口定义了一种从数据结构中取回连续元素的方式。

    例如,枚举定义了一个叫nextElement 的方法,该方法用来得到一个包含多元素的数据结构的下一个元素。

    关于枚举接口的更多信息,请参见枚举(Enumeration)


    位集合(BitSet)

    位集合类实现了一组可以单独设置和清除的位或标志。

    该类在处理一组布尔值的时候非常有用,你只需要给每个值赋值一"位",然后对位进行适当的设置或清除,就可以对布尔值进行操作了。

    关于该类的更多信息,请参见位集合(BitSet)


    向量(Vector)

    向量(Vector)类和传统数组非常相似,但是Vector的大小能根据需要动态的变化。

    和数组一样,Vector对象的元素也能通过索引访问。

    使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小,它的大小会根据需要动态的变化。

    关于该类的更多信息,请参见向量(Vector)


    栈(Stack)

    栈(Stack)实现了一个后进先出(LIFO)的数据结构。

    你可以把栈理解为对象的垂直分布的栈,当你添加一个新元素时,就将新元素放在其他元素的顶部。

    当你从栈中取元素的时候,就从栈顶取一个元素。换句话说,最后进栈的元素最先被取出。

    关于该类的更多信息,请参见栈(Stack)


    字典(Dictionary)

    字典(Dictionary) 类是一个抽象类,它定义了键映射到值的数据结构。

    当你想要通过特定的键而不是整数索引来访问数据的时候,这时候应该使用Dictionary。

    由于Dictionary类是抽象类,所以它只提供了键映射到值的数据结构,而没有提供特定的实现。

    关于该类的更多信息,请参见字典( Dictionary)


    哈希表(Hashtable)

    Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。

    例如,在地址列表的哈希表中,你可以根据邮政编码作为键来存储和排序数据,而不是通过人名。

    哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

    关于该类的更多信息,请参见哈希表(HashTable)


    属性(Properties)

    Properties 继承于 Hashtable.Properties 类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。

    Properties 类被许多Java类使用。例如,在获取环境变量时它就作为System.getProperties()方法的返回值。

    关于该类的更多信息,请参见属性(Properties)

    展开全文
  • JAVA数据结构和算法+面试题

    热门讨论 2011-12-19 22:36:17
    JAVA数据结构和算法的教程 还有算法题 加部分面试题 从别人那下的 在这一次给了 希望能帮到大家
  • java数据结构和算法(第二版)

    千次下载 热门讨论 2012-11-29 21:12:37
    Java数据结构的类库 小结 问题 第2章数组 Array专题Applet Java中数组的基础知识 将程序划分成类 类接口 Ordered专题applet 有序数组的Java代码 对数 存储对象 大O表示法 为什么不用数组表示一切? 小结 问题 实验 ...
  • 线性结构和非线性结构 队列 顺序队列 循环队列 链表 链表(Linked List)介绍 链表是有序的列表,但是它在内存中是存储如下 小结: 1) 链表是以节点的方式来存储,是链式存储 2)每个节点包含 data 域, ...

    红色的表示重要,绿色的表示暂时还不懂而且很重要

    线性结构和非线性结构

    队列

    顺序队列

    循环队列

    链表

    链表(Linked List)介绍

    链表是有序的列表,但是它在内存中是存储如下

     

    小结:

    1) 链表是以节点的方式来存储,是链式存储

    2)每个节点包含 data 域, next 域:指向下一个节点.

    3)如图:发现链表的各个节点不一定是连续存储.

    4)链表分带头节点的链表和没有头节点的链表,根据实际的需求来确定

    单向链表

    双向链表

    Josephu(约瑟夫、约瑟夫环) 问题

    排序算法

    算法的时间复杂度介绍

    排序算法介绍

    冒泡排序(Java)

    选择排序(Java)

    插入算法(Java)

    希尔排序(Java)

    快速排序(Java)

    归并排序(Java)

    展开全文
  • Java数据结构及原理实现

    万次阅读 2017-07-21 16:18:03
    程序设计主要是数据结构+算法,而数据结构在面向对象思维里是“容器”的意思,数据结构主要...所以下面就简单介绍java数据结构的体系和部分原理实现java集合体系结构图集合父接口Collection,Map和集合工具类Collect

    程序设计主要是数据结构+算法,而数据结构在面向对象思维里是“容器”的意思,数据结构主要负责数据的添加,删除,修改,查找及对数据的其他操作。编程里面对着不同问题场景,选择哪种数据结构进行操作就非常重要。试想:如果谷歌是以数组来存储数据的话,还会有那么快的搜索速度?所以下面就简单介绍java数据结构的体系和部分原理实现

    总体思路:

    1. java集合体系结构图
    2. 集合父接口Collection,Map和集合工具类Collections
    3. List(列表)
    4. Set(规则集)
    5. Queue(队列
    6. Map(映射类)

    java集合体系结构图

    java集合体系结构图


    集合父接口Collection,Map和集合工具类Collections

    Collection是java集合框架体系的总接口,其他集合框架都是实现Collection,封装了集合框架的公共操作:add(E),addAll(),remove(E),removeAll(),其方法摘要如下:
    Collection API

    说到集合框架必须提到Collection的工具类Collections,它封装了所有集合的关于算法操作的具体实现静态方法:二分查找,找出集合最大值,集合最小值,打乱集合,以及生成不可修改集合,同步集合(多线程环境下使用),其主要方法API如下:
    Collections  API

    Collections的synchronizedCollection()主要是在原来的方法外添加一个信号量来进行同步操作,其源码实现如下:

    static class SynchronizedCollection<E> implements Collection<E>, Serializable {
        private static final long serialVersionUID = 3053995032091335093L;
        
        final Collection<E> c;  // Backing Collection
        final Object mutex;     // Object on which to synchronize
        
        public boolean add(E e) {
        	//锁定信号量才可以对集合进行操作,在多线程环境下来进行同步,调用的还是原来的方法
            synchronized (mutex) {return c.add(e);}
        }
        
        public boolean remove(Object o) {
        	//锁定信号量才可以对集合进行操作,在多线程环境下来进行同步,调用的还是原来的方法
            synchronized (mutex) {return c.remove(o);}
        }
     }
    

    集合框架Collection的三种主要实现如下:List(列表),Set(散列集,有一个key-value的Map进行维护,其中key值保证Set集合里元素的唯一性),Queue(队列,先进先出,底层实现可以用List列表或者LinkedList链表)

    集合框架的另外一种数据类型的总接口是Map,基于Key-Value进行存储数据的,其中Key键值是不可重复的,主要是通过类的hashCode()和equal()进行保证的


    List(列表)

    List列表允许存储相同元素,插入元素和按照下标获取元素方便,具体实现有ArrayList,LinkedList和Vector,

    1. ArrayList底层基于数组实现的,按顺序存储元素以及快速按照元素下标进行获取元素,不可同步的;

    2. 而Vector底层也是数组,可进行同步操作,在多线程环境下可以使用;

    3. LinkedList链表的具体机制如下图:可以在具体下标位置删除和添加元素,在许多需要根据具体下标添加和删除元素的应用场景下比ArrayList有更好的性能。

    LinkedList

    ArrayList和Vector的部分源码分析:

    //ArrayList的add()方法
     public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            //在数组结尾下标添加元素
            elementData[size++] = e;
            return true;
        }
        //ArrayList的remove()方法
        public E remove(int index) {
            rangeCheck(index);
    
            modCount++;
            E oldValue = elementData(index);
            //获取移动的元素的个数
            int numMoved = size - index - 1;
            if (numMoved > 0)
            	//将移除元素的下标位置后的数组元素都往前移一位来填补空位,调用System.arraycopy方法调用虚拟机自带的方法进行操作效率更高
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            elementData[--size] = null; // clear to let GC do its work
    
            return oldValue;
        }
        
        //Vector添加了synchronized 进行同步
        public synchronized void addElement(E obj) {
            modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = obj;
        }
    

    综上:Array List在不需要同步操作及不需要频繁删除任意下标的元素时推荐使用,Vector是在同步场景下使用,LinkedList是在需要频繁删除和添加任意下标的元素时使用

    Set(规则集)

    散列集,不能保证存储元素的顺序,保证存储元素的不可重复性。具体实现由HashSet,LinkedHashSet,TreeSet,

    1. HashSet是哈希散列集,底层由HashMap支持的,主要使用hashCode()和equal()方法确保Key值不可重复性来保证元素的唯一性

    2. LinkedHashSet底层由LinkedHashMap,则可以保证按照元素插入规则集的顺序进行提取。

    3. TreeSet底层是由TreeMap支持的,可以按照Comparable接口对存储对象排序或者Comparator比较器接口进行存储对象的比较排序

    HashSet的具体源码如下所示:

        public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable{
    	    private transient HashMap<E,Object> map;
    	    // Dummy value to associate with an Object in the backing Map
    	    private static final Object PRESENT = new Object();
    	    
    	    public boolean contains(Object o) {
    	    	//判断是否存在元素就在hashMap中查看是否存在键值Key为元素o
    	        return map.containsKey(o);
    	    }
    	    
    	    public boolean add(E e) {
    	    	//将要存储的元素当作hashMap的key值进行存储,保证存储元素的唯一性
    	    	return map.put(e, PRESENT)==null;
    	    }
        }
    

    Queue(队列)

    队列是一般按照先进先出First-In-First-Out的规则,元素被追加到队列末尾,在队列头进行删除,底层实现可以是数组,也可以是链表。主要实现有PriorityQueue和LinkedList,

    • 其中PriorityQueue优先队列默认情况下以Comparable按照元素的自然顺序进行排序,最小值的元素优先级最高最先删除,也可以传入指定的比较器Comparator进行元素间的比较。

    • 在java.util.concurrent包里有ArrayBlockingQueue,LinkedBlockingQueue等实现同步机制的队列数据结构,有兴趣可以查看源码进行研究。

    ##Map(映射类)
    Map是按照Key-Value进行存储的数据结构,主要实现有HashMap,LinkedHashMap,TreeMap,

    • 在不需要保证元素的顺序情况下,HashMap是非常高效的,主要是通过hashCode()和equal()方法进行哈希化存储的,所以要求存储的对象要实现hashCode()和equal()方法才能提高性能。HashMap具体的内部机制可以看
      高爽|Coder的HashMap深度解析

    • 而LinkedHashMap可以保证存储元素的顺序;可以按照元素的存储顺序或者元素的访问顺序进行排序存储,它的底层是由HashMap加上循环双向链表实现的。其中LinkedHashMap的具体机制可以看 LinkedHashMap及其源码分析

    • TreeMap在遍历排序好的键值是非常高效率的,默认是按照元素的实现Comprable接口方法进行排序的,也可以传入Comparator比较器接口进行比较排序
      以下是TreeMap的put(K key, V value)源码分析

    public V put(K key, V value) {
            Entry<K,V> t = root;
            //若集合为空,那么添加的元素成为TreeMap的根结点
            if (t == null) {
                compare(key, key); // type (and possibly null) check
    
                root = new Entry<>(key, value, null);
                size = 1;
                modCount++;
                return null;
            }
            int cmp;
            Entry<K,V> parent;
            // split comparator and comparable paths
            Comparator<? super K> cpr = comparator;
            //当比较器存在时,使用比较器Comparator
            if (cpr != null) {
                do {
                    parent = t;
                    //使用比较器Comparator对元素的Key值进行比较
                    cmp = cpr.compare(key, t.key);
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else
                        return t.setValue(value);
                } while (t != null);
            }
            else {//当比较器不存在时,使用元素实现Comparable接口的方法
                if (key == null)
                    throw new NullPointerException();
                @SuppressWarnings("unchecked")
                    Comparable<? super K> k = (Comparable<? super K>) key;
                do {
                    parent = t;
                    //使用元素实现Comparable接口的方法进行键值Key的比较
                    cmp = k.compareTo(t.key);
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else
                        return t.setValue(value);
                } while (t != null);
            }
            Entry<K,V> e = new Entry<>(key, value, parent);
            if (cmp < 0)
                parent.left = e;
            else
                parent.right = e;
            fixAfterInsertion(e);
            size++;
            modCount++;
            return null;
        }
    

    以上是最近学习整理的数据结构内容,对于数据结构的学习不单单需要知道各种数据结构的优缺点和应用场景,对于数据结构的源码和算法也是蕴含着很多可以学习的东西。数据结构在程序设计中的应用也非常广泛,比如Sturts的值栈机制就是使用List数据实现的,Mybatis的缓存机制就是使用Map机制进行实现的…

    未来路还很长,继续前进

    展开全文
  • Java数据结构和算法-第二版-高清扫描版-带目录书签

    千次下载 热门讨论 2012-09-15 14:55:34
    Java数据结构和算法.(第二版).pdf Java数据结构和算法-第二版-高清扫描版-带目录书签
  • 本书是著名作者JohnLewis与JosephChase作为...尽管本书的英文名为“JavaSoftwareStructures:DesigningandUsingDataStructures”,但正如作者在前言中所说的那样,本书其实是一本可作为“数据结构与算法”课程的教材。
  • Java数据结构与算法视频教程(44集版),附源码资料 目录找不到 讲的很详细
  • java数据结构之Map

    千次阅读 2018-09-07 10:05:44
    Java中的List和Map是使用频率非常高的数据结构。这里介绍下常用的Map实现。 先来看下类图: HashMap的实现原理 HashMap的实现原理参考:HashMap的实现原理 HashMap与HashTable的异同 HashTable与HashMap的...
  • 老韩图解Java数据结构和算法-结束语(卖油翁和老黄牛).avi 老韩图解Java数据结构和算法-骑士周游回溯算法用贪心算法优化.avi 老韩图解Java数据结构和算法-骑士周游回溯算法代码实现(3).avi 老韩图解Java数据结构和...
  • 从前慢-java数据结构和算法

    千次阅读 多人点赞 2020-12-22 21:27:52
    数据结构包括:线性结构和非线性结构 1.线性结构 1)线性结构作为最常用的数据结构,其特点是数据元素之间存在一对一的线性关系 2)线性结构有两种不同的存储结构,即顺序存储结构(数组)和链式存储结构(链表)....
  • java数据结构与算法的基础总结

    千次阅读 2017-10-09 11:03:30
    Java数据结构与算法之学习路线 最全的数据结构解析与归纳数据结构首先,要清楚数据结构的概念:数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 我们在...
  • Java数据结构和算法.(第二版).rar 免积分下载
  • java数据结构——抽象数据类型

    千次阅读 2019-02-18 12:24:51
    数据得抽象是用抽象数据类型来实现的,ADT是这个集合和定义在这集合上的一组数据操作,它不包括计算机数据存储:隐藏了数据存储结构并且不涉及实现结构数据类型。 java中抽象数据类型的描述:1.抽象类...
  • java数据结构之Set

    千次阅读 2018-09-07 10:07:12
    先来一张UML图: 如上,Set最重要的是HashSet、LinkedHashSet、TreeSet和CopyOnWriteArraySet几个实现类。Set中的元素是不能重复的。...参考:《java程序性能优化——让你java程序更快、更稳定》
  • Java数据结构和算法(一)——简介

    千次阅读 2019-06-02 21:48:12
     本系列博客我们将学习数据结构和算法,为什么要学习数据结构和算法,这里我举个简单的例子。  编程好比是一辆汽车,而数据结构和算法是汽车内部的变速箱。一个开车的人不懂变速箱的原理也是能开车的,同理一个不...
  • java数据结构之List

    千次阅读 2018-09-07 10:03:56
    List是java中重要的数据结构之一,这里介绍常用的3种实现方式:ArrayList、Vector、LinkedList。 类图如下: 可以看到,ArrayList、Vector、LinkedList都是AbstractList的实现。而AbstractList实现了List接口,...
  • java数据结构与算法之(Queue)队列设计与实现

    万次阅读 多人点赞 2016-12-04 10:05:06
    队列的抽象数据类型 顺序队列的设计与实现 链式队列的设计与实现 队列的简单应用 优先队列的设置与实现
  • java数据结构有哪些?

    万次阅读 多人点赞 2018-12-28 17:26:11
    Java中有几种常用的数据结构,主要分为Collection和map两个主要接口(接口只提供方法,并不提供实现),而程序中最终使用的数据结构是继承自这些接口的数据结构类。 Collection----&gt;Collections Map--...
  • java数据结构与算法之栈(Stack)设计与实现

    万次阅读 多人点赞 2016-11-28 12:27:43
    【版权申明】转载请注明出处(请尊重原创,博主...关联文章:java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedL
  • Java数据结构与算法解析(一)——表

    万次阅读 多人点赞 2017-08-27 13:27:07
    本节我们讨论常见常用的数据结构——表。 如果要通俗简单的说什么是表,那我们可以这样说:按顺序排好的元素集合就是表。表的概述抽象数据类型是带有一组操作的一些对象的结合1、定义: 线性表是一个线性结构,它...
  • Java数据结构与算法之学习路线

    万次阅读 多人点赞 2016-09-28 17:19:21
    目录: 1.前言 2.数据结构与算法学习大纲(粗糙) 3.线性结构分类 4.各个线性类型数据结构的特点以及使用场景 5.数组与队列的区别 1.前言: ...去做了两道面试题,全是数据结构和算法的题,由于我的java
  • 如何理解并掌握 Java 数据结构

    千次阅读 多人点赞 2019-11-13 11:11:45
    Jack和大家一起来重温《Java数据结构》经典之作。 第一部分:Java数据结构 要理解Java数据结构,必须能清楚何为数据结构? 数据结构: Data_Structure,它是储存数据的一种结构体,在此结构中储存一些数据,而这些...
  • 16 张图带你搞懂 Java 数据结构,从此想不飘都难!

    千次阅读 多人点赞 2021-04-06 11:07:31
    今天我们来学一下数据结构方面的知识,对扎实 Java 的基本功非常有用,学会了就会有一种自带大佬的感觉,嘿嘿。数据结构,也就是 Data Structure,是一种存储数据的结构体,数据与数据之间存在着一定的关系,这样的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,445,109
精华内容 578,043
关键字:

java数据结构

java 订阅
数据结构 订阅