精华内容
下载资源
问答
  • 删除中间节点

    2020-03-08 23:01:18
    实现一种算法,删除单向链表中间的某个节点(除了第一个和最后一个节点,不一定是中间节点),假定你只能访问该节点。 示例: 输入:单向链表a->b->c->d->e->f中的节点c 结果:不返回任何数据,但该...
    /*
    实现一种算法,删除单向链表中间的某个节点(除了第一个和最后一个节点,不一定是中间节点),假定你只能访问该节点。
    示例:
    
    输入:单向链表a->b->c->d->e->f中的节点c
    结果:不返回任何数据,但该链表变为a->b->d->e->f
    
    来源:力扣(LeetCode)
    */
    
    /*
    说明:
    不知道该节点前驱,因此无法直接删除该节点;
    可以用该节点取代它的下一个节点,然后把它的下一个节点删掉;
    */
    
    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
    void deleteNode(struct ListNode* node) {
    	struct ListNode* tmpNode = node->next;
    	
        node->val = node->next->val;
    	node->next = node->next->next;
    	tmpNode->next = NULL;
    	free(tmpNode);
    }
    
    展开全文
  • 删除链表的中间节点

    2021-03-06 15:51:23
    删除链表的中间节点 删除链表的中间节点 public static LinkNode removeHalfNode(LinkNode node) { if(node==null || node.next==null) { return node; } if (node.next.next==null) { return node.next...

    删除链表的中间节点

    删除链表的中间节点

    public static LinkNode removeHalfNode(LinkNode node) {
    		if(node==null || node.next==null) {
    			return node;
    		}
    		if (node.next.next==null) {
    			return node.next;
    		}
    		LinkNode fast = node.next.next;
    		LinkNode slow = node; //重点slow指的是要删除节点的前一个节点
    		while(fast!=null&&fast.next!=null) {
    			fast = fast.next.next;
    			slow = slow.next;
    		}
    		slow.next= slow.next.next;
    		return node;
    	}
    
    展开全文
  • 图解-堆删除节点

    千次阅读 2018-12-04 18:06:34
    转自:http://www.mathcs.emory.edu/~cheung/Courses/171/Syllabus/9-BinTree/heap-delete.html     Deleting a specific node from a Heap     ... You are given a heap...

    转自:http://www.mathcs.emory.edu/~cheung/Courses/171/Syllabus/9-BinTree/heap-delete.html

     

     

    • Deleting a specific node from a Heap

       

       





       

      • Problem description:

         

        • You are given a heap.

          For example:

           

           


           

        • You are also given a index k

          For example: k = 2

           


           

        • Problem:

           

          • Delete the value a[k] from the heap (so that the resulting tree is also a heap !!!)

           

         


         

      • Here is a Heap with the element a[2] = 5 deleted:

         

        Heap before deleting the value a[2] = 5
        Heap after the deletion...

        $64,000 question:

         

        • How did you do it ???        

         

    • The delete algorithm for a Heap

       

       





       

      • The heap deletion algorithm in pseudo code:

         

            1, Delete a node from the array 
               (this creates a "hole" and the tree is no longer "complete")
        
            2. Replace the deletion node
               with the "fartest right node" on the lowest level
               of the Binary Tree
               (This step makes the tree into a "complete binary tree")
        
            3. Heapify (fix the heap):
        
                 if ( value in replacement node < its parent node )
                    Filter the replacement node UP the binary tree
                 else
        	    Filter the replacement node DOWN the binary tree
         
        

         


         

      • Example:

         

        • Delete the node containing the value 5 from the following heap:

           

          After you delete the node, the tree is not a complete binary tree:

           

           



           

        • Step 1: replace the deleted node with the node in the "fartest right location" of the lowest level

           

          Result:

           

          However, it is not a heap:

           

          • We must fix the binary tree so that it becomes a heap again !!!

             

             

            • Depending on the value of the replacement node, we must filter the replacement node upwards ordownwards

             

             

          Since you have already seen the filter up algorithm --- in the heap insert algorithm --- I made the example to show you the filter down algorithm now

           


           

        • Step 2: because the replacement node 21 is greater than its parent node (1), we must filter the replacement node down the tree

           

           

          Filter the replacement node down the tree proceeds as follows:

           

          • Compare the values of the replacement node with all its children nodes in the tree:

             

            Some child node has a smaller value: the replacement node is not in its proper location

             


             

          • Swap the replacement node with the smallest of the children nodes:

             

             

          • After swapping:

             

             

            Repeat !

             



             

          • Compare the values of the replacement node (21) with all its children nodes in the tree:

             

             

            Some child node has a smaller value: the replacement node is not in its proper location

             


             

          • Swap the replacement node with the smallest of the children nodes:

             

            After swapping:

             

             

            Repeat !

             



             

          • The replacement node (21) does not have any children node:

             

            Done !!!

           

         







         

      • Warning:

         

        • Sometimes, you have to filter the replacement node up the Binary tree !!!!!      

        Example:

         

        • Delete the node with value = 33 from the following heap:

           

           



           

        • Step 1: replace the deleted node with the "last" node in the lowest level (to make a complete binary tree)

           

          Result:

           

           



           

        • In this case, the replacement node must be filtered up into the binary tree:

           

          Result:

           

           

         



         

      • Conclusion:

         

             if ( replacement node < its parent node )
                filter the replacement node up the tree
             else
                filter the replacement node down the tree      
        

         

         



         

      • Heap deletion algorithm in Java:

         

           public double remove( int k )
           {
              int parent;
              double r;             // Variable to hold deleted value
        
              r = a[k];             // Save return value
        
              a[k] = a[NNodes];     // Replace deleted node with the right most leaf
                                    // This fixes the "complete bin. tree" property
        
              NNodes--;             // One less node in heap....
        
              parent = k/2;
        
              /* =======================================================
        	 Filter a[k] up or down depending on the result of:
        		a[k] <==> a[k's parent]
                 ======================================================= */
              if ( k == 1 /* k is root */ || a[parent] < a[k] ) 
                 HeapFilterDown(k);  // Move the node a[k] DOWN the tree
              else
                 HeapFilterUp(k);    // Move the node a[k] UP the tree
        
              return r;         // Return deleted value...
           }
        

        (We have already discussed the HeapFilterUp() algorithm .... )

         





         

      • Filter Down algorithm in pseudo code:

         

            HeapFilterDown( k )   // Filter node a[k] down to its proper place
            {
               while ( a[k] has at least 1 child node )
               {
                  child1 = 2*k;        // left  child of a[k]
        	  child2 = 2*k + 1;    // right child of a[k]
        
                  if ( a[k] has 2 childred nodes )
        	  {
        	     if ( a[k] has smallest value among {a[k], a[child1], a[child2]} )
        	        break;       // a[k] in proper place, done
        	     else
        	     {
        	        /* =========================================
        		   Replace a[k] with the smaller child node
        		   ========================================= */
        	        if ( a[child1] < a[child2] )
        		{
        		   swap ( a[k], a[child1] );
        		   k = child1;                 // Continue check....
        	        }
        		else
        		{
        		   swap ( a[k], a[child2] );
        		   k = child2;                 // Continue check...
        		}
        	     }
        	  }
        	  else  // a[k] must have only 1 child node
        	  {
        	     if ( a[k] has smallest value among {a[k], a[child1]} )
        	        break;       // a[k] in proper place, done
        	     else
        	     {
        		swap ( a[k], a[child1] );
        	        k = child1;                    // Continue check....
        	  }
               }
            }
        

         


         

      • The Filter down algorithm (describe above) is coded as a method:

         

           /* ========================================================
              HeapFilterDown(k): Filters the node a[k] down the heap
              ======================================================== */
           void HeapFilterDown( int k )
           {
              int child1, child2;          // Indices of the children nodes of k
              double help;
        
              while ( 2*k <= NNodes )       // Does k have any child node ? 
              {
                 child1 = 2*k;              // Child1 = left  child of k
                 child2 = 2*k+1;            // Child2 = right child of k
        
                 if ( child2 <= NNodes )    // If true, then k has 2 children nodes !
                 {
                    /* ========================================
                       Node k has 2 children nodes....
                       Find the min. of 3 nodes !!!
                       ======================================== */
                    if ( a[k] < a[child1] && a[k] < a[child2] )
                    {
                       /* -------------------------------------------------------
        	          Node k has the smallest value !
                          Node k is in correct location... It's a heap. Stop...
                          ------------------------------------------------------- */
                       break;    // STOP, it's a heap now
                    }
                    else
                    {
                       /* ===================================================
        	          Swap a[k] with the smaller of its 2 children nodes
        		  =================================================== */
                       if ( a[child1] < a[child2] )
           	       {
           		  /* -------------------------------------------------------
           		     Child1 is smaller: swap a[k] with a[child1]
           		     ------------------------------------------------------- */
           		  help = a[k];
           		  a[k] = a[child1];
           		  a[child1] = help;
           		
           		  k = child1;     // Replacement node is a[child1]
           				  // in next iteration
           	       }
           	       else
           	       {
           		  /* -------------------------------------------------------
           		     Child2 is smaller: swap a[k] with a[child2]
           		     ------------------------------------------------------- */
           		  help = a[k];
           		  a[k] = a[child2];
           		  a[child2] = help;
           		
           		  k = child2;     // Replacement node is a[child2]
           				  // in next iteration
           	       }
                    }
                 }
                 else
                 {
                    /* ========================================
                       Node k only has a left child node
                       Find the min. of 2 nodes !!!
                       ======================================== */
                    if ( a[k] < a[child1] )
                    {
                       /* -------------------------------------------------------
                          Node k is in correct location... It's a heap. Stop...
                          ------------------------------------------------------- */
                       break;
                    }
                    else
                    {
                       /* -------------------------------------------------------
                          Child1 is smaller: swap a[k] with a[child1]
                          ------------------------------------------------------- */
                       help = a[k];
                       a[k] = a[child1];
                       a[child1] = help;
        
                       k = child1;     // Replacement node is a[child1]
                                       // in next iteration
                    }
                 }
              }
           }
        

         


         

      • Example Program: (Demo above code)                                                 

         

        How to run the program:

         

        • Right click on link and save in a scratch directory

           

        • To compile:   javac testProg2.java
        • To run:          java testProg2

         

    • Running time analysis of the heap delete algorithm

       

       





       

      • Before we can perform a running time analysis, we must first understand how the algorithm works exactly...

         


         

      • Summary of the heap delete algorithm:

         

        • The deleted node is first replaced:

           

          We will always have a complete binary tree:

           

           


           

        • Then the HeapFilterUp() or the HeapFilterDown() algorithm will migrate the replacement node up or down into the binary tree:

           

          and:

           

           

         



         

      • Fact:

         

        • The number of times that the deleted node will migrate up or down into the binary tree is:

           

              # migrationsheight of the binary tree               
          

           

        Example:

         

        • The maximum number of times that replacement node can move down in a binary tree:

           

          is at most 3 times:

           

           

        The same argument can be apply to show that the maximum number of times that a nodes can move up the tree is at most the height of the tree.

         



         

      • Therefore:

         

           Running time( delete(n) ) = Running time heap delete in heap with n node     
        
                                     = height of a heap of n nodes   
        

         

    • The height of a heap when it contains n nodes

       

       





       

      • We have already determined this fact:

         

          Let:  n =  # nodes in heap of height h 
        
                  2h - 1  <  n          ≤  2h+1 − 1       
           <===>  2h      <  n + 1      ≤   2h+1
           <===>  h       <  lg(n + 1)  ≤  h+1
        
        
           ===> height of heap ~= lg(n + 1)         
        

         

    • Running time of the heap delete algorithm

       

      • Summary:

         

        • Running time of delete into a heap of n nodes = height of the heap

           


           

        • height of the heap containing n nodes ~= lg(n + 1)

         


         

      • Conclusion:

         

        • Running time of delete into a heap of n nodes = O(lg(n))       
    展开全文
  • 实现一种算法,删除单向链表中间的某个节点(即不是第一个或最后一个节点),假定你只能访问该节点。 示例: 输入:单向链表a->b->c->d->e->f中的节点c 结果:不返回任何数据,但该链表变为a->b-&...

    项目场景:

    实现一种算法,删除单向链表中间的某个节点(即不是第一个或最后一个节点),假定你只能访问该节点。

    示例:

    输入:单向链表a->b->c->d->e->f中的节点c
    结果:不返回任何数据,但该链表变为a->b->d->e->f

    问题描述:

    free(node->next);
    加这句将出现AddressSanitizer: heap-use-after-free报错,不加将存在一个无用节点node->next浪费内存(但好像无法解决)

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
     //由于只能访问该节点
    void deleteNode(struct ListNode* node)
    {
        node->val = node->next->val;
        node->next = node->next->next;
        //free(node->next);
    }
    

    原因分析:

    释放node->next内存将对前面对此节点内容的使用造成内存访问上的错误:
    Use after free:访问堆上已经被释放的内存
    Heap buffer overflow:堆上缓冲区访问溢出
    Stack buffer overflow:栈上缓冲区访问溢出
    Global buffer overflow:全局缓冲区访问溢出
    Use after return:访问栈上已被释放的内存
    Use after scope:栈对象使用超过定义范围
    Initialization order bugs:初始化命令错误
    Memory leaks:内存泄漏

    解决方案:

    注释掉free那句即可

    【附AddressSanitizer常见报错】
    应用 AddressSanitizer 发现程序内存错误
    【附其他人解法:添加临时变量】
    (我不觉得有什么区别,但大家好像都用临时变量)

    void deleteNode(struct ListNode* node) {
        struct ListNode* temp = node->next;
        node->val = node->next->val;
        node->next = node->next->next;
        free(temp);
    }
    
    

    展开全文
  •  1、定义一个中间变量来暂时寄存要删除节点后面的链表元素  2、删除节点(free()函数)  3、将剩余的节点与重新关联起来   删除中间某一个值的节点:  1、遍历链表,找到要删除节点的位置  2、定义一个...
  • 实现一种算法,删除单向链表中间的某个节点(即不是第一个或最后一个节点),假定你只能访问该节点。 示例: 输入:单向链表a->b->c->d->e->f中的节点c 结果:不返回任何数据,但该链表变为a->b-&...
  • 译文:实现一个算法来删除单链表的中间结点,只给出指向那个结点的指针  例子 输入:指向链表 a->b->c->d->e 中结点c的指针 结果:无返回值,得到一个新链表 a->b->d->e 这里要清楚的是题目只给出一个...
  • // 假设一个没有头指针的单链表,一个指针指向此单链表中间的一个节点(不是第一个也不是最后一个节点),请将该结点从单链表中删除 // 创建节点 typedef struct node { int data; struct node
  • 内存的申请和使用3.链表的头指针4.访问链表中各个节点的数据5.实战:构建一个简单的单链表6.将创建节点的代码封装成一个函数(三)单链表的算法-插入节点1.从链表尾部插入新的节点1.头节点引入1.什么是头节点2.从...
  • 的结构特点 排序是一个可以高效实现排序的算法,复杂度是O(nlogn)和之前的快速排序与归并排序的复杂度相同,而它...其中大于等于其左右节点叫大顶堆,小于等于其左右节点叫小顶堆 的存储结构分析 由...
  • 2021-01-23 20:29:21
    最小节点的值是中最小的,以最小为例子,如下图 他是数组结构,结点中的数字是数组元素的下标,不是数组元素的值。所以如果我们知道父节点的下标我们就可以知道他的两个子节点(如果有子节点),如果知道子...
  • 关于原生JS获取节点,一直是个头疼的问题,而且调用方法的名字又贼长了,所以我选择用JQ,好像跑题了-- 话不多说看代码 获取父节点 及 父节点下所有子节点(兄弟节点) &lt;ul&gt; &lt;li&gt...
  • 题目:HEAP-DELETE(A,i)操作将节点i中的项从中删去。对含n个元素的最大,请给出时间为O(lgn)的HEAP-DELETE的实现。 编程思路: 我们可以用中最后一个元素a[heapSize]放到节点i 位置,然后将heapSize减一。...
  • 其满足中间节点大于左子树和右子树上所有节点值的特点,为保证其存储、查找和删除的遍历,通常采用数组的形式进行构建。 本文实现了最小和最大的构建、顶查找、删除、插入等基本功能。 最小 class ...
  • 最小的指定删除

    2020-05-23 23:51:58
    其实最小是可以指定删除某个节点的,包括最大。只要使用正确的方法 伪代码: // 向下调整 if (末尾节点key >要删除节点key) { //这里就使用尾换头的方法调整,只不过把所谓的 "头" 换成了指定节点 } // ...
  • 1、创建一个结构体:创建一个包含自身结构的结构体,该结构体包含一个数据...3、初始化创建链表:创建链表要分为头插法和尾插法,该部分要注意用malloc申请的空间是在里面,而用int等定义的申请的空间是在栈里面。 3
  • 2020-05-06 13:51:40
    我们知道二叉查找树与性质是有矛盾的,解决办法就是元素值以二叉查找树的性质分布,每个元素插入时都会随机生成一个优先级,优先级要满足性质中父节点大于等于子节点的性质,但不要求满足完全二叉树的性质。...
  • 最大的插入和删除

    2020-03-23 00:38:43
    首先,我们要了解这种数据结构,这里的具有完全二叉树的结构,并且树中某个节点的值总是不大于或不小于其孩子节点的值(‘不大于’的情况叫最小,‘不小于的情况叫最大’),树中每个节点的子树都是树...
  • else //删除中间节点 { p1->next->pre = p1->pre; p1->pre->next = p1->next; free(p1); //需要释p1指向的空间 } } else { cout !" ; } return head; } int _tmain(int argc, _TCHAR * ...
  • EOS多节点组网

    2018-11-11 14:30:04
    区块链公链都是基于p2p网络,本篇文章将建立一个多节点不同职责参与的EOS的测试网络,根据路上发现的可做文章的技术点大做文章。...源节点就是第一个EOS节点(Genesis node),也可以叫主节点,EOS多节点组网的前...
  • 其中,我们把根节点最大的叫做大顶堆,根节点最小的叫做小顶堆。 2.详解 2.1满二叉树 满二叉树是指所有层都达到最大节点数的二叉树。比如,下面这颗树: 2.2完全二叉树 完全二叉树是指除了最后一层其它...
  • 最小是一种符合下面两个特性的树形结构:最小是一颗完全二叉树,即最小的每个节点要么没有子节点,要么只有一个左子节点,要么有两个子节点。最小的每个节点都小于等于它的子节点的基本操作从性质2可以...
  • 删除堆顶元素如何基于实现排序?1. 建2. 排序解答开篇课后思考 如何理解“”? 是一种特殊的树,只要满足这两点,它就是一个是一个完全二叉树; 中每一个节点的值都必须大于等于(或小于等于)其...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,644
精华内容 13,057
关键字:

删除堆的中间节点