精华内容
下载资源
问答
  • // 已知指向节点p的指针,如何删除该节点(不知道链表头) #include #include struct listnode { int data; struct listnode* next; }; // 思路,删除该节点的下一个节点,并将下一个节点的数据复制到p节点 void ...
    /*************************************************************************
    	> File Name: deleteNode.c
    	> Author: XXDK
    	> Email: v.manstein@qq.com 
    	> Created Time: Tue 07 Mar 2017 05:25:25 PM PST
     ************************************************************************/
    // 已知指向节点p的指针,如何删除该节点(不知道链表头)
    #include<stdio.h>
    #include<stdlib.h>
    
    struct listnode {
    	int data;
    	struct listnode* next;
    };
    // 思路,删除该节点的下一个节点,并将下一个节点的数据复制到p节点
    
    void delete_node(struct listnode* p)
    {
    	int data;
    	struct listnode* temp;
    
    	temp = p -> next;
    	p->next = temp->next;
    	p->data = temp->data;
    
    	free(temp);
    }
    

    展开全文
  • 平衡二叉树删除某个节点的方法

    千次阅读 2013-09-18 10:29:57
    如果节点Z仅有一个孩子,那么将Z节点的父节点中指向Z的指针指向Z仅有的孩子,然后删除节点Z。如果节点Z有两个非空的子节点,那么找到节点Z的中序后继节点Y(即右子树的最左节点),将节点Y的Key值覆盖节点Z的Key值,...
    1. 确认违规节点的位置

                 首先我们找到待删除的节点Z,如果节点Z的两个孩子均为空,那么将其父节点中对应指向Z的指针置为空,然后删除节点Z。如果节点Z仅有一个孩子,那么将Z节点的父节点中指向Z的指针指向Z仅有的孩子,然后删除节点Z。如果节点Z有两个非空的子节点,那么找到节点Z的中序后继节点Y(即右子树的最左节点),将节点Y的Key值覆盖节点Z的Key值,此时节点Y的两个孩子均为空或者只有一个右孩子,将节点Y的右指针里的值覆盖其父节点中指向Y的指针,然后删除节点Y。综上所述,删除的节点要么是节点Z本身要么是节点Z的中序后继节点Y。我们现在将它们统一命名为X,假若节点X是一个左孩子就对其父节点P的平衡因子进行减1操作,否则对节点P的平衡因子进行加1操作。如果节点P的平衡因子的绝对值超出了1,那么节点P即为违规节点,如果P的平衡因子为0,此时表示P的树高减小了1,这会对上层的节点的平衡因子造成影响(如附图),此时根据P是一个左孩子还是右孩子对其父节点的平衡因子进行修改。如果P的平衡因子的绝对值为1,那么表示原来等高的两颗子树,现在其中一颗子树高度减1了,这节点P的树高并没有影响,此时不需要对平衡二叉树进行调整。Bf表示平衡因子。下面是上述判断的示意图:


                判断节点P的平衡因子的绝对值是否为1,若是则不需要调整树形结构,否则进行调整。

    附图:


               此时删除红色节点会对树根的平衡因子产生影响。

               2.调整二叉树使之平衡  

                    与平衡二叉树节点插入的调整方法相同,详见《平衡二叉树插入某个节点的方法》博文,不再赘述。

    展开全文
  • 后附创建链表的两种方法的示意图。 #include<iostream> typedef struct Node{ int value; Node *next;...//创建有10个节点的链表 const int delete_n = 9;//删除第9个节点 const int delete_f...

     后附创建链表的两种方法的示意图。

    #include<iostream>
    
    typedef struct Node{
    	int value;
    	Node *next;
    }node,*linklist;
    
    const int numoflink = 10;//创建有10个节点的链表
    const int delete_n = 9;//删除第9个节点
    const int delete_forward_n = 2;//删除前两个节点
    
    const int insert_num = 6;//被插入节点的位置
    const int insert_value = 100;//插入的值
    
    const int auto_num = 3;//更改第3个节点的值
    const int auto_value = 500;//将值更改为100
    
    linklist CreateLink(int n);//创建链表
    linklist DeleteNode(node* head,int i);//删除链表第i个元素
    linklist DeleteForwardNode(node* head,int n);//删除链表前n个元素
    linklist InsertNode(node* head,int n);//在第n个节点后面添加一个节点
    linklist AutoNode(node* head,int n,int value);//更改第n个节点的数据
    void print(node *head);//打印链表
    
    //链表中第一个节点的存储位置叫做头指针;单链表的第一个节点前附设一个结头,为头结点
    //头结点是在链表的开始结点之前附加的一个结点;第一个结点(或称首元结点)是链表中存储第一个数据元素的结点
    
    //创建链表
    linklist CreateLink(int n)//返回的是该链表的地址
    {
    	//头插法
    	node *l = (node*)malloc(sizeof(node));
    	l->next = NULL;//先将l的下一个指针置空,是为了让指针l指向的下一个链表类型作为链表的第一个数,每次往链表中加数都加到链表中的第1个位置(即指针l指向的位置)。
    	//for(int i = 0;i < n;i++)
    	//{
    	//	node *p = (node*)malloc(sizeof(node));//新建一个node结构并为其申请空间
    	//	p->value = i;//给新建的node结构赋值
    	//	p->next = l->next;//赋值p所指的节点(就是l所指的节点,即链表的第2个节点)
    	//	l->next = p;//将l所指的节点更新为p点
    	//}
    
    	//尾插法
    	node *r;//r指向的始终是该链表的最后一个node结构
    	r = l;//这个地方是地址之间的赋值,所以对r操作就相当于对l操作(l指向的空间并不改变),即对链表最后一个node结构操作
    	for(int i = 0;i < n;i++)
    	{
    		node *h = (node*)malloc(sizeof(node));
    		h->value = i;
    		r->next = h;//将h插入到链表的最后一个node结构的后面
    		h->next = NULL;//此时h已经是链表的最后一个了,给h的next赋值
    		r = h;//让r等于链表的最后一个node结构,即h节点
    	}
    	return l;
    }
    
    //删除链表第i个元素
    linklist DeleteNode(node* head,int i)
    {
    	node* p;
    	p = head;//这个地方是地址之间的赋值,所以对p操作就相当于对head操作(head指向的空间并不改变),即对链表最后一个node结构操作
    	
    	int num = 0;
    
    	//将p移动到要删除的节点的前一个的位置
    	while(num < i-1 && p->next != NULL)
    	{
    		p = p->next;
    		num++;
    	}
    	//获取被删除点后面的链表
    	node* q = p->next->next;
    	//将被删除点前后的两端链表连接起来
    	p->next = q;
    	return head;
    }
    
    //删除链表前n个元素
    linklist DeleteForwardNode(node* head,int n)
    {
    	node *p;
    	p =head->next;
    	int num = 0;
    
    	while(p != NULL)
    	{
    		if(num == n-1)
    		{
    			//获取删除前n个节点后开始节点的位置,并直接将后一段链表输出
    			p = p->next;
    			break;
    		}
    		num++;
    	}
    	head = p;
    	return head;
    }
    
    //在第n个节点后面插入数据insert
    linklist InsertNode(node* head,int n,int insert)
    {
    	node* p;
    	//这个地方是地址之间的赋值,所以对p操作就相当于对head操作(head指向的空间并不改变),即对链表最后一个node结构操作
    	p = head;
    	int num = 0;
    
    	//创建一个新的节点存储要插入的元素
    	node *q = (node*)malloc(sizeof(node));
    	q->value = insert;
    
    	node* h;
    
    	while(num <= n && p->next != NULL)
    	{
    		//h用于定位被插入节点位置的前一个节点的位置(例如在第6个位置插入节点,则h最后存储的是第5个节点的位置)
    		h = p;
    		p = p->next;
    		num++;
    	}
    	//将插入节点与后面的节点连接起来(例如新节点插入到第6个位置,则q这个链表包括了新节点+原链表第6个元素及其之后的元素组成的链表)
    	q->next = p;
    	//将两段链表串接起来
    	h->next = q;
    
    	return head;
    
    }
    
    //更改第n个节点的数据
    linklist AutoNode(node* head,int n,int value)
    {
    	node* p;
    	//这个地方是地址之间的赋值,所以对p操作就相当于对head操作(head指向的空间并不改变),即对链表最后一个node结构操作
    	p = head;
    	int num = 0;
    
    	while(num < n && p->next != NULL)
    	{
    		p = p->next;
    		num++;
    	}
    	p->value = value;
    	return head;
    }
    
    //打印链表
    void print(node *head)     //输出双向链表的所有的元素 
     
    {
    	node *p;
    	p =head->next;
     
    	while(p!=NULL)
     
    	{
    		printf("%d ",p->value);
    		p=p->next;
    	}
    	printf("\n");
    }
    
    int main()
     
    {
     
    	node *head;
     
    	head = CreateLink(numoflink);
    	printf("初始链表:\n");
    	print(head); 
    
    	head = DeleteNode(head,delete_n);
    	printf("删除第%d个元素:\n",delete_n);
    	print(head); 
    
    	head = DeleteForwardNode(head,delete_forward_n);
    	printf("删除前%d个元素:\n",delete_forward_n);
    	print(head);
    
    	head = InsertNode(head,insert_num,insert_value);
    	printf("在第%d个节点后面进行插入,数值为%d:\n",insert_num,insert_value);
    	print(head);
    
    	head = AutoNode(head,auto_num,auto_value);
    	printf("更改第%d点的值,将值更改为%d:\n",auto_num,auto_value);
    	print(head);
     
     
    	return 0; 
     
    } 
    

    展开全文
  • 删除单链表中指针q指向的结点

    千次阅读 2017-12-28 21:50:12
    指针q指向链表中某一个结点,编写函数delLink,删除q指向的结点。 链表定义如下: typedef struct node { ElemType data; //数据域 struct node *next; //指针域 }LNode, *LinkList; 分析:

    题目:有一个非空单链表list,每个结点中存放一个整型数据。 指针q指向链表中某一个结点,编写函数delLink,删除q指向的结点。本文讨论的链表不带头结点。

     

    链表定义如下:

    typedef struct node

    {

    ElemType data;             //数据域

    struct node *next;         //指针域

    }LNode, *LinkList;

     

    分析:要删除单链表中的结点,最重要的是获取其前驱结点的指针。但此题中只给出了要删除的结点指针q,并不知道其前驱结点的指针,因此无法直接删除q指向的结点。因此需要通过一个循环来遍历链表,找到q的前驱结点,完成删除操作。算法代码描述如下:

     

    /*这里应该是LinkList *list,而不是LinkList list,否则下面第6行对*list的修改无法在主函数中生效(LinkList list应该也是指针,修改为什么无法在主函数生效,暂时不理解)*/
    void delLink(LinkList *list, LinkList q)     
    {
    	LinkList r;
    	if (q == *list) 
    	{
    		*list = q->next;			/*如果q指向的结点即为第1个结点,则需要修改list的值*/
    		free(q);					/*释放被删除结点的空间*/
    	} 
    	else 
    	{
    		r = *list;
    		while ((r->next != q)&&(r->next != NULL)) 
    		{
    			r = r->next;			/*通过循环找到q所指结点的前驱结点*/
    		}
    
    		if (r->next != NULL) 
    		{
    			r->next = q->next;		/*删除q所指向的结点*/
    			free(q);				/*释放被删除结点的空间*/
    		}
    	}
    }
    

     

     

    该算法时间复杂度为O(n),算法测试用例如下:

     

     

     

    #include <stdio.h>
    #include <malloc.h>
    
    typedef struct node
    {
    	int data;
    	struct node *next;
    }LNode,*LinkList;
    
    LinkList GreatLinkList(int n)
    {
    	/*建立一个长度为n的链表*/
    	LinkList p, r, list = NULL;
    	int e;
    	int i;
    	for (i=1;i<=n;i++)
    	{
    		scanf("%d",&e);					/*获取链表结点中的数据元素*/
    		p=(LinkList)malloc(sizeof(LNode));	/*分配一个新的链表结点*/
    		p->data=e;
    		p->next=NULL;
     		if (list == NULL) 
    		{
    				list = p;				/*list指向第一个结点,list是头指针*/
    		} 
    		else 
    		{
    				r->next = p;			/*将新结点连接到链表的尾部*/
    		}
    		r = p;						/*指针r始终指向链表的最后一个结点*/
    	}
    	return list;					/*返回链表的头指针*/
    }
    
    void delLink(LinkList *list, LinkList q) 
    {
    	LinkList r;
    	if (q == *list) 
    	{
    		*list = q->next;			/*如果q指向的结点即为第1个结点,则需要修改list的值*/
    		free(q);					/*释放被删除结点的空间*/
    	} 
    	else 
    	{
    		r = *list;
    		while ((r->next != q)&&(r->next != NULL)) 
    		{
    			r = r->next;			/*通过循环找到q所指结点的前驱结点*/
    		}
    
    		if (r->next != NULL) 
    		{
    			r->next = q->next;		/*删除q所指向的结点*/
    			free(q);				/*释放被删除结点的空间*/
    		}
    	}
    }
    
    void printLink(LinkList list) 
    {
    	while (list != NULL) 
    	{
    		printf("%3d",list->data);	/*打印出每个结点中的数据data*/
    		list = list->next;
    	}
    	printf("\n");
    }
    
    main() 
    {
    	LinkList list, q;
    	int i;
    	q = list = GreatLinkList(10);	/*创建包含10个元素的单链表,并初始化该链表*/
    	delLink(&list, q);				/*删除q指向的结点*/
    	printLink(list);				/*打印出链表中的内容*/
    	q = list;
    	for (i=0; i<4; i++) 
    	{
    		q = q->next;				/*指针q指向链表中第5个元素*/
    	}
    	delLink(&list, q);				/*删除q指向的结点*/
    	printLink(list);				/*打印出链表中的内容*/
    	getchar();
    	getchar();
    }

     

     

     

     

     

     

     

     

     

    展开全文
  • vc树控件Tree Control 1....消息会附带一个指向NMTREEVIEW结构的指针,程序可从该结构中获得必要的信息。两个消息都会在该结构的itemOld成员中包含原来的选择项信息,在itemNew成员中包含新选择项的信息,在acti
  • 链表两节点互换的指针问题

    万次阅读 2014-03-21 14:45:59
    不知哪根神经不对劲,突然就想试试能不能通过直接互换两个节点指针,很快写出如下交换函数: void DoExchange(Node *A, Node *B) { Node* temp = A; A = B; B = temp; }   一运行,果然是不行的
  • 除了递归,这里还提供另一个方法,要返回单链表中倒数第n个元素,我们可以借用两个指向链表节点指针,并使其间隔距离为n-1,将这两个指针同步向链表尾移动,当前面那个移动到尾部时,那么后面那个就是指向倒数第n...
  • 在双向链表存储结构中,删除p所指的结点时需修改指针的操作为 p-&gt;next-&gt;prior=p-&gt;prior; p-&gt;prior-&gt;next=p-&gt;next; p-&gt;next=p-&gt;next-&gt;next;p-&...
  • 一个节点的next域是固定的,当修改了节点的next域后,不管有多少指针指向这个节点,那么,这些指针的next节点均为修改后的节点,所以,以后要想删除某个节点后的节点时,必须要做到代码段1中的处理方法,先找一个...
  • 问题:有一个单项的链表,在没有头结点的情况下,只知道有一个指向结点B的指针p,假设这个结点B不是尾结点,删除该节点B。 p->data = p->next->data; p->next = p->next->next; free(p->next)解析:要删除p指向的结点B...
  • 单链表删除节点的方法

    千次阅读 2019-02-27 14:12:07
    public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } ...1.修改指针指向的对象   public static void deleteNodeV2(ListNode head, ListNode node) { if(...
  • 双链表删除节点

    千次阅读 2021-02-22 15:22:20
    编写一个程序,从双链表中移除一个节点,函数的原型如下 int dll_remove(struct NODE *rootp, struct NODE *node);...遇到链表操作的题目,第一步就是画一个链表图,然后理清指针指向然后再转化成代码
  • 其实我们知道,想要在单向链表中找到某个节点并删除它,复杂度为O(n),因为必须从头遍历才能找到它(最重要的是因为要找到它的前一个节点。)所以想要O(1)完成,必须想其他的方法。 目前重要的一个信息就是已经有一...
  • 访问单个节点的删除

    2016-08-04 00:03:53
    对于单向链表,要删除一个节点A,只要找到节点A的前驱节点AA,然后修改AA指向下一个节点的值,将其指向A节点的后继即可,但本题有限制,已知要删除的节点,又因为是单链表,所以无法获得其前面一个节点指针,...
  • cpp知识汇总(1) 指针vs引用、static、const

    千次阅读 多人点赞 2020-05-31 15:05:34
    引用和指针的区别? 指针是一个实体,需要分配内存空间。引用只是变量的别名,不... sizeof 引用得到的是所指向的变量(对象)的大小,而sizeof 指针得到的是指针本身的大小。 引用访问一个变量是直接访问,而指针访
  • 多级指针和链表

    千次阅读 热门讨论 2011-02-11 21:15:00
    *p定义一个指针,p指向一个内存位置,该位置中保存p声明的数据类型,而**p表示一个指针指针,p指向一个位置,该位置存放一个指针,后者指向p声明的数据类型,类似的***p也一样表示一个指针,****p也没什么区别,这
  • /* 遍历访问,反问某个节点元素用函数处理 */ ChainNode * NewChainNode( ElemType); List *CreateList(int size ) { List * pt = 0; ElemType data = 0; pt=(List*)malloc( sizeof(List) ); if...
  • 不过我们需要改造一下现有的循环链表,我们不用头指针,而是用指向终端结点的尾指针来表示循环链表,此时查找开始结点和终端结点都很方便了 如图所示,这样,我们把尾指针代替头节点作为首发指针,就能可使得...
  • C语言的本质(10)——指针本质

    千次阅读 多人点赞 2014-06-30 13:08:17
    指针的类型是derived from其它类型,也就是说指针的类型是由它指向的类型决定的;2. 指针是一种reference类型,即引用类型; 指针这个词出现在高级语言程序设计中,在汇编中,就没有指针这个概念,有的只是地址。...
  • 二级指针删除单链表

    2015-06-25 22:19:24
    首先创建一个节点 typedef struct node { int data; struct node *next;...直接在create函数中修改了*head的值,让*head的值是第一个节点。 可见这种方法创建的链表不存在大多数教材上得“头结点”这个节点
  • Linux文件系统索引节点inode详解

    千次阅读 2015-08-22 14:58:11
    在Linux系统中,为每个文件分配一个称为索引节点的号码inode,可以将inode简单理解成一个指针,它永远指向本文件的具体存储位置。  系统是通过索引节点(而不是文件名)来定位每一个文件。  例如:在硬盘当前目录...
  • C和指针学习

    万次阅读 热门讨论 2008-06-24 18:15:00
    C和指针学习最后更新时间:2012.12.3原则:尽量短小精悍,实用,需要扩充阅读都是以链接形式出现注意:本文主要是针对Unix环境下的C目 录一.编译与链接二.特殊字符三.数据类型四.修饰符五.运算符六.控制语句七.函数...
  • 本节讲解一下单链表中节点的查找、插入、删除、求单链表长度等操作。 按序号查找结点值 在单链表中从第一个结点出发,顺指针next域逐个往下搜索,直到找到第i个结点为止,否则返回最后一个结点指针域NULL。 按序号...
  • Rust中,常会用到的3种指针有哪些?

    千次阅读 2021-01-31 14:47:12
    指针只是指向进程地址空间中内存位置的变量。在Rust中,我们主要会用到3种指针。 5.8.1 引用—— 安全的指针 在介绍借用时已经详细阐述了这类指针。引用类似于C语言中的指针,但同时会检查它们的正确性。它们永远...
  • 我们应该注意,存储在哈希指针中的哈希是前一个块的整个数据的哈希,其中还包括指向该块之前的块的哈希指针。这使得在不通知他人的情况下篡改区块链中的区块是不可能的。 篡改区块链的明显属性 我们只需要保留指向...
  • c语言指针详解

    2008-01-05 19:10:00
     要搞清一个指针需要搞清指针的四方面的内容:指针的类型,指针指向的类型,指针的值或者叫指针指向的内存区,还有指针本身所占据的内存区。让我们分别说明。 先声明几个指针放着做例子: 例一: (1)int *ptr; ...
  • http://www.newsmth.net/nForum/#!article/LinuxApp/850708 http://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/0013744142037508cf42e51debf49668810645e02887691000 比如某个
  • 《c和指针》函数指针

    2012-08-25 09:25:05
    这里的com就是一个回调函数,也就是用户需要用fun函数的时候,需要传一个函数的指针过来,而指向的这个函数是由用户来编写的. 什么时候用回调函数:编写的函数必须能够在不同的时候执行不同类型的工作或者执行只能由...
  • c语言-指针数组

    千次阅读 2018-11-10 22:53:05
    指针 内存和地址怎么理解呢? 机器中有一些位置,每一个位置被称为【字节】/byte,许多现代机器上,每个字节包含8个位。更大内存单位【字】,通常包含2个或4个字节组成。 一个字包含4个字节,它的地址是什么? 他...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,311
精华内容 24,524
关键字:

修改指针指向某个节点