精华内容
下载资源
问答
  • } } 输入一组数据,然后输入一个数插入到原链表,不用考虑大于第一个节点和小于最后一个节点的情况,我现在只要实现这个功能。不管我输入什么数,都只会按原样输出,如先输入1,3,5。输入2插入,可是输出是1,3,5...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    include

    #include

    struct student

    {

    int data;

    struct student *next;

    };

    void main()

    {

    int n=0;

    struct student *head,*p1,*p2,*p,*q;

    p1=p2=(struct student *) malloc (sizeof(struct student));

    scanf("%d",&p1->data);

    head=NULL;

    while(p1->data!=0)

    {

    n=n+1;

    if(n==1)

    head=p1;

    else

    p2->next=p1;

    p2=p1;

    p1=(struct student *) malloc (sizeof(struct student));

    scanf("%d",&p1->data);

    }

    p2->next=NULL;

    printf("input the number to insert:\n");

    p=(struct student *) malloc (sizeof(struct student));

    scanf("%d",p->data);

    p1=head;

    while((p->data>p1->data)&&(p1->next!=NULL))

    {

    q=p1;

    p1=p1->next;

    }

    if(p->data<=p1->data)

    {

    q->next=p;

    p->next=p1;

    }

    n=n+1;

    p=head;

    while(p!=NULL)

    {

    printf("%d",p->data);

    p=p->next;

    }

    }

    输入一组数据,然后输入一个数插入到原链表,不用考虑大于第一个节点和小于最后一个节点的情况,我现在只要实现这个功能。不管我输入什么数,都只会按原样输出,如先输入1,3,5。输入2插入,可是输出是1,3,5。高手看看那错了

    展开全文
  • 分析过程:首先需要比较待添加节点编号与已有的节点编号的大小,若待添加节点编号已经存在,则不能加入。为防止出现空指针的情况,需要对节点的位置进行判断。示例代码:package linkedlist;public class ...

    分析过程:

    首先需要比较待添加的节点编号与已有的节点编号的大小,若待添加的节点编号已经存在,则不能加入。为防止出现空指针的情况,需要对节点的位置进行判断。

    示例代码:

    package linkedlist;

    public class DoubleLinkedListDemo {

    public static void main(String[] args) {

    // 测试

    System.out.println("双向链表的测试");

    // 创建节点

    Node node1 = new Node(1, "道明寺");

    Node node2 = new Node(2, "花泽类");

    Node node3 = new Node(3, "西门总二郎");

    Node node4 = new Node(4, "美作玲");

    // 创建一个双向链表

    DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

    // 添加节点

    doubleLinkedList.addByOrder(node1);

    doubleLinkedList.addByOrder(node4);

    doubleLinkedList.addByOrder(node3);

    doubleLinkedList.addByOrder(node2);

    // 显示排序后的双向链表

    doubleLinkedList.list();

    }

    }

    // 创建一个双向链表的类

    class DoubleLinkedList {

    // 先初始化头节点,头节点不动

    private Node head = new Node(0, "");

    // 返回头节点

    public Node getHead() {

    return head;

    }

    // 添加节点时,根据编号将节点插入到指定位置

    // 如果有这个编号,则添加失败,并给出提示

    public void addByOrder(Node node) {

    // 头节点不能动,通过一个辅助指针(变量)帮助找到需要添加的位置

    Node temp = head;

    boolean flag = false;// flag标志添加的编号是否存在,默认为false

    while(true) {

    if(temp.next == null) {

    break;

    }

    if(temp.next.no > node.no) {

    break;

    }

    if(temp.next.no == node.no) {

    flag = true;

    break;

    }

    temp = temp.next;// 遍历链表

    }

    if(flag) {

    System.out.printf("输入的编号%d已经存在,不能加入\n", node.no);

    }

    else {

    // 为防止出现空指针的情况,需要对temp节点位置进行判断

    // 若双向链表尚未到达尾端,则需要将node节点与其相邻的后面的节点进行连接

    if(temp.next != null) {

    node.next = temp.next;

    temp.next.pre = node;

    }

    // 无论双向链表是否到达尾端,都需要将node节点与其相邻的前面的节点进行连接

    temp.next = node;

    node.pre = temp;

    }

    }

    // 遍历双向链表的方法

    // 显示链表【遍历】

    public void list() {

    // 判断链表是否为空

    if(head.next == null) {

    System.out.println("链表为空");

    return;

    }

    // 因为头节点不能动,需要一个辅助变量来遍历

    Node temp = head.next;

    while (true) {

    // 判断是否到链表最后

    if(temp == null)

    break;

    // 输出节点的信息

    System.out.println(temp);

    // 将temp后移

    temp = temp.next;

    }

    }

    }

    // 创建一个双向链表的类

    // 定义Node,每个Node对象就是一个节点

    class Node {

    public int no;

    public String name;

    public Node next;// 指向下一个节点,默认为null

    public Node pre;// 指向前一个节点,默认为null

    // 构造器

    public Node(int no, String name) {

    this.no = no;

    this.name = name;

    }

    // 为了显示方便,重新toString

    @Override

    public String toString() {

    return "Node [no=" + no + ",]";

    }

    }

    运行结果运行结果

    21f3f18b8c057fbe5d1dd3c70fdf5010.png

    总结

    到此这篇关于Java双向链表按照顺序添加节点的文章就介绍到这了,更多相关Java双向链表按照顺序添加节点内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

    郑重声明:本文版权归原作者所有,转载文章仅为传播更多信息之目的,如作者信息标记有误,请第一时间联系我们修改或删除,多谢。

    展开全文
  • 本文实例讲述了Java链表添加元素的原理与实现方法。分享给大家供大家参考,具体如下:1.链表中头节点的引入1.1基本的链表结构:1.2对于链表来说,若想访问链表中每个节点则需要把链表的头存起来,假如链表的头节点...

    本文实例讲述了Java链表中添加元素的原理与实现方法。分享给大家供大家参考,具体如下:

    1.链表中头节点的引入

    1.1基本的链表结构:

    c5b5mwgkgyu.jpg

    1.2对于链表来说,若想访问链表中每个节点则需要把链表的头存起来,假如链表的头节点为head,指向链表中第一个节点,如图:

    5c2bcf47fb8554caaabe90488e7807cd.png

    1.3使用代码表示此时的链表

    //定义头节点

    private Node head;

    //节点个数

    private int size;

    //无参数构造函数

    public LinkedList() {

    head = null;

    size = 0;

    }

    //获取链表中的元素个数

    public int getSize() {

    return size;

    }

    //返回链表是否为空

    public boolean isEmpty() {

    return size == 0;

    }

    2.在链表头添加元素

    2.1初始时,假设链表如下:

    b76c252fdf14658ceb504310de1f782c.png

    2.2 如在链表头添加一个666元素则需要先将666放进一个节点里,在节点里存入这个元素以及相应的next。

    5vkztvuw2w3.jpg

    操作如下:

    第一步:现将666这个节点(node)的next指向head,代码如下:

    node.next=head

    图示为:

    v5jv0b1wngg.jpg

    第二步:然后再将head指向新的节点666

    head=node

    图示为:

    d3wszbpzyqg.jpg

    通过第一步、第二步,我们就成功将新节点添加到头节上。此时node这个变量也就结束了此轮的工作,结果变为:

    40taj50uqqr.jpg

    2.3 在链表头添加新元素的相关代码

    //在链表头添加新的元素e

    public void addFirst(E e) {

    Node node = new Node(e);

    node.next = head;

    head = node;

    size++;

    }

    等同于:

    //在链表头添加新的元素e

    public void addFirst(E e) {

    head = new Node(e, head);

    size++;

    }

    2.4 在链表中间添加元素

    假设初始链表为:

    09250d5e782f559b1198c18772fe076b.png

    假设我们需要在索引为2的位置添加元素666(此时的索引为2只是用来说明我们此时需要操作的位置,并不是真正的索引意思)

    操作步骤:

    1):创建出666这个节点

    2y3bcvtetkt.jpg

    2):使用一个变量prev来标识在需要插入节点的地方的前一个节点,初始时prev和头节点head是相同的。

    iujrfzin5p0.jpg

    对于此处我们需要在索引为2的位置插入新元素,我们只需要找到索引为2的前一个位置(索引为1),然后把prev指向索引为1节点即可。

    o4j5exwrfgr.jpg

    3):进行元素添加操作

    第一步:先将node的next指向prev的下一个节点元素

    node.next=prev.next

    rhe15jwinny.jpg

    第二步:再将prev的next指向node

    prev.next=node

    i0p5k1pcccb.jpg

    通过第一步、第二步即可将新元素插入到索引为2的地方。

    从上不难看出,对于在链表中添加元素关键是找到要添加的节点的前一个节点,因此对于在索引为0的节点添加元素就需要单独处理。

    关于在链表中间添加元素的代码:

    //在链表的index(0--based)的位置添加新的元素e (实际不常用,练习用)

    public void add(int index, E e) {

    if (index < 0 || index > size) {

    throw new IllegalArgumentException("位置不合法");

    }

    //对于头节点的特殊处理

    if (index == 0) {

    addFirst(e);

    } else {

    Node prev = head;

    for (int i = 0; i < index - 1; i++) {//获取到需要添加元素位置的前一个元素

    prev = prev.next;

    }

    Node node = new Node(e);

    node.next = prev.next;

    prev.next = node;

    size++;

    }

    }

    此时代码等同于:

    //在链表的index(0--based)的位置添加新的元素e (时间不常用,练习用)

    public void add(int index, E e) {

    if (index < 0 || index > size) {

    throw new IllegalArgumentException("位置不合法");

    }

    //对于头节点的特殊处理

    if (index == 0) {

    addFirst(e);

    } else {

    Node prev = head;

    for (int i = 0; i < index - 1; i++) {//获取到需要添加元素位置的前一个元素

    prev = prev.next;

    }

    // Node node = new Node(e);

    // node.next = prev.next;

    // prev.next = node;

    prev.next=new Node(e,prev.next);

    size++;

    }

    }

    3.在链表尾部添加元素

    这里复用上述的add()方法

    //在链表末尾添加新的元素

    public void addLast(E e){

    add(size,e);

    }

    本小节完整代码:

    package LinkedList;

    public class LinkedList {

    //将Node节点设计成私有的类中类

    private class Node {

    public E e;

    public Node next;

    //两个参数的构造函数

    public Node(E e, Node next) {

    this.e = e;

    this.next = next;

    }

    //一个参数的构造函数

    public Node(E e) {

    this.e = e;

    this.next = null;

    }

    //无参构造函数

    public Node() {

    this(null, null);

    }

    @Override

    public String toString() {

    return e.toString();

    }

    }

    //定义头节点

    private Node head;

    //节点个数

    private int size;

    //无参数构造函数

    public LinkedList() {

    head = null;

    size = 0;

    }

    //获取链表中的元素个数

    public int getSize() {

    return size;

    }

    //返回链表是否为空

    public boolean isEmpty() {

    return size == 0;

    }

    //在链表头添加新的元素e

    public void addFirst(E e) {

    head = new Node(e, head);

    size++;

    }

    //在链表的index(0--based)的位置添加新的元素e (实际不常用,练习用)

    public void add(int index, E e) {

    if (index < 0 || index > size) {

    throw new IllegalArgumentException("位置不合法");

    }

    //对于头节点的特殊处理

    if (index == 0) {

    addFirst(e);

    } else {

    Node prev = head;

    for (int i = 0; i < index - 1; i++) {//获取到需要添加元素位置的前一个元素

    prev = prev.next;

    }

    // Node node = new Node(e);

    // node.next = prev.next;

    // prev.next = node;

    prev.next=new Node(e,prev.next);

    size++;

    }

    }

    //在链表末尾添加新的元素

    public void addLast(E e){

    add(size,e);

    }

    }

    更多关于java算法相关内容感兴趣的读者可查看本站专题:《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

    希望本文所述对大家java程序设计有所帮助。

    展开全文
  • 设计一个Java程序,来实现单向链表添加节点的过程,并且允许可以链表头部、链表末尾和链表中间三种不同位置插入新节点。 package LinkList; public class Node1 { int data; Node1 next; public Node1(int ...

    设计一个Java程序,来实现单向链表添加节点的过程,并且允许可以在链表头部、链表末尾和链表中间三种不同位置插入新节点。

    package LinkList;
    
    public class Node1 {
    	int data;
    	Node1 next;
    	public Node1(int data) {
    		this.data=data;
    		this.next=null;
    	}
    }
    
    
    package LinkList;
    
    public class insert {
    	public Node1 first;
    	public Node1 last;
    	public boolean isEmpty(){
    		return first==null;
    	}
    	public void print() {
    		Node1 current=first;
    		while(current!=null) {
    			System.out.print("["+current.data+"]");
    			current=current.next;
    		}
    		System.out.println();
    	}
    	public insert Concatenate(insert head1,insert head2) {
    		insert ptr;
    		ptr=head1;
    		while(ptr.last.next!=null) ptr.last=ptr.last.next;
    		ptr.last.next=head2.first;
    		return head1;
    	}
    	public void insert(Node1 ptr) {
    		Node1 temp;
    		Node1 newNode;
    		if(this.isEmpty()) {
    			first=ptr;
    			last=ptr;
    		}else {
    			if(ptr.next==first) {
    				ptr.next=first;
    				first=ptr;
    				
    			}else {
    			if(ptr.next==null) {
    				last.next=ptr;
    				last=ptr;
    			}else {
    				temp=first;
    				newNode=first;
    				while(ptr.next!=newNode.next) {
    					temp=newNode;
    					newNode=newNode.next;
    				}
    				temp.next=ptr;
    				ptr.next=newNode;
    			}
    			}
    			
    		}
    	}
    	
    	
    }
    
    
    package LinkList;
    
    public class InsertTest {
    	public static void main(String args[]) {
    		insert list1=new insert();
    		insert list2=new insert();
    		Node1 node1=new Node1(5);
    		Node1 node2=new Node1(6);
    		list1.insert(node1);
    		list2.insert(node2);
    		Node1 node3=new Node1(7);
    		Node1 node4=new Node1(8);
    		list2.insert(node3);
    		list2.insert(node4);
    		list1.Concatenate(list1, list2);
    		list1.print();
    		
    	}
    }
    
    
    展开全文
  • 我试图一个链接列表的“索引”位置插入一个节点“item”,我有以下代码,对我来说这听起来不错,但它不能正常工作。如果有人能帮我,我会非常感激的。class Node:def __init__(self,initdata):self.data = ...
  • 一、概念梳理链表是计算机科学里面应用应用最广泛的数据结构之一。它是最简单的数据结构之一,同时也是比较高阶的数据结构(例如棧、环形缓冲和队列)简单的说,一个列表就是单数据通过索引集合一起。C里面这叫做...
  • 文章目录单向链表1.尾部添加节点思路分析代码实现注意事项2.按照序号插入新节点思路分析 单向链表 使用带 head 头的单向链表实现:...定义单向链表类,初始化一个头节点,整型数据初始化为0,字符类型数据初始化为空
  • 这里我们要来实现某个位置插入节点。示例代码上传至https://github.com/chenyufeng1991/InsertList 。核心代码如下:Node *InsertToPosition(Node *pNode,int pos,int x){if (pos < 0 || p...
  • linux链表之:使用for循环添加链表、list_add、list_add_tail使用for循环,向链表添加10个节点如果使用list_add,则将节点添加到链表头,那么使用后面的list_for_each打印时,便是倒着的:***********************...
  • 实验需求:链表打印出来后,在节点数据'4'和节点数据'6'之后插入一个节点,插入节点数据分别是'100'和'99'。 */ #include <stdio.h> #include <stdlib.h> #define ERROR 1 #define SUCCESS 0 ...
  • * 双向链表:一个字段存放数据,两个字段存放指针,一个指针指向后面的节点,另一个指针指向前面的节点 * llink-data-rlink * 插入:第一个位置插入:将新节点的右链接指向原表的第一个节点,左链接指向null *...
  • 双向链表 您如何一次找到LinkedList的中间元素是一个编程问题,电话采访中经常被问到Java和非Java程序员。 这个问题类似于检查回文或计算阶乘,有时Interviewer还会要求编写代码。 为了回答这个问题,候选人必须...
  • 下面是自己实现的一个类似于LinkedList类,其中getMidNode方法是获取链表中间节点的实现方法(未知列表长度的情况下),大致思路如下:1、首先方法中定义temp 、temp2两个局部变量。2、temp每次循环next一次,...
  • 一、由图可以看出,单项循环链表和普通单链表的区别在于尾节点,普通单链表的为节点指向一个空的位置,表示这个节点链表的族最末端,而循环链表的尾节点则指向该链表的头结点,形成一个环状结构,首尾相连。...
  • 1、指针链表 先看一道题目 【问题描述】 输入n个数据,建立带有头结点的单链表,并将建立好的单链表中的数据从头至尾遍历输出(要求输出数据的顺序与输入数据的顺序一致)。 【输入形式】 输入两行 第一行为...
  • C语言实现在链表某个位置插入元素

    千次阅读 2021-03-07 22:43:48
    void InsertFromList( Node *pHead, int Index, int Value ) { Node *pIter = pHead; for( int i = 0; i < Index && nullptr != pIter; ++i, pIter = pIter->mpNext ); ... ..
  • C语言实现有序链表中插入新的节点 节点结构 struct node { int data; node *next; }; 插入函数(保持有序) //链表中插入节点(保持链表升序关系) node *insert(node *head, node *p) {//头节点 ,p指向要插入的...
  • 有空头链表介绍特点链表的创建空头的创建节点计数器的建立链表添加添加释放链表 介绍 特点 1)第一个节点不装数据作为链表头(永远不变),从第二个节点开始有数据 2)不使用尾指针,涉及尾部,循环寻找;目的是...
  • 为了回答这个问题,候选人必须熟悉LinkedList的数据结构,即单个LinkedList的情况下,链表的每个节点都包含数据和指针,这是下一个链表的地址,而单个链表的最后一个元素指向空值。因为要找到链接列表的中间元素,...
  • 插入时,要考虑双向链表为空的情况下插入、节点,尾节点插入时、插入位置不合法时的情况。 测试代码时,应该测试头节点,尾节点中间节点的元素插入。避免出现bug。 如果不懂,就多画图理解!!! 二、...
  • 新建单向链表、遍历链表及新节点插入(头部、尾部、任意位置) 一、单向链表属于叫复杂的数据结构,C语言编程中应用广泛。...从链表中间插入节点; // 3.从链表尾部插入节点; #include <stdio.h> #incl.
  • 876.链表中间节点

    2021-04-22 08:55:54
    题目给定节点在100个以内,所以用正常的数组和ArrayList都行。 Class Solution{ public ListNode middleNode(ListNode head){ List<ListNode> arr = new ArrayList(); int len = 0; while(head!=null){ ...
  • 单向链表基本概括二级目录三级目录 基本概括 链表的常用结构主要成分有空头有链表与无空头链表 二级目录 三级目录
  • 数据结构双向链表

    2021-08-08 17:54:49
    在上一篇博客中在下介绍了单链表的一些操作,那么这篇博客里边我就着重讲一下双向链表,至于为什么没有说链表的循环什么的,这个放在我的下一篇博客里说,这里呢也给我自己立一个flag,下一篇的博客我就重点说...
  • 链表在插入和删除数据时,时间复杂度(即执行算法所需要的计算工作量)可以达到O(1),相对数组效率高许多。 链表相对于数组的缺点在于: 链表访问任何一个位置的元素时,都需要从头开始访问 无法像数组一样通过下...
  • 日常开发中,常常会用到数据集合,那么数据集合是什么呢,数据集合也没有想象中那么复杂。 数据集合就是专门用来存储数据、检索数据,以及对数据一系列操作的类。 这些类有:ArrayList数组、List列表、Queue队列、...
  • 首先我们了解一下什么是链表链表数据存储一种单独的数据结构中,这个结构通常叫做“节点”,对于链表来说,节点通常只有两部分内容,e:存储的数据,next:链表中的节点通过next指向下一个节...
  • 2.链表在逻辑上是有序的 3.链表在实际的内存中不一定是连续的 4.链表有带头结点和不带头结点的两种实现 本文主要讲解单向带头结点的链表增删改查操作 链表的逻辑结构图 链表的内存示意图 代码实现 如果代码不太好...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,988
精华内容 24,395
关键字:

在链表中间添加节点