精华内容
下载资源
问答
  • /***@authoracer**/public classtest_22链表中倒数第k个节点 {/****/publictest_22链表中倒数第k个节点() {//TODO 自动生成的构造函数存根}public static classListNode{private intval;ListNode ...

    /****/

    packagecom.cherish.SwordRefersToOffer;/***@authoracer

    **/

    public classtest_22链表中倒数第k个节点 {/****/

    publictest_22链表中倒数第k个节点() {//TODO 自动生成的构造函数存根

    }public static classListNode{private intval;

    ListNode next= null;

    ListNode(intval){this.val =val;

    next= null;

    }

    }/***@paramargs*/

    public static voidmain(String[] args) {//TODO 自动生成的方法存根

    ListNode head = new ListNode(1);//给一个链表赋值

    for(int i = 2;i<10;i++) {

    insertNodeFromTail(head,newListNode(i));

    }

    printListNode(head);

    System.out.println(FindKthToTail(head,4).val);

    System.out.println(listNodeLength(head));

    System.out.println(deleteFromIndex(head,4));

    printListNode(head);

    System.out.println(listNodeLength(head));

    System.out.println(FindKthToTail(head,4).val);

    }//找到倒数第k个节点

    public static ListNode FindKthToTail(ListNode head,intk) {if(head == null||k <= 0) {return null;

    }

    ListNode p1=head;

    ListNode p2=head;for(int i = 1;i

    p1=p1.next;

    }else{return null;

    }

    }while(p1.next != null) {

    p1=p1.next;

    p2=p2.next;

    }returnp2;

    }//从头部插入新节点

    public static voidinsertNodeFromHead(ListNode head,ListNode newNode)

    {

    newNode.next=head;

    head=newNode;

    }//从尾部插入新节点

    public static voidinsertNodeFromTail(ListNode head,ListNode newNode)

    {if(head == null) {

    head=newNode;return;

    }

    ListNode temp= head;//用temp代替head去遍历找到最后一个节点,一定不要用head自己去遍历,不然就找不到链表头了

    while(temp.next != null) { //下一节点不为空

    temp =temp.next;

    }

    temp.next= newNode;//找到最后一个节点后把新节点插入进去

    }//计算链表的长度

    public static intlistNodeLength(ListNode head) {if(head ==null) {return 0;

    }

    ListNode temp=head;int length = 0;while(temp.next != null) {

    length++;

    temp=temp.next;

    }returnlength;

    }//从特定位置删除链表

    public static boolean deleteFromIndex(ListNode head,intdeleteIndex)

    {if(head == null || deleteIndex<1) {return false;

    }if(deleteIndex == 1) {

    head=head.next;return true;

    }int index = 1;

    ListNode temp=head;

    ListNode deleteNode;while(temp.next != null && index

    index++;

    temp=temp.next;

    }

    deleteNode=temp.next;

    temp.next=deleteNode.next;return true;

    }//按顺序输出链表

    public static voidprintListNode(ListNode head)

    {

    ListNode temp=head;while(temp.next != null)

    {

    System.out.print(temp.val);

    System.out.print("\t");

    temp=temp.next;

    }

    System.out.println();

    }

    }

    展开全文
  • java里面没有指针的说法,所以初始化的时候,就是新建一个null节点就是一个空链表了。//C里面链表会有头指针,头指针指向头节点如果想向空链表插入第一个节点,直接head=newNode;注意的情况是如果想循环链表,一定...

    java里面没有指针的说法,所以初始化的时候,就是新建一个null节点就是一个空链表了。//C里面链表会有头指针,头指针指向头节点

    如果想向空链表插入第一个节点,直接head=newNode;

    注意的情况是

    如果想循环链表,一定新建一个节点把head考出来,然后遍历,不能直接用head遍历

    /**

    * Created by Administrator on 2017-10-27.

    */

    public class linkedListFuns {

    public static void main(String[] arg) {

    Node head = new Node(1);

    for(int i=2;i<10;i++){

    insertFromTail(head,new Node(i));

    }

    printList(head);

    deleteFromIndex(head,3);

    printList(head);

    }

    static class Node {

    int data;

    Node next;

    public Node(int d) {

    data = d;

    next = null;

    }

    }

    //从头节点插入,比较简单不用遍历链表

    public static void insetFromHead(Node head,Node newNode){

    newNode.next=head;

    head = newNode;

    }

    //在尾部插入,要遍历链表

    public static void insertFromTail(Node head1, Node newNode){

    if(head1 == null){ //如果是个空链表,直接把新节点赋值给head,然后结束,要先判断null的情况 其实这是一段错误代码,大家可以查看我另外一篇文章,Java参数引用传递之例外:null

    head1 =newNode;

    return;

    }

    Node temp = head1; //用temp代替head去遍历找到最后一个节点,一定不要用head自己去遍历,不然就找不到链表头了

    while (temp.next!=null){

    temp=temp.next;

    }

    temp.next=newNode;

    }

    //计算链表的长度

    public static int length(Node head){

    int len =0;

    Node temp = head;

    while(temp!=null){

    len++;

    temp=temp.next;

    }

    return len;

    }

    //从特定位置删除一个节点

    public static boolean deleteFromIndex(Node head,int index){

    if(index<1||index>length(head)){ //先判断是否越界

    return false;

    }

    if(index ==1){//如果是删除第一个元素,因为直接涉及到了head所以只能单独处理

    head = head.next;

    return true;

    }

    Node curNode = head;

    for(int curIndex =1;curIndex

    curNode = curNode.next;

    }

    curNode.next=curNode.next.next;

    return true;

    }

    //按照顺序输出一个列表

    public static void printList(Node head){

    Node temp = head;

    while(temp != null){

    System.out.print(temp.data+" ");

    temp = temp.next;

    }

    System.out.println();

    }

    //对链表进行冒泡排序

    public static void orderList(Node head){

    }

    }

    展开全文
  • Java中的数据分为引用数据类型和基础数据类型,在Java中不存在指针的概念,但是对于链表而言的指针,指的就是引用数据类型的地址。链表和数组都是线性的数据结构,对于数组而言其长度是固定的,由于在内存中其是...

    前言

    链表是一种常见的基础数据结构,它是一种线性表,但在内存中它并不是顺序存储的,它是以链式进行存储的,每一个节点里存放的是下一个节点的“指针”。在Java中的数据分为引用数据类型和基础数据类型,在Java中不存在指针的概念,但是对于链表而言的指针,指的就是引用数据类型的地址。

    链表和数组都是线性的数据结构,对于数组而言其长度是固定的,由于在内存中其是连续的,因此更适合做查找与遍历,而链表在内存中是并不是顺序存储的,但是由于其是通过“指针”构成的,因此在插入、删除时比较数组更为的方便。

    下面的代码通过内部类并结合递归的方式来实现了一个简单的用Java语言描述的链表的数据结构,下面话不多说了,来一起看看详细的介绍吧

    链表数据结构的定义

    首先来看一下,链表数据结构的定义,代码如下:

    class NodeManager {

    private Node root; // 根节点

    private int currentIndex = 0; // 节点的序号,每次操作从0开始

    public void add(int data) {}

    public void delNode(int data) {}

    public void print() {}

    public boolean findNode(int data) {}

    public boolean updateNode(int oldData, int newData) {}

    // 向索引之前插入

    public void insert(int index, int data) {}

    // 谁拥有数据,谁提供方法

    class Node {

    private int data;

    private Node next; // 把当前类型作为属性

    public Node(int data) {

    this.data = data;

    }

    public void setData(int data) {

    this.data = data;

    }

    public int getData() {

    return data;

    }

    // 添加节点

    public void addNode(int data) {}

    // 删除节点

    public void delNode(int data) {}

    // 输出所有节点

    public void printNode() {}

    // 查找节点是否存在

    public boolean findNode(int data) {}

    // 修改节点

    public boolean updateNode(int oldData, int newData) {}

    // 插入节点

    public void insertNode(int index, int data) {}

    }

    }

    对于链表的定义来说,NodeManager类是用来管理链表操作的,而成员内部类Node是用于提供链表数据与链式结构的。对于类的使用者来说,并不直接访问数据,因此操作的是NodeManager类,而内部类Node提供了真正的数据管理,因此Node类需要提供真正的数据操作方法,对于NodeManager类中也需要提供一套由外部来操作链表的方法。因此,在NodeManager类和Node类中都提供了看似相同的方法,但实际的意义并不相同。

    下面来查看NodeManager类和Node类中的add()方法,代码如下:

    public void add(int data) {

    if ( root == null ) {

    root = new Node(data);

    } else {

    root.addNode(data);

    }

    }

    // 添加节点

    public void addNode(int data) {

    if ( this.next == null ) {

    this.next = new Node(data);

    } else {

    this.next.addNode(data);

    }

    }

    代码中上面的方法是NodeManager类中的方法,而下面的方法是Node类中的方法。

    在Manager类中提供了一个root的成员变量,它用于管理链表的头节点,因此在添加节点时,会先判断root是否为空,如果为空则直接将节点由root来进行保存,如果root不为空,则通过Node类中的addNode()方法来进行添加,添加到思路是找到当前链表的最后一个节点,并将新添加到节点赋值给最后一个节点的next成员变量中。

    链表增删改查

    对于链表的其他操作也是相同的思路,关于链表增删改查和输出的完整代码如下:

    class NodeManager {

    private Node root; // 根节点

    private int currentIndex = 0; // 节点的序号,每次操作从0开始

    public void add(int data) {

    if ( root == null ) {

    root = new Node(data);

    } else {

    root.addNode(data);

    }

    }

    public void delNode(int data) {

    if ( root == null ) return ;

    if ( root.getData() == data ) {

    Node tmp = root;

    root = root.next;

    tmp = null;

    } else {

    root.delNode(data);

    }

    }

    public void print() {

    if ( root != null ) {

    System.out.print(root.getData() + " ");

    root.printNode();

    System.out.println();

    }

    }

    public boolean findNode(int data) {

    if ( root == null ) return false;

    if ( root.getData() == data ) {

    return true;

    } else {

    return root.findNode(data);

    }

    }

    public boolean updateNode(int oldData, int newData) {

    if ( root == null ) return false;

    if ( root.getData() == oldData ) {

    root.setData(newData);

    return true;

    } else {

    return root.updateNode(oldData, newData);

    }

    }

    // 向索引之前插入

    public void insert(int index, int data) {

    if ( index < 0 ) return ;

    currentIndex = 0;

    if ( index == currentIndex ) {

    Node newNode = new Node(data);

    newNode.next = root;

    root = newNode;

    } else {

    root.insertNode(index, data);

    }

    }

    // 谁拥有数据,谁提供方法

    class Node {

    private int data;

    private Node next; // 把当前类型作为属性

    public Node(int data) {

    this.data = data;

    }

    public void setData(int data) {

    this.data = data;

    }

    public int getData() {

    return data;

    }

    // 添加节点

    public void addNode(int data) {

    if ( this.next == null ) {

    this.next = new Node(data);

    } else {

    this.next.addNode(data);

    }

    }

    // 删除节点

    public void delNode(int data) {

    if ( this.next != null ) {

    if ( this.next.getData() == data ) {

    Node tmp = this.next;

    this.next = this.next.next;

    tmp = null;

    } else {

    this.next.delNode(data);

    }

    }

    }

    // 输出所有节点

    public void printNode() {

    if ( this.next != null ) {

    System.out.print(this.next.getData() + " ");

    this.next.printNode();

    }

    }

    // 查找节点是否存在

    public boolean findNode(int data) {

    if ( this.next != null ) {

    if ( this.next.getData() == data ) {

    return true;

    } else {

    return this.next.findNode(data);

    }

    }

    return false;

    }

    // 修改节点

    public boolean updateNode(int oldData, int newData) {

    if ( this.next != null ) {

    if ( this.next.getData() == oldData ) {

    this.next.setData(newData);

    return true;

    } else {

    return this.next.updateNode(oldData, newData);

    }

    }

    return false;

    }

    // 插入节点

    public void insertNode(int index, int data) {

    currentIndex ++;

    if ( index == currentIndex ) {

    Node newNode = new Node(data);

    newNode.next = this.next;

    this.next = newNode;

    } else {

    this.next.insertNode(index, data);

    }

    }

    }

    }

    以上就是链表基本操作的完整代码,下面写一个调用的代码进行测试,代码如下:

    public class LinkList {

    public static void main(String[] args) {

    NodeManager nm = new NodeManager();

    System.out.println("链表的添加(添加5、4、3、2、1)");

    nm.add(5);

    nm.add(4);

    nm.add(3);

    nm.add(2);

    nm.add(1);

    nm.print();

    System.out.println("链表的删除(删除3)");

    nm.delNode(3);

    nm.print();

    System.out.println("链表的查找(查找1)");

    System.out.println(nm.findNode(1));

    System.out.println("链表的查找(查找10)");

    System.out.println(nm.findNode(10));

    System.out.println("链表的更新(把1更新为10)");

    nm.updateNode(1, 10);

    nm.print();

    System.out.println("链表的插入(在第1个位置插入20)");

    nm.insert(1, 20);

    nm.print();

    System.out.println("链表的插入(在第0个位置插入30)");

    nm.insert(0, 30);

    nm.print();

    }

    }

    将代码编译、运行,结果如下图:

    fa2ff018c463000bb6f5b3d3b5ee19e4.png

    对于Java中的集合类中用到了不少的数据结构的知识,等自己状态好的时候学习学习Java集合类的源码。我会努力做一个初级程序员!

    总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对脚本之家的支持。

    展开全文
  • 链表的实现在很多刚毕业的Java面试中都会提到,分享这篇文章希望对大家会有所帮助。首先出一个链表模型:第一步: 创建空链表 第二步:创建头节点第三部:创建尾节点到此为止 一个比较有完整意义的链表已经构造出 ...

    链表的实现在很多刚毕业的Java面试中都会提到,分享这篇文章希望对大家会有所帮助。

    首先给出一个链表模型:

    3dcffb7b0132e8f0573f591b4f0833c9.png

    第一步: 创建空链表

    a27f81115d3c9e5fac8d0cb00d396956.png

    第二步:创建头节点

    6a8b29a895da42712e9cb8dc1c1e1ac4.png

    第三部:创建尾节点

    4dd88bd1171cc56a4a2c025ca7c24fe7.png

    到此为止 一个比较有完整意义的链表已经构造出

    增加节点

    61a2439d3da6664e6836ce080d006485.png

    删除节点:

    39de964bd06ba8c5d89bc03551e3b1d0.png
    package test; public class LinkList { private Node head; //链表的头节点private Node tail; //链表的尾节点/** * 构造一个空链表 */public LinkList() { head = tail = null;    }  /** * 链表内部的节点类 */private static class Node {  T data;//节点的数据Node next;//该节点的指向下一个节点的指针Node(T data) {     this.data = data;      this.next = null;   }    }  public void addHead(T point) {//为空链表增加头结点    this.head = new Node(point);  if(tail == null) {      tail = head;  }  }  public void addTail(T point){//为链表增加尾节点      tail = new Node(point);      head.next = tail;  }  public void insert(T point) {if (this.head == null) {addHead(point);} else if (this.tail == this.head) {addTail(point);} else {    Node preNext = head.next;  @SuppressWarnings({ "unchecked", "rawtypes" })Node newNode = new Node(point);          preNext = head.next;          this.head.next = newNode;          newNode.next = preNext;  }     }  public void printLinkList() {    //打印链表Node curr = this.head;  if (isEmpty()) {  try {throw new Exception("linklist is empty");} catch (Exception e) {e.printStackTrace();}}while(curr != null){  System.out.print(curr.data+" ");      curr = curr.next;  }  }  public void delete(T data){//删除某一节点Node curr = head, prev = null;boolean suc = false;//是否删除成功标志while (curr != null) {if (curr.data.equals(data)) {//判断是什么节点if (curr == head) {   //如果删除的是头节点System.out.println(''+"delete head node");head = curr.next;suc = true;return;}if (curr == tail) { //如果删除的是尾节点System.out.println(''+"delete tail node");tail = prev;prev.next = null;suc = true;return;} else {//如果删除的是中间节点(即非头节点或非尾节点)System.out.println(''+"delete center node");prev.next = curr.next;suc = true;return;}} prev = curr;curr = curr.next;}if(suc == false) {System.out.println(''+"没有这个数据");}}public boolean isEmpty(){//判断链表是否为空return this.head == null || this.tail == null;    }      public static void main(String[] args) {  LinkList mylist = new LinkList();//构造一个空链表  mylist.insert(5);  mylist.insert(6);  mylist.insert(7);  mylist.insert(3);  mylist.printLinkList();  mylist.delete(1);mylist.printLinkList();  mylist.delete(5);mylist.printLinkList();mylist.delete(6);mylist.printLinkList();      }    } 

    总结:我们可以看到链表在增加节点和删除节点的时候,只需要改变next指针的指向,就能达到我们想要的操作目的。而对于数组来说,增加和删除一个元素都要将目标删除元素后面的每个元素往前移动一位。 如果增删很频繁的话,链表会比数组会更快。对于遍历操作而言,链表需要通过next指针遍历每一个元素,相对于数组遍历直接访问下标来说,会比较慢。 所以在增删比较频繁的时候我们应该考虑是否使用链表这种数据结构。

    展开全文
  • 一 前言之前知识知识追寻...二 双向链表简介双向链表的定义是,一个节点有两个方向,分别储存当前节点的前驱节点,和后续节点;双向链表的删除只需要指定前驱节点,或者后续节点就可以进行删除操作;但是缺点也很明...
  • title单向链表:只包含一个指针的链表。如下图(只有next指针)单向链表单向链表简单代码示例:class Linked{ //链表节点 private static class Node { private E item; private Node next; public Node(E item, Node ...
  • 容器我们平时都经常遇到容器这个词,那么 Java 集合中的容器指的是什么呢?容器就是利用某种特定的数据结构来存储...物理结构就是数据在计算机中是怎么存储的,有数组和链表两种方式。数组是内存中一块连续的存储空...
  • 【本文详细介绍了JAVA应用开发中的链表,欢迎读者朋友们阅读、转发和收藏!】1 基本概念链表是一种数据结构,和数组同级,有单链表和双链表之分。单链表(单向链表):由两部分组成,数据域( Data )和结点域 (Node), ...
  • 对读者的要求:1、不要看到本文写的是链表,就觉得很难,就直接退出,花一点点时间,不敢说让你上来就搞懂链表,但至少你一种思路,就像当初在黑暗中的我看到那微弱的亮光,因为我就是从初学者刚刚过来的,所以还...
  • java -新建list链表赋值的方法总结1、直接初始化并赋值1.1 初始化的同时赋值1.2 先初始化后赋值2、将一个list赋值给另一个list2.1 对象引用的方式赋值2.2 非对象引用的方式赋值 1、直接初始化并赋值 1.1 初始化的...
  • 错误见下面注释处“temp” public class HaTest{ ... ****** //这个地方用node.next赋值明显是对的,但换成temp进行赋值为什么出错 //wrong: temp=new Node(t);****** node.next=new Node(t); } } }
  • (一般在编程题中, 只会初始化,包含data和next属性)其中,getNext()就是获得下一个节点,比如current = current.getNext()的意思,就是current此时被赋值为当前节点的下一个节点class Node:d...
  • 2021-02-04 java实现链表

    2021-02-04 17:24:26
    指定位置新增元素,如果是在头部位置,先初始化节点,将头部节点赋值给这个节点的下一位指针,如果不是头部位置,循环遍历链表找到要插入的位置,将当前节点的下一位指针指向新增节点的下一位指针,然后将新增节点...
  • Java使用链表实现栈

    2017-09-28 18:44:29
    大话数据结构中,这一块其实对于初学的还是挺难的,我看了小半天,最后才...因此每次插入一个,都需要将插入前的栈顶结点赋值给新节点的next结点属性; 每次弹栈,都需要将top的next指向元素置为top元素; 下面上
  • //指向下一个结点}将数据域定义成Object类是因为Object类是广义超类,任何类对象都可以赋值,增加了代码的通用性。为了使链表可以被访问还需要定义一个表头,表头必须包含指向第一个结点...
  • 链表是一种重要的数据结构,在程序设计中占有很重要的地位。C语言和C++语言中是用指针...//指向下一个结点 } 将数据域定义成Object类是因为Object类是广义超类,任何类对象都可以赋值,增加了代码的通用性。为了
  • 今天刷题做到了leetcode#82,做一会又掉进了链表的大坑,总是对链表赋值链表很迷惑,一会儿就绕晕了,因此想总结一下。 正文开始 代码段①: ListNode dummy=new ListNode(); ListNode tail=dummy; dummy为新建的一...
  • 如果想要存储更多的数据我们就需要创建一个新的更大的数组,接着把旧数组的内容传递的到新数组,再加上需要存储的内容,最后把新数组赋值给旧数组(数组扩容思想),这种扩容方式有很慢,且很浪费内存,效果很不好;...
  • 实验踩坑记录:Java迭代器iterator无法remove、remove失败原因以及Iterator源码分析第一个坑在软件构造Lab2实验过程中遇到一个问题,调用Set的iterator.remove函数时无法删除,且未报错,但是单步运行时发现所比较...
  • Java 链表操作

    2017-05-02 15:19:11
    转自:... public Node head; public Node current; //方法:向链表中添加数据 public void add(int data){ if(head==null){//如果头节点为空,说明这个链表还没创建。把新的结点赋值给头节点
  • 将第一个结点赋值给p;循环:将下一结点赋值给q;释放p;将q赋值给p;实现代码如下:/* 初始条件:顺序线性表L已存在。操作结果:将L重置为空表 */Status ClearList(LinkList *L){LinkList p,q;p=(*L)->next; ...
  • Java链表类LinkedList

    2019-12-23 18:22:26
    Java提供了LinkedList<E>链表类,它是实现了泛型接口List<E>的泛型类,而泛型接口List<...我们可以利用接口回调把LinkedList对象赋值给List或者Collection接口对象,接口就可以直接调用类实现的接口...
  • 一、什么是链表集合,通过图形来看,比如33只知道它下一个是55如果:现在要删除33的话,就是把55赋值给45,这样看它操作集合速度会非常快。二、LinkedList特有方法1、添加addFirst();addLast();jdk1.6offerFirst();...
  • JAVA数组与链表

    2020-12-08 17:05:49
    首先来看如何在java使用数组,数组的使用主要就是四个步骤:声明数组、分配空间、赋值、处理。 声明数组:就是告诉计算机数组的类型是什么。有两种形式:int[] array、int array[]。 分配空间:告诉计算机需要
  • JAVA实现简单链表操作

    2016-12-20 15:29:00
    Java语言中的对象引用实际上是一个指针,所以我们可以编写这样的类来实现链表中的结点。 class Node { Object tData; Node next;//指向下一个结点 } 将数据域定义成Object类是因为Object类是广义...
  • 含义:将某个变量(对象)赋值给指针(引用),实际上就是就是将这个变量(对象)的地址赋值给指针(引用)。2.示例:p—>next = q; 表示p节点的后继指针存储了q节点的内存地址。p—>next = p—>next—>next; ...
  • java 中创建链表 ListNode

    千次阅读 2018-11-04 17:42:13
    class ListNode { 2 //为了方便,这两个变量都使用pub1ic, 3 //存放数据的变量,直接为int型 4 public int data; 5 //存放结点的变量,默认为...7 //构造方法,在构造时就能够data赋值 8 public ListNode () { ...
  • JAVA如何使用链表

    千次阅读 2007-07-25 13:57:00
    //定义一个链表类,与其它类一样,包括成员变量和成员函数等。//成员变量可以是对象的引用,成员函数包括通过构造函数对变量赋值,也包括通过一般的方法为成员函数赋值或者是返回...可以赋值为一个对象。protecte
  • 15.反转链表 Java

    2019-10-08 17:10:42
    本题的关键就是在于对next域的赋值,同时对下一个节点进行保存,然后对把下一个节点赋新的节点,这样依次循环完所有的节点。每次使新插入的节点变成头第一个有效节点。 public ListNode ReverseList(ListNode ...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

java给链表赋值

java 订阅