精华内容
下载资源
问答
  • 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数据结构和算法(一)——开篇

    万次阅读 多人点赞 2014-09-15 07:03:40
    看的是——《Java数据结构和算法》一书,作者Robert Lafore。 目录 1)数据结构算法有什么用? 2)技术与通俗 3)驱动力学习 1)数据结构算法有什么用? 当你用着java里面的容器类很爽的时候,你有没有想过,怎么...

    这篇文章里面不讲技术,抽空讲讲技术和通俗之间有一种奇特的关系,还有驱动力学习的东西。看的是——《Java数据结构和算法》一书,作者Robert Lafore。

    目录

    1)数据结构算法有什么用?

    2)技术与通俗

    3)驱动力学习


    1)数据结构算法有什么用?

    当你用着java里面的容器类很爽的时候,你有没有想过,怎么ArrayList就像一个无限扩充的数组,也好像链表之类的

    展开全文
  • java数据结构和算法(第二版)

    千次下载 热门讨论 2012-11-29 21:12:37
    Java数据结构的类库 小结 问题 第2章数组 Array专题Applet Java中数组的基础知识 将程序划分成类 类接口 Ordered专题applet 有序数组的Java代码 对数 存储对象 大O表示法 为什么不用数组表示一切? 小结 问题 实验 ...
  • 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数据结构算法

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

    千次阅读 多人点赞 2019-01-07 13:58:39
  • Java数据结构学习

    千次阅读 2014-03-13 21:11:01
    java 数据结构学习
  • 如何理解并掌握 Java 数据结构

    千次阅读 多人点赞 2019-11-13 11:11:45
    Jack和大家一起来重温《Java数据结构》经典之作。 第一部分:Java数据结构 要理解Java数据结构,必须能清楚何为数据结构? 数据结构: Data_Structure,它是储存数据的一种结构体,在此结构中储存一些数据,而这些...
  • Java 数据结构——单链表面试题(一)

    千次阅读 多人点赞 2021-05-16 16:14:35
    文章目录Java 数据结构——单链表面试题(一)一、删除所有关键字为 key的节点1.题目要求2.思路实现3.代码实现二、反转链表1.题目要求2.思路实现3.代码实现三、找到链表的中间节点1.题目要求2.思路实现3.代码实现 ...
  • java数据结构与算法之栈(Stack)设计与实现

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

    万次阅读 2017-07-21 16:18:03
    程序设计主要是数据结构+算法,而数据结构在面向对象思维里是“容器”的意思,数据结构主要...所以下面就简单介绍java数据结构的体系和部分原理实现java集合体系结构图集合父接口Collection,Map和集合工具类Collect
  • 【版权申明】未经博主同意,不允许转载!(请尊重原创,博主保留追究权) ... 出自【zejian的博客】 关联文章:java数据结构与算法之顺序表与链表设计与实现...java数据结构与算法之改良顺序表与双链表类似ArrayList和L
  • Java数据结构(4)- 链表

    万次阅读 2019-01-26 20:27:45
    一、什么是数据结构 定义:计算机存储和组织数据的方式 目的:用来提高数据处理的效率 ...分类:在Java中为我们提供了八种数据结构来存储数据 队列,堆,栈,二叉树,链表,图,散列图等八种数据结构 ...
  • java数据结构与算法的基础总结

    千次阅读 2017-10-09 11:03:30
    Java数据结构与算法之学习路线 最全的数据结构解析与归纳数据结构首先,要清楚数据结构的概念:数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 我们在...
  • Java数据结构Map的常用功能

    千次阅读 2020-11-09 09:39:44
    Java数据结构—Map 常用功能 添加功能: map.put(key,value); //添加元素或者修改value的值 删除功能 map.remove(key); 根据key的值删除对应value并且返回value map.clear(); 清除所有的对应关系 判断功能 map....
  • java数据结构(Java版)(第3版)[叶核亚] 全套资料

    千次下载 热门讨论 2013-08-18 12:01:48
    java数据结构(Java版)(第3版)[叶核亚] 全套资料包含:[电子教案] [配套资料] [习题解答与试题库] 内容相当丰富 不收藏肯定后悔呀
  • JAVA数据结构和算法+面试题

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

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

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

    万次阅读 多人点赞 2014-09-23 23:59:27
    Java数据结构和算法(二)——数组
  • Java数据结构和算法.(第二版).rar 免积分下载
  • Java数据结构和算法-第二版-高清扫描版-带目录书签

    千次下载 热门讨论 2012-09-15 14:55:34
    Java数据结构和算法.(第二版).pdf Java数据结构和算法-第二版-高清扫描版-带目录书签
  • java数据结构分析及优化

    千次阅读 2011-04-12 19:40:00
    java数据结构分析及优化
  • Java数据结构(2)- List

    万次阅读 2019-01-27 14:26:49
    程序的运行过程种,由于数据的长度并不会确定,所以使用数组的方式太过于麻烦,由此有产生了集合框架(说白了就是学习类,调用方法) 2、数组和集合的区别 3、集合体系 4、线程不安全 什么叫做线程不安全,...
  • Java数据结构(3)- 数组

    万次阅读 2019-01-26 22:23:59
    1、容器 容器:什么是容器,容器是一...而再java’语言当中什么是容器,容器就是用来装数据的,存储数据的容器。 2、数组 何为数组,从字面上来理解,就是一组数字,一组数据。数组作为一种基本容器,可以在jvm虚...
  • 老韩图解Java数据结构和算法-结束语(卖油翁和老黄牛).avi 老韩图解Java数据结构和算法-骑士周游回溯算法用贪心算法优化.avi 老韩图解Java数据结构和算法-骑士周游回溯算法代码实现(3).avi 老韩图解Java数据结构和...
  • Java数据结构复习之多项式加法和乘法实现 存储结构 数组 链表 数组实现package com.genge.jichu.polyn;/** * 用数组表示的多项式,以及相关实现 * Created by Genge on 2016-06-15. */ public class Polynomial ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,432,119
精华内容 572,847
热门标签
关键字:

java数据结构

java 订阅
数据结构 订阅