精华内容
下载资源
问答
  • //向循环有序链表插入一个值 //…… struct ListNode { int val; ListNode* next; ListNode(int x):val(x),next(NULL){} }; ListNode* insertNodeToList(ListNode* LNode,ListNode* pNode) { //1.循环链表为...
    //向循环有序链表插入一个值
    
    //……
    struct ListNode
    {
    	int val;
    	ListNode* next;
    	ListNode(int x):val(x),next(NULL){}
    };
    
    ListNode* insertNodeToList(ListNode* LNode,ListNode* pNode)
    {	
    	//1.循环链表为空,新插入节点,首尾相连
    	if(LNode==NULL)
    	{
    		pNode->next=pNode;
    		return PNode;
    	}
    
    	ListNode* preNode=LNode;
    	ListNode* p=preNode->next;
    
    	do
    	{
    		//2.头尾之间插节点,升序
    		//3.尾头之间插节点,大于尾节点,或者小于头节点
    		if(preNode->val <= pNode->val && pNode->val <= p->val) break;
    		else if(preNode->val >= p->val && (pNode->val >= preNode || pNode->val <=p->val)) break;
    		else
    		{
    			preNode=preNode->next;
    			p=p->next;
    		}				
    	}while(preNode!=LNode)
    
    	//插入节点
    	preNode->next=pNode;
    	pNode->next=p;
    	
    	return LNode;
    }
    
    
    展开全文
  • 有序链表插入讲解.zip

    2020-07-29 09:16:09
    有利于新手学习c语言,为以后的语言以及实战使用打下坚实的基础。以供大家学习。欢迎大家下载使用,好好学习研究,早日成为一方大牛。
  • 599. 向循环有序链表插入节点 给一个来自已经排过序的循环链表的节点,写一个函数来将一个值插入到循环链表中,并且保持还是有序循环链表。给出的节点可以是链表中的任意一个单节点。返回插入后的新链表。 样例 ...

    599. 向循环有序链表插入节点

    给一个来自已经排过序的循环链表的节点,写一个函数来将一个值插入到循环链表中,并且保持还是有序循环链表。给出的节点可以是链表中的任意一个单节点。返回插入后的新链表。

    样例

    给一个链表:3->5->1
    插入值 4
    返回 5->1->3->4

    注意事项

    3->5->1 是一个循环链表,所以 3 是 1 的下一个节点。3->5->1 与 5->1->3 相同

    实现代码:

    """
    Definition of ListNode
    class ListNode(object):
    
        def __init__(self, val, next=None):
            self.val = val
            self.next = next
    """
    
    
    class Solution:
        """
        @param: node: a list node in the list
        @param: x: An integer
        @return: the inserted new list node
        """
        def insert(self, node, x):
            # write your code here
            new_node = ListNode(x)
            
            if node is None:
                node = new_node
                node.next = node
                return node
            
            #定义当前结点和前一节点
            cur, pre = node, None
            
            while cur:
                pre = cur
                cur = cur.next
                #   pre.val <= x <= cur.val
                if x <= cur.val and x >= pre.val:
                    break
                
                #链表循环处特殊判断(最大值->最小值),如果x小于最小值或x大于最大值,在此处插入
                if pre.val > cur.val and (x < cur.val or x > pre.val):
                    break
                
                #循环了一遍了
                if cur is node:
                    break
            
            #插入该结点
            new_node.next = cur
            pre.next = new_node
            
            return new_node
                
    

     

                
     

    展开全文
  • 题目:将值为value的节点node插入有序环形链表中(头节点head) 思路: 分以下情况: (1)head==null,即链表为空,那么node.next=next,返回node。 (2)链表不为空,pre=head,cur=head.next;两个同步向后找,...

    题目:将值为value的节点node插入有序环形链表中(头节点head)


    思路:

    分以下情况:

    (1)head==null,即链表为空,那么node.next=next,返回node。

    (2)链表不为空,pre=head,cur=head.next;两个同步向后找,直到pre<node<cur,将node插入两者中间

    (3)如果没找到(2),node要插入head前面,有两种情况:node>cur,node<head,其中后者返回node节点作为新头结点,因为要维持环形链表有序这一特性。


    牛客该题的后台测试序列有问题,它是把期看成单链表而不是循环链表了

    有一个整数val,如何在节点值有序的环形链表中插入一个节点值为val的节点,并且保证这个环形单链表依然有序。

    给定链表的信息,及元素的值A及对应的nxt指向的元素编号同时给定val,请构造出这个环形链表,并插入该值。


    /*
    public class ListNode {
        int val;
        ListNode next = null;
    
        ListNode(int val) {
            this.val = val;
        }
    }*/
    public class InsertValue {
        public ListNode insert(int[] a, int[] nxt, int val) {
            // write code here
            
            ListNode node=new ListNode(val);
            if(a==null) {//初始为空链表
                node.next=node;
                return node;
            }
            
            ListNode head=new ListNode(a[0]);
            ListNode cur=head;
            ListNode pre=head;
            for(int i=0;i<a.length-1;i++){//构造环形链表
                cur.next=new ListNode(a[nxt[i]]);
                
                cur=cur.next;
            }
            cur.next=head;
    
            
            if(val<head.val){//插入值小于头结点值
                node.next=head;
                cur.next=node;
                return node;
            }
            
            if(val>=cur.val){//插入值大于等于尾节点值
                cur.next=node;
                node.next=head;
                return head;
            }
            
            pre=head;
            cur=head.next;
            
            while(cur!=head){//普遍情况
                if(val>=pre.val&&val<cur.val){
                    pre.next=node;
                    node.next=cur;
                    break;
                }
                pre=cur;
                cur=cur.next;
            }
            return head;
        }
    }


    展开全文
  • 链表:包含一些数据的独立的数据结构(通常称为节点)的集合。 单链表 根指针记录链表的起始位置,根指针指向链表的第一个节点,注意根指针只是一个指针,它不包含任何数据 最后一个节点的指针字段值为NULL,提示...

    链表:包含一些数据的独立的数据结构(通常称为节点)的集合。

    单链表

    根指针记录链表的起始位置,根指针指向链表的第一个节点,注意根指针只是一个指针,它不包含任何数据

    最后一个节点的指针字段值为NULL,提示链表后面不再有任何节点。

    用结构体创建一个简单的节点数据结构Node

    typedef struct NODE {
            struct NODE *link;
            int          value;
    }Node;

    插入新节点到有序的单链表

    #include <stdlib.h>
    #include <stdio.h>
    #include "sll_node.h"
    
    #define FALSE 0
    #define TRUE  1
    
    //register关键字可以将变量放到寄存器,提高速度
    //linkp是指向根节点指针root的一个指针
    sll_insert( register Node **linkp,int new_value)
    {
        register Node *current;
        register Node *new;
    
        /*
        **寻找正确的插入位置,按序访问链表,直到到达一个值大于或等于新值的节点
        */
        while((current = *linkp) != NULL &&
                current->value < new_value)//这里先要检查当前节点current没到链表结尾不是NULL
           linkp = &current->link;         //然后才能去访问current的值
                                           //linkp是根节点的指针可以让值插入到根节点之后
        /*
        **为新节点分配内存,如果分配失败,返回FALSE
        */
        new = (Node *)mallco(sizeof(Node));
        if(new == NULL)
            return FALSE;
        new->value = new_value;
    
        /*
        **在链表中插入新节点,返回TRUE
        */
        new->link = current;
        *linkp = new;
        return TRUE;
    }

    双链表

    定义节点

    typedef struct NODE {
            struct NODE* pre;
            struct NODE* bwd;
            int          value;
    }Node;
    

    编写一个函数插入有序的双链表中

    #include <stdlib.h>
    #include <stdio.h>
    #include "double_liked_list_node.h"
    
    int dll_insert(register Node * rootp,int value )
    {
        register Node *this;
        register Node *next;
        register Node *newnode;
    
        for(this = rootp; (next = this->fwd)!=NULL; this = next){
            if(next->value == value) return 0;
            if(next->value >  value)    break;
        }
        newnode = (Node*)malloc(sizeof(Node));
        if( newnode == NULL )
             return -1;
        newnode->value = value;
    
        newnode->fwd = next;
        this->fwd    = newnode;
    
        if(this != rootp)
            newnode->bwd = this;
        else
            newnode->bwd = NULL;//根指针的值为空只是个指针,
                                //因此newnode是第一个节点的话bwd就是NULL
    
        if(next != NULL)
            next->bwd = newnode;
        else
            rootp->bwd = newnode;
    }

     

    展开全文
  • 用指向指针的指针,减少了一个指向插入节点之前的指针,值得研读。插入 static int notifier_chain_register(struct notifier_block **nl, struct notifier_block *n){ while ((*nl) != NULL) { if (n->priority...
  • 两个有序链表合并 链表插入 删除 修改等
  • 有序链表插入函数

    2019-06-16 21:43:04
    创建一个节点 ...调用有序链表插入函数: //插入到一个有序链表。函数的参数是一个指向链表根指针的指针,以及一个需要插入的新值 result=sll_insert(&root,12); 插入函数1 #include <st...
  • 有序链表插入

    千次阅读 2017-11-07 20:36:28
    7-1 有序链表插入(20 分) 已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新整数插入到L中,并保持L的有序性。其中单链表的类型定义参考如下: typedef int elementType; typedef ...
  • 题目:给定一个整数num,如何在节点有序的环形链表插入一个节点值为num的节点,并保证这个环形链表依然有序。(假如链表是升序) 解决思路: 1.如果链表为空,则开辟一个节点,让后让他自己指向自己,然后返回该...
  • 有序链表

    2016-09-05 22:44:46
     在有序链表插入一个数据项,可以采用之前的插入排序的思想,通过局部有序实现数据的排序。插入数据通常在链表中有三种方式:在链表头部、尾部、中间。这三种方式需要考虑到。有序链表的创建过程 和一般链表创建...
  • 有序链表插入元素

    千次阅读 2015-07-05 14:59:30
    有序链表插入元素时,最好设置两个指针,一前一后,后面指针负责比较大小,前面的指针负责插入操作。#include "stdafx.h" #include #include <stdlib.h>struct vNode { int value; struct vNode* next; }; ...
  • 有序链表插入元素时,最好设置两个指针,一前一后, cur指针负责比较大小,pre指针负责定位插入位置的前驱。 #include using namespace std;typedef struct TNode { int data; struct TNode *next; }TNode;...
  • 在循环有序链表插入一个新值。例如:插入7之后算法: 为新插入的节点分配内存,并将数据放在新分配的节点中。让指向新节点的指针是new_node。在内存分配之后,以下是需要处理的三种情况。1)链接为空: a)因为...
  • C语言实现有序链表插入新的节点 节点结构 struct node { int data; node *next; }; 插入函数(保持有序) //链表中插入节点(保持链表升序关系) node *insert(node *head, node *p) {//头节点 ,p指向要插入的...
  • 看到一道面试题: typedef struct node { int value; struct node* next;...//实现有序双向链表插入和删除 int insert1(S_LIST_NODE* _list, int value); int delete1(S_LIST_NODE* _list, int value...
  • 有序链表插入(PTA)

    千次阅读 2019-03-04 14:00:34
    已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新的整数差入到L中,并保持 L的有序性。其中单链表的类型定义参考如下: typedef struct elementType; typedef struct Inode{ elementType data; ...
  • //向单向有序链表插入一个节点,保证其有序性不变 struct ListNode { int val; ListNode* next; ListNode(int x):val(x),next(NULL){} }; ListNode* insertToList(ListNode* head,ListNode* pNode) { if...
  • 已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新整数插入到L中,并保持L的有序性。 其中单链表的类型定义参考如下: typedef int elementType; typedef struct lnode { elementType data; struct ...
  • 如果在一个有序数组中,你想插入一个数据,还需要把其后所有元素往后移一位。 那么有没有一个比较好的数据结构可以实现简单便捷的插入操作呢? 那就是链表链表由两个部分组成,前面的部分为数据部分,用来存储...
  • 编写在非递减有序链表插入一个元素使链表元素仍有序的函数,并利用该函数建立一个非递减有序单向链表 #include<bits/stdc++.h> #define RESULT int #define OK 1 #define ERROR 0 using namespace std; ...
  • 两个有序链表合并成一个有序链表

    千次阅读 2019-04-17 14:04:04
    算法:两个有序链表合并成一个有序链表(Java实现) 首先我们创建链表的结构类 @Getter @Setter class Node{ private Integer data; //存储数据 private Node next; //后继引用 public Node(Integer data) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 106,717
精华内容 42,686
关键字:

有序链表的插入