精华内容
下载资源
问答
  • 2018-12-10 20:55:31

    题目:输入两个链表,找出他们的第一个公共节点。

    分析:我们可以先遍历一次得到他们的长度,计算他们的差值diffNode,让长的链表先走diffNode个节点,然后一起向后走,直到他们第一个相同的节点,就是我们要找的节点。

     public FindEntranceOfListNode.ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {

            int length1=getLength(pHead1);

            int length2=getLength(pHead2);

            int diffLength=Math.abs(length1-length2);

            ListNode shortListNode=length1<length2?pHead1:pHead2;

          ListNode longListNode=length1<length2?pHead2:pHead1;

    //长的链表先走diffLength个节点

          for(int i=0;i<diffLength;i++){

               longListNode=longListNode.next;

           }

      //找到第一个相同的节点

     while(longListNode!=null&&shortListNode!=null&&shortListNode.val!=longListNode.val){

               longListNode=longListNode.next;

               shortListNode=shortListNode.next;

            }

           return longListNode;

     

      }

        public int getLength(ListNode node){

           int length=0;

           ListNode head=node;

           while(node!=null){

               length++;

              node=node.next;

           }

          return length;

       }

    更多相关内容
  • java (双)链表实现

    2021-03-16 03:31:52
    /*** 双向链表* @author huangbiao* @date 2013-9-20*/public class MyList {public static void main(String[] args) {MyList mylist = new MyList();mylist.addFirst("huangbiao_first1");mylist.ad...

    package hb.struct;

    /**

    * 双向链表

    * @author huangbiao

    * @date 2013-9-20

    */

    public class MyList {

    public static void main(String[] args) {

    MyList mylist = new MyList();

    mylist.addFirst("huangbiao_first1");

    mylist.addFirst("huangbiao_first2");

    mylist.addLast("huangbiao_last1");

    mylist.addLast("huangbiao_last2");

    System.out.println("-------------add(int,Object)-------------------");

    mylist.add(1, "add(int,Object)");

    mylist.addBefor("addBefore", mylist.getNode(2));

    for(int i=0;i

    System.out.println(mylist.getNode(i).getItem());

    }

    System.out.println("-------------getFirst()-------------------");

    System.out.println(mylist.getFirst().getItem());

    System.out.println(mylist.getLast().getItem());

    System.out.println("-------------remove(Node)-------------------");

    try {

    mylist.remove(mylist.getNode(2));

    } catch (Exception e) {

    e.printStackTrace();

    }

    for(int i=0;i

    System.out.println(mylist.getNode(i).getItem());

    }

    System.out.println("-------------remove(int)-------------------");

    try {

    mylist.remove(2);

    } catch (Exception e) {

    e.printStackTrace();

    }

    for(int i=0;i

    System.out.println(mylist.getNode(i).getItem());

    }

    System.out.println("------------removeLast()--------------------");

    mylist.removeLast();

    for(int i=0;i

    System.out.println(mylist.getNode(i).getItem());

    }

    }

    private Node head;

    private Node tail;

    private int size;

    MyList() {

    head = new Node();

    tail = new Node();

    head.setNext(tail);

    tail.setPre(head);

    size = 0;

    }

    public Node getNode(int i){

    Node result = head;

    if(0<= i && i < size){

    for (int j = 0; j <= i; j++)

    result = result.next;

    }else{

    return result;

    }

    return result;

    }

    public Node getFirst(){

    Node result = null;

    if(size > 0){

    result = head.next;

    }

    return result;

    }

    public Node getLast(){

    Node result = null;

    if(size > 0){

    result = tail.pre;

    }

    return result;

    }

    private boolean isPositionIndex(int i){

    return i>=0 && i<=size;

    }

    private void checkPositionIndex(int i){

    if(!isPositionIndex(i)){

    throw new IndexOutOfBoundsException(outOfBoundsMsg(i));

    }else{

    return ;

    }

    }

    private String outOfBoundsMsg(int i) {

    return (new StringBuilder()).append("Index: ").append(i).append(", Size: ").append(size).toString();

    }

    public void addFirst(Object item) {

    Node n = new Node(item, head, head.getNext());

    head.getNext().setPre(n);

    head.setNext(n);

    size++;

    }

    public int size(){

    return this.size;

    }

    public void add(int index,Object item){

    checkPositionIndex(index);

    if (index == size)

    addLast(item);

    else

    addBefor(item, getNode(index));

    }

    public void addBefor(Object obj,Node beforeNode){

    Node node2 = beforeNode.pre;

    Node node = new Node(obj,node2,beforeNode);

    //

    beforeNode.pre = node;

    node2.next = node;

    size++;

    }

    public void addLast(Object item) {

    Node n = new Node(item, tail.getPre(), tail);

    tail.getPre().setNext(n);

    tail.setPre(n);

    size++;

    }

    public void remove(Node node) throws Exception {

    Node n = check(node);

    n.getPre().setNext(n.getNext());

    n.getNext().setPre(n.getPre());

    size--;

    }

    public void remove(int index) throws Exception{

    if(index<=size){

    Node target = head;

    for(int i=0;i

    target = target.next;

    }

    this.remove(target);

    }

    }

    public void removeLast(){

    if(size>0){

    Node last = tail.pre;

    last.pre.setNext(last.next);

    last.next.setPre(last.pre);

    size--;

    }

    }

    protected Node check(Node node) throws Exception {

    if (node == null) {

    throw new Exception("节点为空!");

    }

    if (node == head) {

    throw new Exception("节点不能指向头节点!");

    }

    if (node == tail) {

    throw new Exception("节点不能指向尾节点!");

    }

    return node;

    }

    /**

    * 定义了一个类为node,用来存储数据

    * @author Administrator

    */

    private class Node {

    Object item;

    Node pre;

    Node next;

    Node(Object item, Node pre, Node next) {

    this.item = item;

    this.pre = pre;

    this.next = next;

    }

    Node(Object item) {

    this(item, null, null);

    }

    Node() {

    this(null, null, null);

    }

    public Object getItem() {

    return item;

    }

    public void setItem(Object item) {

    this.item = item;

    }

    public Node getPre() {

    return pre;

    }

    public void setPre(Node pre) {

    this.pre = pre;

    }

    public Node getNext() {

    return next;

    }

    public void setNext(Node next) {

    this.next = next;

    }

    }

    }

    打印结果:

    -------------add(int,Object)-------------------

    huangbiao_first2

    add(int,Object)

    addBefore

    huangbiao_first1

    huangbiao_last1

    huangbiao_last2

    -------------getFirst()-------------------

    huangbiao_first2

    huangbiao_last2

    -------------remove(Node)-------------------

    huangbiao_first2

    add(int,Object)

    huangbiao_first1

    huangbiao_last1

    huangbiao_last2

    -------------remove(int)-------------------

    huangbiao_first2

    add(int,Object)

    huangbiao_first1

    huangbiao_last1

    ------------removeLast()--------------------

    huangbiao_first2

    add(int,Object)

    huangbiao_first1

    展开全文
  • Java集合是使程序能够存储和操纵元素不固定的组数据。 所有Java集合都位于java.util包中。 【问】:之前我们需要把多元素放到一起的时候,使用的是数组。那么为何还要提供Java集合工具呢? 我们通过对比...

    1 概述

    Java集合是使程序能够存储和操纵元素不固定的一组数据。 所有Java集合类都位于java.util包中。

    【问】:之前我们需要把多个元素放到一起的时候,使用的是数组。那么为何还要提供Java集合工具类呢? 
    我们通过对比数组和Java集合工具类来解释Java集合工具类的必要性。

    数组

    集合

    长度固定

    长度不固定

    存放任意类型

    不能存放基本数据类型,只能存放对象的引用


    注意:如果集合中存放基本类型,一定要将其 “装箱”成对应的”基本类型包装类”。

    2 Collection

    2.1 继承体系

    Java的集合类主要由两个接口派生而出:Collection和Map。Collection和Map是Java结合框架的根接口,这两个接口又包含了一些子接口或实现类。

    层次结构如图所示

    Java集合类有清晰的继承关系,有很多子接口和实现类。但是,并不是所有子接口或实现类都是最常用的。

    下面我们列举出最常用的几个子接口和实现类:

    Collection ——> List ——> ArrayList类

    Collection ——> List ——> LinkedList类

    Collection ——> Set ——> HashSet类

    Collection ——> Set ——> SortedSet接口 ——> TreeSet类

    Map ——> HashMap类

    Map ——> SortedMap ——> TreeMap类

     2.2 常用方法

     2.3 使用方法

     代码实现    

             // 创建集合对象
            Collection c1 = new ArrayList<>();
            // 判断是否为空,即个数是否为0
            System.out.println(c1.isEmpty());
            // 集合中是不能保存基本类型的,需要转换为对应的包装类才可以
            // 这里会进行自动装箱为Integer类型,然后发生多态转型为Object类型进行存储
            c1.add(123);
            c1.add(new Integer(1));
            c1.add(new Collection_01());
            // 个数
            System.out.println(c1.size());
            System.out.println(c1.isEmpty());
            // 删除,会调用要删除的元素的equals方法,但是Integer覆写了,所以可以把1删除掉
            c1.remove(1);
            A a = new A("张三");
            A a1 = new A("张三");
            c1.add(a);
            // 所以使用集合保存自定义类型的时候,要注意是否要覆写equals方法,定义怎么算相等
            c1.remove(a1);
            // 把集合转换为数组
            Object[] arr = c1.toArray();
            for (Object object : arr) {
                System.out.println(object);
            }
            // 清空集合
            c1.clear();
            System.out.println(c1.size());

    2.4 注意Contains和Remove

    Contains(数据) : 判断集合中是否包含某个元素

    Remove(数据 ) : 删除指定元素

    两个方法底层都会自动调用该对象的equals方法

    因为不管是判断是否包含还是删除,都要先找到这个数据,而找到只能比较

    但是集合中保存的都是引用类型,所以比较只能使用equals方法

    所以如果存储的是自定义类型,就要考虑equals方法的覆写问题

    3 Integer

    3.1 概述

     在面向对象的编程中,迭代器模式是一种设计模式,是一种最简单也最常见的设计模式
     * 它可以让用户透过特定的接口寻访容器中的每一个元素,而不用了解底层的实现
     * 获取该集合的迭代器对象
     * Iterator it=集合对象.iterator();
     *               三个方法:
     *                       1 boolean hasNext():判断下面有没有元素,如果有就返回true,没有就返回false
     *                       2 E next():获取下一个元素,并指向下一个元素
     *                       3 remove(): 删除当前指向的元素
     *              三个方法的使用步骤就是1,2,3,按照这个顺序调用
     *   注意 : 迭代器一旦创建,集合中就不能添加和删除元素(长度就不能更改了)
     *            如果添加或者删除了元素,那么迭代器必须重新生成
     *   增强for循环:就是为了让用iterator循环访问的方式简单,写起来更方便,当然功能不太全,比如删除时还是要用iterator来删除

     3.2 常用方法

     3.3 使用方法

    代码实现    

            Collection c1=new LinkedList();
            c1.add(1);
            c1.add("abc");
            //判断是否包含
            System.out.println(c1.contains(1));
            //1 创建迭代器
            Iterator it=c1.iterator();
            //遍历  判断下面是否有元素
            while(it.hasNext()){
                //获取并指向下一个元素
                Object obj=it.next();
                System.out.println(obj);
            }
            //使用完之后想要再次使用需要重新创建
            it=c1.iterator();
            //迭代器创建之后不能添加和删除,必须重新生成迭代器
            c1.add(2);
            c1.add(3);
            c1.remove(1);
            it=c1.iterator();
            while (it.hasNext()) {
                //获取并指向下一个元素
                Object obj=it.next();
                System.out.println(obj);
                //使用迭代器的时候不能更改集合个数,所以删除数据的时候不能使用集合的删除,应该使用迭代器的删除
                //c1.remove(obj);
                it.remove();
            }
            System.out.println(c1.size()+"-----");

    4 List

    4.1 概述

     * List特点: 有序,可重复
     *               有序: 添加顺序和取出顺序是一致的
     *               可重复: 就是可以有重复的数据
     * ArrayList: 底层是个Object数组,随机查询和更改效率高,但随机添加和删除效率低
     * LinkedList: 底层是一个双向链表,随机查询更该效率低,但随机添加和删除效率高

    4.2 ArrayList

    4.2.1概述

       ArrayList底层是数组,下标从0开始
     *                 默认初始化容量为10,扩大容量为原始容量的1.5倍
     *                 并且默认容量是第一次添加数据的时候设置的
     *            也就是说,我们new ArrayList()的时候,数组长度是为0的
     *                 1.5倍: 长度+长度>>1    

           

     4.2.2基本使用

            //创建对象
            //Vector已经过时了,ArrayList是Vector的升级版,Vector是线程安全,而ArrayList是非线程安全
            List list=new ArrayList();
            list.add(100);
            list.add(123);
            //[100,123]覆写了toString方法
            System.out.println(list);

    4.2.3 常用方法

             //add(E e): 尾部添加
            //add(int index,E e): 添加到指定位置
            //set(int index,E e): 更改指定位置上的元素值
            //remove(Object object): 根据元素内容删除
            //remove(int index): 根据索引删除
            //get(int index): 获取指定位置的数据 

    4.2.4 遍历

        代码实现    

             //传统for遍历
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
            //foreach遍历
            for (Object object:list) {
                System.out.println(object);
            }
            //迭代器遍历
            Iterator it=list.iterator();
            while(it.hasNext()){
                System.out.println(it.next());

    4.3 LinkedList

     4.3.1 基本使用及方法

        和 ArrayList操作 一样

    4.3.2 底层实现

    4.3.2.1 Node节点类

     链表: 保存的都是节点,每个节点都有三个属性,分别是: 添加的数据,上一个节点引用,下一个节点引用

     4.3.2.2LinkedList类

     4.3.2.3 add方法实现

     

     4.3.2.4 Get方法实现

     

     

     获取数据

    Get方法 只是模拟了下标获取数据的方式,本质就是遍历,从头挨个去找

    所以这可以理解为 并不是下标,只是决定了循环次数

    而 ArrayList的get才是根据下标获取

     

     

    展开全文
  • 详解创建一个新的链表

    千次阅读 2020-12-14 15:45:12
    玩贪吃蛇的时候,食物就相当于一个新的结点,而在链表中,有很多对链表的操作,比如说:头插,尾插,排序插,中间插等等你可以想象成,将贪吃蛇吃到的食物是放在,头,尾,或者中间,或者按颜色的顺序进行排列,...

    创建一个单链表

    那什么是单链表?

    1. 简单说一下

    我的理解,其实链表和数组是有很多相似的地方的。链表作为一种数据结构,它是用来存储数据的,举一个很形象的例子,就比如说以前玩的那个贪吃蛇,就是链表的一个很好的应用。在玩贪吃蛇的时候,食物就相当于一个新的结点,而在链表中,有很多对链表的操作,比如说:头插,尾插,排序插,中间插等等你可以想象成,将贪吃蛇吃到的食物是放在,头,尾,或者中间,或者按颜色的顺序进行排列,其实链表不难,理解了之后,写起来也是挺有意思的

    下面是创建一个链表的代码式例

    写的很简单,用了一点c++但大多数还是c的语法,简单来说我的思路是,先创建一个结点(结构体)->然后在主函数里面,获取到屏幕的输入数据后,将此时输入的数据存到一个结点当中->然后将结点串起来,形成一个链表。将结点串起来的方法有很多上面有提到了,就不再重复->最后的最后,就是将链表打印输出了

    #include<iostream>
    
    using namespace std;
    
    struct Node
    {
        int data;
        struct Node * next;
    };
    
    
    int main()
    {
        struct Node * head = nullptr;
        struct Node * tail = nullptr;
        struct Node * pre = nullptr; 
        int data;
        while(1)
        {
            //输入一个数
            cin >> data;
            if(data == 0)
            {
                break;
            }
            //初始化一个结点
            struct Node * pnew = (Node *)malloc(sizeof(Node));
            pnew->data = data;
            pnew->next = nullptr;
    
            //如果只有一个结点
            if(head == nullptr)
            {
                head = pnew;
                tail = pnew;
            }
            else//尾插
            {
                tail->next = pnew;//Tail的下一个指向新的结点 s
                tail = pnew;//让Tail作为新的结点s,即Tail结点往后移
            }
            /*
            头插
            {
            	pnew->next = head;//将新的结点放在Head的前面
            	head = pnew;//Head结点则往前移
            }
    		*/
        }
        //打印链表
        while(head)
        {
            cout << " " << head->data;
            pre = head;
            head = head->next;
            pre->next = nullptr;
            free(pre);//释放堆空间
        }
        cout << endl;
        return 0;
    }
    
    展开全文
  • 【C++】用的方式创建链表

    千次阅读 2019-08-22 21:45:10
    #include<iostream> using namespace std;...class Node //定义一个Node { public: int id, age; //数据域 class Node *next; //指针域 class Node* create1();//创建链表函数1 class ...
  • 【c++程序链表

    2016-05-25 22:12:26
    cout<<"a="<<a<<",b="<<b<<endl; cout<<"***********************************"<<endl; a.next=&b; b.next=&c; c.next=&d; showlist(&a); cout<<endl; cout<<"***********************************"<<endl; ...
  • 1.迭达器接口实现 package com.zhaochao; public interface Iterator { boolean hasNext(); E next(); boolean delete(); boolean modify(E e); int index(); } 2.List接口实现 package
  • 1.Java遍历数组的方法  遍历数组方法较多,如何遍历,只要你喜欢,都可以的。 import java.util.ArrayList; import java.util.Iterator; import java.util.List; /**  * 遍历数组四种方法  * @...
  • 这篇文章是关于C++语言的一个新的扩展——标准模板库的(Standard Template Library),也叫STL。   当我第一次打算写一篇关于STL的文章的时候,我不得不承认我当时低估了这个话题的深度和广度。有很多内容要含盖...
  • 的定义与对象创建2.1 的定义:与`struct`相似(C++)2.2 对象创建/实例化直接创建 \-\- 作为类型定义变量 \-\- 栈上创建动态创建 \-\- 堆上创建动态创建数组 \-\- 堆上创建3\. `this`指针4\. 方法4.1 构造函数1...
  • 2021-01-15

    2021-01-15 14:38:43
    下列描述,错误的是 正确答案: C 你的答案: D (错误) SQL语言又称为结构化查询语言 java”static”关键字表明一个成员变量或者是成员方法可以没有所属的的实例变量的情况下被访问 面向对象开发,引用传递...
  • 面试题答案见微信小程序 “Java精选面试题”,3000+道面试题。内容持续更新包含基础、集合、并发、JVM、Spring、Spring MVC、Spring Boot、Spring Cloud、Dubbo、MySQL、Redis、MyBaits、Zookeeper、Linux、数据...
  • Java 最全面的面试题675道

    万次阅读 2019-01-21 07:21:56
    045_定义一个类名为”MyClass.java”的,并且该可被一个工程的所有访问,那么该的正确声明为()(选择项) 61 046_面向对象的特征有哪些方面?请用生活的例子来描述。 61 047_说明内存泄漏和内存...
  • 基础:Java基础

    2022-04-28 18:03:06
    ‍ 个人主页:花棉袄 本章内容:【基础:Java基础】 ✍ 版权: 本文由【花棉袄】原创CSDN首发需要转载请联系博主
  • JAVA复习笔记

    2021-07-26 17:20:15
    但是计算过程有三数据需要临时找空间存储一下: 这三数据分别是:10 20 30 内存: 程序运行过程当中的临时数据存储空间。 断电之后或者关机之后内存的数据就消失了。 硬盘: ...
  • 、Java的历史与演变 目的:为完全了解Java,需要理解Java的诞生原因、成型动力以及他继承的思想。 计算机语言的创新与发展的原因:适应环境和用途的变化;实现编程艺术的完善和提高。 1.1、Java的家世 Java...
  • JAVA程序设计基础

    千次阅读 2016-02-19 11:19:44
    1章引言... 5 1.1 程序设计语言的分类... 6 1.2 Java的发展过程(网络咖啡)... 7 1.3 Java程序的类型... 7 1.4 编译和执行Java程序... 8 第2章 JAVA2介绍... 9 2.1 什么是JAVA.. 9 2.2选择JAVA的原因......
  • JAVASE整理知识点

    2020-08-14 18:08:07
    软件 : 存储在硬件的数据(可以执行) : 指令+数据的集合. 系统软件 : 操作系统 OS, 让用户能够方便的使用电脑硬件.(没有国产OS) 应用软件 : 为了完成某种功能的软件. 学习java目标就是应用软件. 人机交互 : 人通过...
  • Java实用教程(第5版)参考答案

    万次阅读 多人点赞 2020-04-16 16:14:48
    Java实用教程(第5版)参考答案第1章 Java入门、问答题二、选择题三、阅读程序第2章 基本数据类型与数组、问答题二、选择题三、阅读或调试程序四、编写程序1章 Java入门 、问答题 1.Java语言的主要贡献者...
  • JAVA学习笔记

    2017-10-08 10:19:00
    1,取模:%:取余数. 结果的符号取决于被模数 int i3 = 12 % (-5); //2 int i4 = -12 % (-5); //-2 System.out.println(i3); System.out.println(i4);2,short s = 10; ******************* //s += 3;编...
  • Java基础(1

    千次阅读 多人点赞 2018-11-18 10:59:59
    1、计算机应用 1.1 科学计算 1.2 数据处理 1.3 自动控制 1.4 计算机辅助设计 1.5 人工智能 1.6 多媒体应用 1.7 计算机网络 2、计算机硬件组成部件 运算器、控制器、存储器、输入设备和输出设备。冯诺依曼...
  • 面试零:Java基础

    2020-10-29 08:14:06
    //以下四变量都是成员变量(全局变量) int num ; //属于基本数据类型的实例变量 Integer obj ; //属于引用数据类型的实例变量 static char ch = 'A'; //变量(静态变量) final double constant= 12.6; //
  • 《Java面向对象编程(第2版)》 ... 创建用户自定义的加载器(三)的卸载三、对象的生命周期(创建对象(二)垃圾回收(三)对象的强、弱、软、虚引用(四)内部四、多线程()Java线...
  • Java允许将一个类A声明一个类B,则A就是内部B成为外部。 b. 内部的分类:成员内部(静态的、非静态的) vs 局部内部(方法内、代码块内、构造器内)。 成员内部:一方面,作为外部的...
  • Java面向考点复习

    2020-12-29 10:09:00
    此文转载自:... Java面向考点复习 1.Action event 事件监听方法(鼠标等事件) Event(事件):用户对组件的一次操作称为一个事件,以的形式出现。例如,键盘操作对应的事件是 KeyEvent。Event Sou...
  • java基础

    2021-04-23 19:26:31
    1, OpenJDK 是完全开源的,而Oracle JDK是OpenJDK的一个实现,并不是完全开源的; 2, Oracle JDK 比 OpenJDK 更稳定。OpenJDK和Oracle JDK的代码几乎相同,但Oracle JDK有更多的和一些错误修复。 3, 响应性和JVM...
  • java课后测试题

    千次阅读 2019-06-02 15:00:44
    1、实验楼Linux可以通过(ABC)查看用户登录情况。 A .who B .who am i C .who mom likes D .who are you 2、 Linux 里面如何知道自己属于哪些用户组呢?(A) A .使用 groups 命令 B .addgroups C .查看 /etc/...
  • JAVA基础

    2021-09-24 18:57:14
    这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、...
  • java基础总结(小白向)

    千次阅读 2020-04-04 17:13:51
    对象一个具体实例。 ​ --属性:对象的静态描述 ​ --方法:对象的动态描述(可以是主动也可以是被动的描述) ​ 看似有一点高深,其实翻译成比较容易理解的大白话,就是模板和个体。打个比方...

空空如也

空空如也

1 2 3 4 5
收藏数 96
精华内容 38
关键字:

:编写一个应用程序,在主类test1类中,创建两个链表liste对象,分别存储通过键盘输

友情链接: yuntaicontrol.rar