精华内容
下载资源
问答
  • 题目:给定一个整数num,如何在节点有序的环形链表中插入一个节点值为num的节点,并保证这个环形链表依然有序。(假如链表是升序) 解决思路: 1.如果链表为空,则开辟一个节点,让后让他自己指向自己,然后返回该...

    题目:给定一个整数num,如何在节点有序的环形链表中插入一个节点值为num的节点,并保证这个环形链表依然有序。(假如链表是升序)

    解决思路:
    1.如果链表为空,则开辟一个节点,让后让他自己指向自己,然后返回该节点。
    2.如果链表不为空,分为三种情况:
    a.如果插入的节点的值是在环形链表最大值和最小的闭区间范围之内,即在链表[min,max]里面,那么先找到要插入的位置,然后插入。
    在这里插入图片描述
    b.如果插入的节点的值大于链表最后一个值,那么插入的位置就直接是最后一个节点的后面,然后让他指向头结点,最后返回头结点。
    在这里插入图片描述
    c.如果插入的节点小于链表的第一个节点,也就是小于最小的一个节点,那么插入的位置还是链表的最后一个节点的后面,然后让他指向头结点,最后返回新插入的节点。
    在这里插入图片描述

    有了方法,代码就比较好写了。

    typedef struct node
    {
    	DataType data;
    	struct node *p_next;
    }Node ,*PNode;
    
    PNode InsertInCircle(PNode head,DataType data)//插入一个节点在有序链表中,并且插入之后链表有序
    {
    	//1.如果环形链表是空,则将该节点插入,返回该节点
    	if (head == NULL)
    	{
    		PNode pCur = NULL;
    		pCur = (PNode)malloc(sizeof(Node));
    		pCur->data = data;
    		pCur->p_next = pCur;
    		return pCur;
    	}
    	else
    	{
    		//2.先找到只要插入的位置
    		pCur = head->p_next;
    		PNode pPre = head;
    		while (pCur != head)
    		{
    			//a.插入位置在链表内
    			if (pPre->data <= data && pCur->data >= data)
    			{
    				PNode pNode = (PNode)malloc(sizeof(Node));
    				pNode->data = data;
    				pPre->p_next = pNode;
    				pNode->p_next = pCur;
    				return head;
    			}
    			pPre=pPre->p_next;
    			pCur = pCur->p_next;
    		}
    		//.出循环,说明此时data是链表中最大或者是最小的节点
    		//此时pCur==head
    		PNode pNode = (PNode)malloc(sizeof(Node));
    		pNode->data = data; 
    		pPre->p_next = pNode;
    		//b.比头结点小
    		pNode->p_next = pCur;
    		if (data < head->data)
    			return pNode;
    		else
    			//比头结点大
    			return head;
    	}
    }
    

    结果:
    测试的链表有5个节点,分别是1->2->3->4->5->1(最后的1是多打印了一次原链表只有一个值为1的节点)…
    1.当链表为空
    在这里插入图片描述
    2.插入值为1的节点
    在这里插入图片描述
    3.插入值为2的节点
    在这里插入图片描述
    4.插入值为5的节点
    在这里插入图片描述
    5.插入值为6的节点

    在这里插入图片描述
    测试及源代码下载:源代码

    展开全文
  • //向单向有序链表中插入一个节点,保证其有序性不变 struct ListNode { int val; ListNode* next; ListNode(int x):val(x),next(NULL){} }; ListNode* insertToList(ListNode* head,ListNode* pNode) { if...
    //向单向有序链表中插入一个节点,保证其有序性不变
    
    struct ListNode
    {
    	int val;
    	ListNode* next;
    	ListNode(int x):val(x),next(NULL){}
    };
    
    ListNode* insertToList(ListNode* head,ListNode* pNode)
    {
    	if(head==NULL || pNode==NULL) return NULL;
    
    	ListNode* dumm=new ListNode();
    	dumm->next=head;
    
    	ListNode* p=head;
    	ListNode* pre=dumm;
    	
    
    	while(p)
    	{	
    		//找到插入位置
    		if(p->val >pNode->val)
    		{
    			break;
    		}
    		p=p->next;
    		pre=pre->next;
    	}
    	//插入
    	pre->next=pNode;
    	pNode->next=p;
    	
    	return dumm->next;
    }
    
    
    展开全文
  • 双向链表——有序双向链表中插入节点

    双向链表——有序双向链表中插入节点


    双向链表——有序双向链表中插入节点

    #include<iostream>
    using namespace std;
    struct node       //node结构体,里面有两个个node指针,用来指向上/下一个node对象
    {
    	int x;
    	node *left;   //指向什么类型的对象,就用什么类型的指针
    	node *right;
    };
    
    node* create(int n)         //创建链表,参数n表示结点的个数,返回类型是结点指针node*
    {
    	if(n<1)                 //参数检测,链表最少有一个节点
    	{
    		cout<<"error input n!"<<endl;	
    		exit(0);
    	}
    	
    	node *head=new node;    //建立头结点
    	node *p=head;           //创建用于往后指的node指针
    
    
    	for(int i=1;i<=n;i++)
    	{
    		node *temp=new node;      //new一个node指针
    		temp->x=rand()%100;
    		p->right=temp;            //将p的right指向创建的temp,把新节点连接到链表后面
    		temp->left=p;             //temp的left指向p,新节点left指向上一个节点
    		p=temp;                   //将p指向新结点temp,即p移动到下一个节点
    	}
    
    	p->right=NULL;                //创建完成后,p->right为空,最后一个节点的right位null
    	head->right->left=NULL;       //创建完成后,第一个节点的left为null
    
    	return head;
    }
    
    void display(node *head)         //输出链表
    {
    	node *p;
    	p=head->right;               //p重新指向头结点后的那个结点,即for循环创建的第一个结点
    	if(p==NULL)
    		cout<<"NULL List";
    	while(p!=NULL)               //输出
    	{
    		cout<<p->x<<"  ";
    		p=p->right;
    	}
    	cout<<endl;
    }
    
    void sort(node *head)
    {
    	node *p,*s;
    	p=head->right;               //p重新指向头结点后的那个结点,即for循环创建的第一个节点
    	int temp;                    //用于交换的临时变量
    	while(p)                     //外循环从头结节后的第一个节点开始
    	{	
    		s=p->right;              //内循环从p的后一个结点开始
    		while(s)
    		{
    			if(p->x > s->x)      //只交换结点里面的x,结点不动
    			{
    				temp=p->x;
    				p->x=s->x;
    				s->x=temp;
    	
    			}
    
    
    			s=s->right;          //内循环后移
    		}
    		
    		p=p->right;              //外循环后移
    	}
    
    }
    
    void insert(node *head, int n)     //直接将数n插入到链表head的适当位置
    {
    	node *p,*s;
    	p=head;                        //p重新指向头结点后的那个结点,即for循环创建的第一个节点
    	
    	while(p->right)
    	{
    		if(p->right->x > n)        //在有序列表中找到第一个比n大的节点,在它前面插入就行
    		{	
    			node *temp=new node;
    			temp->x=n;
    
    
    			s=p->right;           //用于反向连接的临时node指针s
    
    
    			temp->right=p->right;
    			p->right=temp;        //插入适当位置,正向连接链表
    			
    			s->left=temp;         //反向连接链表
    			temp->left=p;
    
    
    			break;
    			
    		}
    		p=p->right;
    
    	}
    
    
    	if(p->right==NULL)            //如果链表最后一个数还比n小,则直接放在链表最后
    	{
    		node *temp=new node;
    		temp->x=n;
    
    		p->right=temp;            //连接上新来的最后一个节点
    		temp->right=NULL;         //right指针为null
    		temp->left=p;             //反向连接
    	}
    
    }
    
    void insert1(node *head, int n)    //既然有排序,就直接将插入的节点连接到第一个节点,然后排序
    {
    
    
    	node *s,*p=head;                        //p重新指向头结点后的那个结点,即for循环创建的第一个节点
    	node *t=new node;
    	t->x=n;
    
    
    	s=p->right;        //用于反向连接的临时node指针s
    
    
    	t->right=p->right; //插入适当位置,正向连接链表
    	p->right=t;       
    			
    	s->left=t;         //反向连接链表
    	t->left=p;
    
    
    	sort(head);        //借助上面的排序
    
    
    }
    
    
    int main()
    {
    	node *list; 
    	list=create(10);      //建立链表
    	display(list);        //输出显示建立的链表,这里是讯链表,不用输出
    	
    	sort(list);           //排序,称为有序列表
    	display(list);        //显示排序后的链表
     
    	insert(list,-2);      //在有序列表中插入
    	display(list);        //显示有序列表插入后的链表
    
    
    	insert1(list,99);     //在有序列表中插入
    	display(list);        //显示有序列表插入后的链表
    
    	return 0;
    }


    展开全文
  • C语言实现有序链表中插入新的节点 节点结构 struct node { int data; node *next; }; 插入函数(保持有序) //链表中插入节点(保持链表升序关系) node *insert(node *head, node *p) {//头节点 ,p指向要插入的...

    C语言实现有序链表中插入新的节点

    节点结构

    struct node
    {
    	int data;
    	node *next;
    };
    

    插入函数(保持有序)

    //链表中插入节点(保持链表升序关系)
    node *insert(node *head, node *p) {//头节点 ,p指向要插入的节点
    	node *p1, *p2;
    	if (head == NULL) {	//链表为空(head=NULL)
    		head = p;
    		p->next = NULL;
    		return head;
    	}
    	if (head->data >= p->data) {	//链表非空,将结点插入到表头位置
    		p->next = head;
    		head = p;
    		return head;
    	}
    	p1 = head;
    	p2 = head;
    	while (p2->next && p2->data < p->data) {
    		p1 = p2;
    		p2 = p2->next;
    	}
    	if (p2->data < p->data) {	//将结点插入到链表的末尾。
    		p2->next = p;
    		p->next = NULL;
    	} else {				//将结点插入到链表的中间位置
    		p->next = p2;
    		p1->next = p;
    	}
    	return head;
    }
    
    展开全文
  • 循环有序链表插入一个新值。例如:插入7之后算法: 为新插入的节点分配内存,并将数据放在新分配的节点中。让指向新节点的指针是new_node。内存分配之后,以下是需要处理的三种情况。1)链接为空: a)因为...
  • 如果一个有序数组,你想插入一个数据,还需要把其后所有元素往后移一位。 那么有没有一个比较好的数据结构可以实现简单便捷的插入操作呢? 那就是链表链表由两个部分组成,前面的部分为数据部分,用来存储...
  • #include #include struct node { int value; struct node *next; };...struct node *inset_into_ordered_list(struct node *list, struct ...必需注意,当要插入的结点在链表的第一位,和最后一位的特殊情况。
  • 单向链表有序插入节点(C语言实现)

    千次阅读 多人点赞 2018-03-20 07:50:05
    链表的创建查看 按特定值插入链表,要求链表本身使用某种排序方法排好序的。   链表的插入分四种情况: ...3、中间插入节点:使新加入的节点的前一个节点指向新加入的节点p_new,新加入的节点的next指...
  • 有序链表插入讲解.zip

    2020-07-29 09:16:09
    有利于新手学习c语言,为以后的语言以及实战使用打下坚实的基础。以供大家学习。欢迎大家下载使用,好好学习研究,早日成为一方大牛。
  • 有序链表插入

    千次阅读 2017-11-07 20:36:28
    已知一个递增有序链表L(带头结点,元素为整数),编写程序将一个新整数插入到L,并保持L的有序性。其中单链表的类型定义参考如下: typedef int elementType; typedef struct lnode { elementType data; ...
  • //向循环有序链表插入一个值 //…… struct ListNode { int val; ListNode* next; ListNode(int x):val(x),next(NULL){} }; ListNode* insertNodeToList(ListNode* LNode,ListNode* pNode) { //1.循环链表为...
  • //若结构体含有构造函数,则直接 ListNode* node=new ListNode(v); if(head==nullptr) { head=node; return; } if(v < head->val) { head->pre=node; node->pre=nullptr; node->next=head; head=node...
  • 单链表(有序插入节点

    千次阅读 2018-04-05 18:15:33
    单链表的插入,有三种情况:1、插入在头结点之前 2、插入在中间节点 3、插入节点Node* insert(int num, Node* head){ Node*New, *previous, *p2;//p2用来保存前一个previo...
  • //头部插入 } else{ s->next=q;p->next=s; } return head; } void printList(linklist *head){ linklist *t; t=head; if (t==NULL) printf("这是一个空列表\n"); while (t!=NULL){ printf("%d ",t->...
  • 有序循环单向链表中插入节点

    千次阅读 2015-02-27 00:33:22
    给定一个有序的循环单向链表和一个整数,要求将以该整数为值的新节点插入链表中,新链表要求仍然有序。 class Node { public: Node(int v) { value = v; next = NULL; } int value; Node
  • 某电器商场仓库一批电视机,按其价格从低到高的次序构成了一个循环链表,表的每个元素指出了价格、数量和链指针三个域。现在新到m台价格为h元的电视机入库。试编写出仓库电视机链表增加电视机的算法 typedef ...
  • 题目 给定一个有序的循环链表其中插入一个值,保持该循环链表依然有序。...此时若是要在链表中插入4,则插入后的链表如下所示: 可以看到插入4后,链表依然有序解决这个问题前,先来看一个简化...
  • 有序链表插入函数

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

    2017-09-12 23:15:00
    双向链表插入节点 1、根据实例分析 2、把节点之间的关系看成 是边的拆除和重建 3、为了方便叙述,给边标了号 如图所示是我们要操作的结构体和双向链表的图。 现在我们的目的就是ab节点之间插入x节点。 ...
  • 主要介绍了JS实现的合并两个有序链表算法,结合实例形式分析了JavaScript链表的定义、节点插入、删除、查找等相关算法实现技巧,需要的朋友可以参考下
  • 下列给定程序已建立一个带头结点的单向链表,链表中节点节点数据域的数据递增有序链接。函数fun的功能是:把形参x的值放入一个新节点插入列表使插入后各节点数据域的数据仍保持递增有序。  请程序的...
  • 指定位置插入节点 先找到要插入的位置(通过节点的属性,比如id或者有序数字) 与单链表不同的时候插入后,next 和 pre 都要与前后节点相连 // 按排序插入节点 public void addByOrder(Node2 node) { // 头节点...
  • //向有序的环形单链表中插入节点 public class InsertNode{ //单链表节点的定义 public static class Node{ public int value; public Node next; public Node(int data) { this.v
  • 这个比较简单,直接上代码了typedef struct ListNode{ int data; ListNode *next; }ListNode;void sortedInsertNode(ListNode *head,ListNode *newNode) ...//把头结点设置为当前节点 //case 1: 该链表为空
  • 599. 向循环有序链表插入节点 给一个来自已经排过序的循环链表的节点,写一个函数来将一个值插入到循环链表,并且保持还是有序循环链表。给出的节点可以是链表的任意一个单节点。返回插入后的新链表。 样例 ...

空空如也

空空如也

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

在有序链表中插入节点