精华内容
下载资源
问答
  • 单链表的删除算法Delete

    千次阅读 2018-10-25 22:20:31
    1.删除操作 删除操作是将单链表的第i个结点删除。因为在单链表中结点ai的存储地址在其前驱结点ai-1的...2.删除算法的时间主要消耗在查找正确的删除位置上,故时间复杂度亦为O(n)。单链表删除算法的C++描述如下: ...

    1.删除操作
    删除操作是将单链表的第i个结点删除。因为在单链表中结点ai的存储地址在其前驱结点ai-1的指针域中,所以必须首先找到ai-1的存储地址p,然后令p的next的域指向ai的后继结点,即把结点ai从链上摘下,最后释放结点ai的存储空间。
    算法用伪代码描述如下:
    在这里插入图片描述
    2.删除算法的时间主要消耗在查找正确的删除位置上,故时间复杂度亦为O(n)。单链表删除算法的C++描述如下:

    在这里插入图片描述

    展开全文
  • 在上学期,用马丁的删除算法实现了K可靠最短路径。 这学期为了进行进一步算法比较,决定用最原始的YEN算法来计算K最短路径,算法最早提出人是YEN,于是算法因此而命名。 在查阅了大量资料后,终于搞明白了算法的...

    在上学期,用马丁的删除算法实现了K可靠最短路径。

    这学期为了进行进一步算法比较,决定用最原始的YEN算法来计算K最短路径,算法最早提出人是YEN,于是算法因此而命名。

    在查阅了大量资料后,终于搞明白了算法的思想,终取用java和C#实现它。

    步骤

    用DIjkstra算法求出最短路径 k=1;

    这条path中的任意两节点构成的边都可以作为偏离边,此边的开始节点为偏离节点

    然后依次将这条path上的偏离边去掉求最短路径。去最短的为次短路径,k=2;

    依次循环,知道K求出

    这里要注意两点:

    在我们寻找偏离边 u -> v' 的时候,如果 u == xi.pre (也就是当 要找的偏离边 和 xi 的偏离边 是从同一点出发时),则要注意 u -> v' 不仅要和 u -> xi.v 不同,而且要和 xi 的所有祖先状态中从点 u 出发的那条边都不同,不然新发展的状态岂不是和 xi 的祖先状态重复了。

    可能有很多偏离路径都是从同一点偏离出来的,但是它们的偏离边都不相同。要在程序中实现这一点,可以在每个状态中记录下所有祖先状态的偏离边。



    function YenKSP(Graph, source, sink, K):
       // Determine the shortest path from the source to the sink.
       A[0] = Dijkstra(Graph, source, sink);
       // Initialize the heap to store the potential kth shortest path.
       B = [];
       
       for k from 1 to K:
           // The spur node ranges from the first node to the next to last node in the previous k-shortest path.
           for i from 0 to size(A[k − 1]) − 1:
               
               // Spur node is retrieved from the previous k-shortest path, k − 1.
               spurNode = A[k-1].node(i);
               // The sequence of nodes from the source to the spur node of the previous k-shortest path.
               rootPath = A[k-1].nodes(0, i);
               
               for each path p in A:
                   if rootPath == p.nodes(0, i):
                       // Remove the links that are part of the previous shortest paths which share the same root path.
                       remove p.edge(i, i + 1) from Graph;
               
               for each node rootPathNode in rootPath except spurNode:
                   remove rootPathNode from Graph;
               
               // Calculate the spur path from the spur node to the sink.
               spurPath = Dijkstra(Graph, spurNode, sink);
               
               // Entire path is made up of the root path and spur path.
               totalPath = rootPath + spurPath;
               // Add the potential k-shortest path to the heap.
               B.append(totalPath);
               
               // Add back the edges and nodes that were removed from the graph.
               restore edges to Graph;
               restore nodes in rootPath to Graph;
                       
           if B is empty:
               // This handles the case of there being no spur paths, or no spur paths left.
               // This could happen if the spur paths have already been exhausted (added to A), 
               // or there are no spur paths at all - such as when both the source and sink vertices 
               // lie along a "dead end".
               break;
           // Sort the potential k-shortest paths by cost.
           B.sort();
           // Add the lowest cost path becomes the k-shortest path.
           A[k] = B[0];
           B.pop();
       
       return A;
    参考资料:http://blog.csdn.net/pi9nc/article/details/12256019
             http://blog.csdn.net/kzm2008/article/details/5460152
    
    
    
    

    展开全文
  • 二叉搜索树(BST)的删除算法原理解析

    千次阅读 2016-11-03 23:36:37
    二叉搜索树的删除算法主要分两种情况: 1、要删除的节点只有一个孩子(左孩子或右孩子),这种情况比较简单,只需要将该孩子连接到当前节点的父节点即可。 下面重点讲讲第二种情况: 2、第二种情况便是要删除的...

    二叉搜索树的删除算法主要分两种情况:

    1、要删除的节点只有一个孩子(左孩子或右孩子),这种情况比较简单,只需要将该孩子连接到当前节点的父节点即可。


    下面重点讲讲第二种情况:

    2、第二种情况便是要删除的节点有两个孩子,这个时候的算法就比较复杂(相比较于只有一个孩子的情况)。首先我们需要找到待删除节点的左子树上的最大值节点,或者右子树上的最小值节点,然后将该节点的参数值与待删除的节点参数值进行交换,最后删除该节点,这样需要删除的参数就从该二叉树中删除了。


    对于第二种情况,由于需要进行节点交换,刚接触的时候,可能会困惑,进行交换之后的二叉树是否还满足二叉搜索树的结构特点呢?以与左子树最大节点交换为例,尽管左子树的根节点比其父节点小,但是左子树的节点中存在比左子树的根节点大的节点,这样如何保证其比右子树的根节点小呢?比如下面一个BST就不满足算法:


                                                                 39

                                                   30                         44

                                           27            36

                                    22          31              45(大于44)

                                                              37

    上面的二叉树乍一看满足BST的结构特点:左孩子的值小于父亲,右孩子的值大于父亲

    但是如从BST构成的角度,一步一步的分析,就会发现节点45应该在右子树上。


    其实,上述二叉树(如果是BST)的左子树的所有节点都应小于39,左子树节点的最大值也应该在30与39之间,不会存在大于44的情况。


    由上讨论,便知不存在左子树最大节点大于右子树根节点的情况了。(同理也不会存在右子树最小值大于左子树根节点的情况)


    下面附上一段BST删除算法代码(源于Clifford A.Shaffer 《date structures and algorithm analysis in C++》):

    (此段代码的删除不是简单意义上的删除,而是对二叉树的重构)

    //return the root of the updated tree after removal
    //t point to the removed node
    BinNode<Elem>* removehelp(BinNode<Elem>* subroot, const Elem& e, BinNode<Elem>*& t) {
    	if (subroot == NULL) return NULL;
    	else if (e < subroot->val())
    		subroot->setLeft(removehelp(subroot->left(), e, t));
    	else if (e > subroot->val())
    		subroot->setRight(removehelp(subroot->right(), e, t));
    	else { // Found it: remove it
    		BinNode<Elem>* temp;
    		t = subroot;
    		if (subroot->left() == NULL)
    			subroot = subroot->right();
    		else if (subroot->right() == NULL)
    			subroot = subroot->left();
    		else {  // Both children are non-empty
    			subroot->setRight(deletemin(subroot->right(), temp));
    			Elem te = subroot->val();
    			subroot->setVal(temp->val());
    			temp->setVal(te);
    			t = temp;
    		}
    	}
    	return subroot;
    }
    //return the root of the tree after remove the node with the minimum value
    BinNode<Elem>* deletemin(BinNode<Elem>* subroot, BinNode<Elem>*& min) {
    	if (subroot->left() == NULL) {
    		min = subroot;
    		return subroot->right();
    	}
    	else { // Continue left
    		subroot->setLeft(deletemin(subroot->left(), min));
    		return subroot;
    	}
    }
    
    


    展开全文
  • Status ListDelete(LinkList *L,int i,ElemType *e) //单链表删除 { int j; LinkList p,q; p = *L; j = 1; while (p->next && j ) { p = p->next; ++j;} if (!(p->next) || j > i) return ERROR; q = p->next; p...
  • B+ tree 删除算法

    千次阅读 2017-07-13 16:34:15
    MD B+ 树有两种定义,一是严蔚敏老师的数据结构一书的定义,二是维基...1.算法描述与B-tree不同,B+tree只能从叶子删除,从叶子删除元素分为三次循环的三种情形: 第一次循环,如果满足条件结束,否则: 第二次循环,如
    MD
    B+ 树有两种定义,一是严蔚敏老师的数据结构一书的定义,二是维基百科的定义,本文采用维基百科的定义并实现。
    

    https://en.wikipedia.org/wiki/B%2B_tree
    前提知识:掌握B-tree ,了解B+插入算法及流程。

    1.算法描述

    与B-tree不同,B+tree只能从叶子删除,从叶子删除元素分为三次循环的三种情形:

    • 第一次循环,如果满足条件结束,否则:
    • 第二次循环,如果满足条件结束,否则:
    • 第三次循环,如满足条件线束,否则继续调用第三次循环。

    第一次循环的三种情形:

    
     情形1:
若x->keynum>Min,则只需删去K及其右指针(*x是叶子)即可使,父节点的索引元素也要重新调整,
         如果K还出现在非父索引节点中,取K的后继元素代替之,删除操作结束。
    

    情形2:
若x->keynum=Min,如左或右兄弟Keynum>Min,借一个填充K,如果K同时作为非父节点的索引元素,用新的K位置上的值并取代其索引元素;
            如果因此父节点的索引被打乱,则索引元素重新取该元素对应的孩子的最小元素。如果该节点是索引节点,孩子一同过继。
         情形3:
若x->keynum=Min,  第一步:左或右合并,删除本元素,
         剩下的元素和孩子过继给左或右兄弟,删除节点,叶子链接调整。
    
         第二步:进行第2次递归调用干掉父元素。递归调用步骤:
                  删除本元素,剩下的元素和孩子过继给左兄弟

    第二次循环的三种情形:

       情形一:只需删去K,移位,调整索引,但不需要用后继元素做替换
       情形二:如左或右兄弟Keynum>Min,借一个填充K,如果K同时作为非父节点的索引元素,取后继元素取代之,
       父节点相应元素的顺序可能被打破,需要取该位置后继元素取代之。删除结束。
       情形三:
         左合并:删除本元素,剩下的元素和孩子过继给左兄弟。如果它的孩子是叶子,
         调整索引(哪个索引有变动重排哪个,不必全部重排)递归调用删除父元素。
         右合并;与左合并一样.

    第三次循环的三种情形:

        与B-树步骤一样,省略。

    2. 举例子

    插入:
    char r[21] = {‘C’, ‘N’, ‘G’, ‘A’, ‘H’, ‘E’, ‘K’, ‘Q’, ‘M’, ‘F’, ‘W’, ‘L’, ‘T’, ‘Z’, ‘D’, ‘P’, ‘R’, ‘X’, ‘Y’, ‘S’,’B’};
    这里写图片描述
    Min= (max_degree+1)/2-1;
Max=max_degree-1;
    约定:
    本例m=5阶。
    S3=situation 3=情形3
    S2=situation 2=情形2
    S1=situation 1=情形1
    S2-right = 情形2,向右兄弟借一个元素
    S2-left = 情形2,向左兄弟借一个元素
    S3-right -> S2-right ,S3 第一次右合并,第二次情形2的右兄弟借元素
    S1 delete A :

    delete : A
    第 1 层, 1 node : K2 层, 2 node : D G 
          第 3 层, 2 node : B C3 层, 3 node : D E F 
          第 3 层, 2 node : G H 
       第 2 层, 4 node : N Q T X 
          第 3 层, 3 node : K L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R S 
          第 3 层, 2 node : T W 
          第 3 层, 3 node : X Y Z 

    S2-right delete AB

    delete : A
    第 1 层, 1 node : K2 层, 2 node : D G 
          第 3 层, 2 node : B C3 层, 3 node : D E F 
          第 3 层, 2 node : G H 
       第 2 层, 4 node : N Q T X 
          第 3 层, 3 node : K L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R S 
          第 3 层, 2 node : T W 
          第 3 层, 3 node : X Y Z 
    delete : B
    第 1 层, 1 node : K2 层, 2 node : E G 
          第 3 层, 2 node : C D3 层, 2 node : E F 
          第 3 层, 2 node : G H 
       第 2 层, 4 node : N Q T X 
          第 3 层, 3 node : K L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R S 
          第 3 层, 2 node : T W 
          第 3 层, 3 node : X Y Z 
    

    S2-left delete DE

    delete : D1 层, 1 node : K2 层, 2 node : E G 
          第 3 层, 3 node : A B C3 层, 2 node : E F 
          第 3 层, 2 node : G H 
       第 2 层, 4 node : N Q T X 
          第 3 层, 3 node : K L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R S 
          第 3 层, 2 node : T W 
          第 3 层, 3 node : X Y Z 
    delete : E1 层, 1 node : K2 层, 2 node : C G 
          第 3 层, 2 node : A B 
          第 3 层, 2 node : C F 
          第 3 层, 2 node : G H 
       第 2 层, 4 node : N Q T X 
          第 3 层, 3 node : K L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R S 
          第 3 层, 2 node : T W 
          第 3 层, 3 node : X Y Z 

    S3-right -> S2-right delete ABC:

    delete : A
    第 1 层, 1 node : K2 层, 2 node : D G 
          第 3 层, 2 node : B C3 层, 3 node : D E F 
          第 3 层, 2 node : G H 
       第 2 层, 4 node : N Q T X 
          第 3 层, 3 node : K L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R S 
          第 3 层, 2 node : T W 
          第 3 层, 3 node : X Y Z 
    delete : B
    第 1 层, 1 node : K2 层, 2 node : E G 
          第 3 层, 2 node : C D3 层, 2 node : E F 
          第 3 层, 2 node : G H 
       第 2 层, 4 node : N Q T X 
          第 3 层, 3 node : K L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R S 
          第 3 层, 2 node : T W 
          第 3 层, 3 node : X Y Z 
    delete : C1 层, 1 node : N2 层, 2 node : G K3 层, 3 node : D E F 
          第 3 层, 2 node : G H 
          第 3 层, 3 node : K L M 
       第 2 层, 3 node : Q T X 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R S 
          第 3 层, 2 node : T W 
          第 3 层, 3 node : X Y Z 
    

    为了测试其它情形,重新插入:
    char r[17] = {‘C’, ‘G’, ‘L’, ‘N’,’Q’, ‘M’, ‘T’, ‘D’, ‘P’, ‘R’,’H’,’J’,K,’I’,’F’,’A’,’B’};
    这里写图片描述

    S3-left -> S2-left delete RT

    delete : R
    第 1 层, 1 node : L 
       第 2 层, 3 node : C G I3 层, 2 node : A B 
          第 3 层, 3 node : C D F 
          第 3 层, 2 node : G H 
          第 3 层, 3 node : I J K2 层, 2 node : N Q 
          第 3 层, 2 node : L M 
          第 3 层, 2 node : N P 
          第 3 层, 2 node : Q T 
    delete : T
    第 1 层, 1 node : I2 层, 2 node : C G 
          第 3 层, 2 node : A B 
          第 3 层, 3 node : C D F 
          第 3 层, 2 node : G H 
       第 2 层, 2 node : L N3 层, 3 node : I J K3 层, 2 node : L M 
          第 3 层, 3 node : N P Q 

    S3-left -> S3-right delete IJAB

    delete : I1 层, 1 node : L 
       第 2 层, 3 node : C G J 
          第 3 层, 2 node : A B 
          第 3 层, 3 node : C D F 
          第 3 层, 2 node : G H 
          第 3 层, 2 node : J K2 层, 2 node : N Q 
          第 3 层, 2 node : L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R T 
    delete : J
    第 1 层, 1 node : L 
       第 2 层, 2 node : C G 
          第 3 层, 2 node : A B 
          第 3 层, 3 node : C D F 
          第 3 层, 3 node : G H K2 层, 2 node : N Q 
          第 3 层, 2 node : L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R T 
    delete : A
    第 1 层, 1 node : L 
       第 2 层, 2 node : D G 
          第 3 层, 2 node : B C3 层, 2 node : D F 
          第 3 层, 3 node : G H K2 层, 2 node : N Q 
          第 3 层, 2 node : L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R T 
    delete : B
    第 1 层, 4 node : G L N Q 
       第 2 层, 3 node : C D F 
       第 2 层, 3 node : G H K2 层, 2 node : L M 
       第 2 层, 2 node : N P 
       第 2 层, 3 node : Q R T 

    S3-right -> S3-left delete IJL

    delete : I1 层, 1 node : L 
       第 2 层, 3 node : C G J 
          第 3 层, 2 node : A B 
          第 3 层, 3 node : C D F 
          第 3 层, 2 node : G H 
          第 3 层, 2 node : J K2 层, 2 node : N Q 
          第 3 层, 2 node : L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R T 
    delete : J
    第 1 层, 1 node : L 
       第 2 层, 2 node : C G 
          第 3 层, 2 node : A B 
          第 3 层, 3 node : C D F 
          第 3 层, 3 node : G H K2 层, 2 node : N Q 
          第 3 层, 2 node : L M 
          第 3 层, 2 node : N P 
          第 3 层, 3 node : Q R T 
    delete : L
    第 1 层, 4 node : C G M Q 
       第 2 层, 2 node : A B 
       第 2 层, 3 node : C D F 
       第 2 层, 3 node : G H K2 层, 3 node : M N P 
       第 2 层, 3 node : Q R T 

    后续上传源码

    展开全文
  • 双向链表结点的插入和删除算法

    千次阅读 多人点赞 2018-10-03 23:47:46
    双向链表的插入与删除 双向链表的结点定义 #define ElemType int //双向链表的存储结构 typedef struct DuLNode { ElemType data; DuLNode *prior; DuLNode *next; }DuLNode, *DuLinkList; 双向链表...
  • 线性链表的查找插入删除算法

    千次阅读 2017-08-14 16:16:54
    插入操作具体算法 Status ListInsert_L(Linklist &L,int i,Elemtype e){ //在带头结点的单链表L中第i个位置之前插入元素e LinkList p=L;//p为移动指针,指向头结点 LNode *s; int j=0; for(p&&j) { //找到第i...
  • 二叉查找树的删除算法

    千次阅读 2004-08-21 23:25:00
    二叉查找树的实现中, 删除算法是最难的, 对于我来说, 尤其困惑了好长时间, 需要画图及一些想象力. 由于我的类中有一些成员对方法提供了支持, 所以先看看类的声明:public class BinaryTree { public TreeNode root;...
  • 实验目的: 熟悉红黑树的性质,使用java语言实现红黑树的插入删除算法,并测试实现的算法。问题定义 尝试构造一个红黑树。实现红黑树的定义,并且实现其插入删除的算法。插入或者删除某个元素之后扔保持红黑树的...
  • 二叉排序树的构造、查找、插入及删除算法的实现(C++) 转自这里 #include using namespace std; class BsTree { public: // 构造函数初始化树根为NULL,表示空树 BsTree (void) : m_pRoot (NULL), m_uSize (0)...
  • 顺序表的插入,删除算法

    千次阅读 2015-10-11 12:37:05
    1,顺序表的插入算法:  算法描述:在一个顺序表的第i个元素前插入元素e,并打印新的顺序表中的元素#include #include #define SIZE 100 #define INCREMENT_SIZE 10 typedef struct { int *elem; int length; ...
  • 将串S中从第i个字符起长度为len的字串删除 void strdelete(seqstring *S,int i,int len) { int k; if(i|| i>S->length || i+len-1>MAXSIZE) { printf("can not delete\n"); return ; } for(k=i-1;k...
  • 单链表的插入与删除算法

    千次阅读 2015-10-11 12:41:08
    2,单链表的删除算法  算法描述:在一个带头结点的单链表中,删除表中第i个结点,返回删除结点的值,并输出删除后的单链表。  代码如下:   #include #include #define SIZE 100 #define INCREMENT_...
  • 顺序表删除算法Delete </pre><pre name="code" class="cpp">template <class DataType> DataType SeqList<DataType>::Delete(int i) { if(length==0) throw "下溢"; if(i||i>length) throw "位置"; //这里...
  • 平时我们在计算单链表的第i个节点删除时间复杂度时一般认为是O(n),过程如下 1.先从头节点开始遍历链表,找到第i-1个节点 2.将第i-1节点next指向第i个节点的next 可以看到时间主要花在了遍历链表上 如果我们...
  • 什么是线性表?  线性表是n个数据元素的有限序列。根据线性表的显现方式,线性表又分为顺序表(数据元素在内存中的存储空间是连续的)和链表(数据元素在内存中的存储...操作包含在指定位置插入某一元素、删除指定...
  • 双向链表的插入和删除算法

    千次阅读 2011-12-07 20:50:04
    1.在带有头结点的双向循环链表中第1个数据域内容为x的结点右边插入一个数据信息为item的新结点,算法如下: typedef struct node{ int data; struct node *llink, *rlink; }DNode, *DLinkList; int insertElem( ...
  • BST的概念BST,又叫平衡二叉树,是一种循关键码访问的二叉树,并且要求保持顺序性,即任一...BST的查找算法BinNodePos(T) BST_Search1(BinNodePos(T)&amp;v,const T&amp; e,BinNodePos(T)hot) {  if(v==n...
  • 请输入节点个数:10 请依次输入10个字母 ...请输入要删除的键: S 节点颜色是否为红: false false false false false false false true true 层序遍历 M E R C L P X A H 先序遍历 M E C A L H R P X
  • 之前的删除算法不需要返回节点对象,现在开始要加入了,不然,如果删掉原先的root节点,要从哪里找入口打印呢?我认为必须有个入口节点,让我搜到整颗树的树根,我决定用替代节点作为入口。 那为啥有两个孩子的...
  • case 4:cout请输入删除位置:"; cin>>i; ListDelete(L,i); break; case 0:break; default:cout你的选择有错,请重新选择!" ; } cout请输入你的选择:"; cin>>x; } return 0; }
  • 首先执行查找算法,找出被插结点的父亲结点。 ○ 判断被插结点是其父亲结点的左、右儿子。将被插结点作为叶子结点插入。 ○ 若二叉树为空。则首先单独生成根结点。 注意:新插入的结点总是叶子结点。...
  • #include using namespace std; typedef int elementType; typedef struct lnode { elementType data; struct lnode *next; }Lnode,*LinkList; void create(LinkList &L) { LinkList r,p;... L=n
  • 红黑树插入、删除、查找算法学习

    千次阅读 2015-11-11 19:53:19
    红黑树(red-black tree)是许多“平衡”搜索树中的一种,可以保证在最坏情况下基本动态集合操作的时间复杂度为O(lgn),文章讲述红黑树的性质,结构描述,插入、删除算法分析,最后完成一个C语言测试程序。
  • 链表删除指定元素算法

    千次阅读 2019-06-07 14:23:22
    链表删除指定元素算法 我们只需要分情况理清楚就很简单 在算法分析的时候记清楚自己的思路是最重要的 只要链表里有一个元素与给定的元素不相同 第一次与给定元素不相同的节点就为头节点 1:改变头节点 2:不改变头...
  • 分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!... /* ...从数字0开始,每次从这个圆圈中删除第m个数字(第一个为当前数字本身,第二个为当前数字的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 662,534
精华内容 265,013
关键字:

删除算法