PeopleCode实现LinkedList

已于 2024-04-24 10:24:33 修改
阅读量177 收藏
点赞数 3
分类专栏： peopleSoft peopleCode 文章标签： 链表
于 2024-03-22 17:50:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28371343/article/details/136947812
版权

链表集合类简介及对比Array：

    基于链表实现的列表集合
    在执行向头部插入(unshift)或删除(removeFirst)和两个集合合并(addLinkedList)或插入(setLinkedList)时速度远远高于Array
    在执行截取(interceptList)时速度远高于Array
    在执行随机插入(set)和替换(replace)时整体速度高于Array
    在执行末尾部插入或删除时理论速度与Array基本相同，但在peopleCode中速度会低于Array
    执行倒序(Reverse)时速度稍低于Array
    随机取数和使用for遍历时速度远低于Array，遍历时应使用迭代遍历或指针遍历方式

具体区别可参阅Java的ArrayList和LinkedList区别的相关文献。

链表集合节点使用any数组，数组第一位为上一个节点，第二位为本节点，第三位为下一节点

本来节点使用实体类实现，但是发现peopleCode对自定义class操作没有对any数组操作快。

peopleCode实现代码如下：

/* CSQ ADD 链表集合类 
	基于链表实现的列表集合
	在执行向头部插入(unshift)或删除(removeFirst)和两个集合合并(addLinkedList)或插入(setLinkedList)时速度远远高于Array
	在执行截取(interceptList)时速度远高于Array
	在执行随机插入(set)和替换(replace)时整体速度高于Array
	在执行末尾部插入或删除时速度与Array基本相同，但在peopleCode中速度会低于Array
	执行倒序(Reverse)时速度稍低于Array
	随机取数和使用for遍历时速度远低于Array，遍历时应使用迭代遍历或指针遍历方式
*/
/*
	链表集合节点使用any数组，数组第一位为上一个节点，第二位为本节点，第三位为下一节点。
	本来节点使用实体类实现，但是发现peopleCode对自定义class操作没有对any数组操作快。
*/

class LinkedList
   /* 集合长度 */
   property integer len get;
   /* 添加元素到集合末尾 */
   method add(&element As any);
   /* 添加节点到集合末尾。注意：此方法会改变&node的前后指针，导致原本引用此节点的LinkedList实例的结构失效！ */
   method addNode(&node As array);
   /* 添加集合到集合末尾。注意：此方法会改变&linkedList的指针数据，导致传入的&linkedList不可用！ */
   method addLinkedList(&linkedList As GT_COMMON:UTIL:LinkedList);
   
   /* 添加元素到集合前面 */
   method unshift(&element As any);
   /* 添加节点到集合前面。注意：此方法会改变&node的前后指针，导致原本引用此节点的LinkedList实例的结构失效！ */
   method unshiftNode(&node As array);
   /* 添加集合到集合前面。注意：此方法会改变&linkedList的指针数据，导致传入的&linkedList不可用！ */
   method unshiftLinkedList(&linkedList As GT_COMMON:UTIL:LinkedList);
   
   /* 插入元素到集合&index位置 */
   method set(&index As integer, &element As any);
   /* 插入节点到集合&index位置。注意：此方法会改变&node的前后指针，导致原本引用此节点的LinkedList实例的结构失效！ */
   method setNode(&index As integer, &node As array);
   /* 插入集合到集合&index位置。注意：此方法会改变&linkedList的指针数据，导致传入的&linkedList不可用！ */
   method setLinkedList(&index As integer, &linkedList As GT_COMMON:UTIL:LinkedList);
   
   /* 获取集合内第&index个元素 */
   method get(&index As integer) Returns any;
   /* 获取集合内第&index个节点 */
   method getNode(&index As integer) Returns array;
   /* 获取集合内第一个元素 */
   method getFirst() Returns any;
   /* 获取集合内第一个节点 */
   method getFirstNode() Returns array;
   /* 获取集合内最后一个元素 */
   method getLast() Returns any;
   /* 获取集合内最后一个节点 */
   method getLastNode() Returns array;
   
   /* 替换&startIndex到&endIndex元素为&element */
   method replace(&startIndex As integer, &endIndex As integer, &element As any);
   /* 替换&startIndex到&endIndex节点为&element。注意：此方法会改变&node的前后指针，导致原本引用此节点的LinkedList实例的结构失效！ */
   method replaceNode(&startIndex As integer, &endIndex As integer, &node As array);
   /* 替换&startIndex到&endIndex节点为&linkedList。注意：此方法会改变&linkedList的指针数据，导致传入的&linkedList不可用！ */
   method replaceToLinkedList(&startIndex As integer, &endIndex As integer, &linkedList As GT_COMMON:UTIL:LinkedList);
   /* 截取列表，保留从&startIndex到&endIndex的元素 */
   method interceptList(&startIndex As integer, &endIndex As integer);
   
   /* 倒序当前列表集合 */
   method reverse();
   
   /* 交换&index1和&index2的位置 */
   method exchange(&index1 As integer, &index2 As integer);
   
   /* 移除稽核内第&index个元素 */
   method remove(&index As integer);
   /* 移除稽核内第一个元素 */
   method removeFirst();
   /* 移除稽核内最后一个元素 */
   method removeLast();
   
   /* 返回集合长度 */
   method getSize() Returns integer;
   
   
   /* 以下为指针遍历LinkedList相关方法。
		正序遍历示例：
		&linkedList.initializePointerToFirst();
		while &linkedList.hasNext()
			&anyValue = &linkedList.next();	 
		end-while;
		倒序遍历示例：
		&linkedList.initializePointerToLast();
		while &linkedList.hasPrevious()
			&anyValue = &linkedList.previous();	 
		end-while;
   */
   method initializePointerToFirst();
   method initializePointerToLast();
   /* 初始化指针到指定的&index位置上 */
   method initializePointerToIndex(&index As integer);
   
   method hasNext() Returns boolean;
   method next() Returns any;
   method hasPrevious() Returns boolean;
   method previous() Returns any;
   
private
   instance integer &size;
   instance array &pointer;
   instance array &firstNode;
   instance array &lastNode;
end-class;

get len
   /+ Returns Integer +/
   Return %This.size;
end-get;

method add
   /+ &element as Any +/
   Local array &node = CreateArrayAny( Null, Null, Null);
   &node [2] = &element;
   %This.addNode(&node);
end-method;

method addNode
   /+ &node as Array of Any +/
   If %This.firstNode = Null Then
      %This.firstNode = &node;
      %This.lastNode = &node;
   Else
      %This.lastNode [3] = &node;
      &node [1] = %This.lastNode;
      %This.lastNode = &node;
   End-If;
   %This.size = %This.size + 1;
end-method;

method addLinkedList
   /+ &linkedList as GT_COMMON:UTIL:LinkedList +/
   If &linkedList.len = 0 Then
      Return;
   Else
      If %This.size = 0 Then
         %This.firstNode = &linkedList.getFirstNode();
         %This.lastNode = &linkedList.getLastNode();
         %This.size = &linkedList.len;
         Return;
      End-If;
   End-If;
   Local array &node = &linkedList.getFirstNode();
   %This.lastNode [3] = &node;
   &node [1] = %This.lastNode;
   %This.lastNode = &linkedList.getLastNode();
   %This.size = %This.size + &linkedList.len;
end-method;

method unshift
   /+ &element as Any +/
   Local array &node = CreateArrayAny( Null, Null, Null);
   &node [2] = &element;
   %This.unshiftNode(&node);
end-method;

method unshiftNode
   /+ &node as Array of Any +/
   If %This.firstNode = Null Then
      %This.firstNode = &node;
      %This.lastNode = &node;
   Else
      %This.firstNode [1] = &node;
      &node [1] = Null;
      &node [3] = %This.firstNode;
      %This.firstNode = &node;
   End-If;
   %This.size = %This.size + 1;
end-method;

method unshiftLinkedList
   /+ &linkedList as GT_COMMON:UTIL:LinkedList +/
   If &linkedList.len = 0 Then
      Return;
   Else
      If %This.size = 0 Then
         %This.firstNode = &linkedList.getFirstNode();
         %This.lastNode = &linkedList.getLastNode();
         %This.size = &linkedList.len;
         Return;
      End-If;
   End-If;
   Local array &node = &linkedList.getLastNode();
   %This.firstNode [1] = &node;
   &node [3] = %This.firstNode;
   %This.firstNode = &linkedList.getFirstNode();
   %This.size = %This.size + &linkedList.len;
end-method;

method set
   /+ &index as Integer, +/
   /+ &element as Any +/
   Local array &node = CreateArrayAny( Null, Null, Null);
   &node [2] = &element;
   %This.setNode(&index, &node);
end-method;

method setNode
   /+ &index as Integer, +/
   /+ &node as Array of Any +/
   If &index = 1 Then
      %This.firstNode [1] = &node;
      &node [1] = Null;
      &node [3] = %This.firstNode;
      %This.firstNode = &node;
   Else
      Local array &node2 = %This.getNode(&index);
      Local array &node1 = &node2 [1];
      &node [1] = &node1;
      &node1 [3] = &node;
      &node [3] = &node2;
      &node2 [1] = &node;
   End-If;
   %This.size = %This.size + 1;
end-method;

method setLinkedList
   /+ &index as Integer, +/
   /+ &linkedList as GT_COMMON:UTIL:LinkedList +/
   If &linkedList.len = 0 Then
      Return;
   End-If;
   If &index = 1 Then
      Local array &node = &linkedList.getLastNode();
      %This.firstNode [1] = &node;
      &node [3] = %This.firstNode;
      %This.firstNode = &linkedList.getFirstNode();
   Else
      Local array &node2 = %This.getNode(&index);
      Local array &node1 = &node2 [1];
      Local array &nodeSet1 = &linkedList.getFirstNode();
      Local array &nodeSet2 = &linkedList.getLastNode();
      &nodeSet1 [1] = &node1;
      &node1 [3] = &nodeSet1;
      &nodeSet2 [3] = &node2;
      &node2 [1] = &nodeSet2;
   End-If;
   %This.size = %This.size + &linkedList.len;
end-method;

method get
   /+ &index as Integer +/
   /+ Returns Any +/
   Return %This.getNode(&index)[2];
end-method;

method getNode
   /+ &index as Integer +/
   /+ Returns Array of Any +/
   If &index > %This.size Then
      throw CreateException(0, 0, "数组越界:&index-" | &index | "不在集合1到" | %This.size | "范围内");
   End-If;
   Local array &node;
   Local integer &i;
   If (%This.size - &index) < &index Then /* &index靠后，从末尾开始查找 */
      &node = %This.lastNode;
      For &i = %This.size To 1 Step - 1
         If &index = &i Then
            Return &node;
         End-If;
         &node = &node [1];
      End-For;
   Else /* &index靠前，从头部开始查找 */
      &node = %This.firstNode;
      For &i = 1 To %This.size
         If &index = &i Then
            Return &node;
         End-If;
         &node = &node [3];
      End-For;
   End-If;
end-method;

method getFirst
   /+ Returns Any +/
   Return %This.firstNode [2];
end-method;

method getFirstNode
   /+ Returns Array of Any +/
   Return %This.firstNode;
end-method;

method getLast
   /+ Returns Any +/
   Return %This.lastNode [2];
end-method;

method getLastNode
   /+ Returns Array of Any +/
   Return %This.lastNode;
end-method;

method replace
   /+ &startIndex as Integer, +/
   /+ &endIndex as Integer, +/
   /+ &element as Any +/
   Local array &node = CreateArrayAny( Null, Null, Null);
   &node [2] = &element;
   %This.replaceNode(&startIndex, &endIndex, &node);
end-method;

method replaceNode
   /+ &startIndex as Integer, +/
   /+ &endIndex as Integer, +/
   /+ &node as Array of Any +/
   If &startIndex > &endIndex Then
      Local integer &i = &startIndex;
      &startIndex = &endIndex;
      &endIndex = &i;
   End-If;
   Local array &node2 = %This.get(&endIndex)[3];
   Local array &node1 = %This.get(&startIndex)[1];
   If &node2 = Null Then
      %This.lastNode = &node;
   Else
      &node2 [1] = &node;
   End-If;
   &node [3] = &node2;
   &node [1] = &node1;
   If &node1 = Null Then
      %This.firstNode = &node;
   Else
      &node1 [3] = &node;
   End-If;
   %This.size = %This.size + &endIndex - &startIndex + 2;
end-method;

method replaceToLinkedList
   /+ &startIndex as Integer, +/
   /+ &endIndex as Integer, +/
   /+ &linkedList as GT_COMMON:UTIL:LinkedList +/
   If &startIndex > &endIndex Then
      Local integer &i = &startIndex;
      &startIndex = &endIndex;
      &endIndex = &i;
   End-If;
   Local array &node2 = %This.get(&endIndex)[3];
   Local array &node1 = %This.get(&startIndex)[1];
   Local array &nodeR2 = &linkedList.getLastNode();
   Local array &nodeR1 = &linkedList.getFirstNode();
   If &node2 = Null Then
      %This.lastNode = &nodeR2;
   Else
      &node2 [1] = &nodeR2;
   End-If;
   &nodeR2 [3] = &node2;
   &nodeR1 [1] = &node1;
   If &node1 = Null Then
      %This.firstNode = &nodeR1;
   Else
      &node1 [3] = &nodeR1;
   End-If;
   %This.size = %This.size + &endIndex - &startIndex + 1 + &linkedList.len;
end-method;

method interceptList
   /+ &startIndex as Integer, +/
   /+ &endIndex as Integer +/
   If &startIndex > &endIndex Then
      Local integer &i = &startIndex;
      &startIndex = &endIndex;
      &endIndex = &i;
   End-If;
   Local array &node1 = %This.get(&startIndex);
   Local array &node2 = %This.get(&endIndex);
   %This.firstNode = &node1;
   %This.lastNode = &node2;
   %This.firstNode [1] = Null;
   %This.lastNode [3] = Null;
   %This.size = &endIndex - &startIndex + 1;
end-method;

method reverse
   /* Local array &node1 = %This.firstNode;
   %This.firstNode = %This.lastNode;
   %This.lastNode = &node1;
   Local integer &i;
   Local array &node2 = &node1[3];
   Local array &node3;
   For &i = 1 To %This.size
      If &node2 = Null Then
         Break;
      End-If;
      &node3 = &node2[3];
      &node2[3] = &node1;
      &node1[1] = &node2;
      &node1 = &node2;
      &node2 = &node3;
   End-For;
   %This.firstNode[1] = Null;
   %This.lastNode[3] = Null; */
   Local array &nodeLeft = %This.firstNode;
   Local array &nodeRight = %This.lastNode;
   Local integer &i = 1;
   Local any &any;
   While True
      If &i * 2 > %This.size Then
         Return;
      End-If;
      &any = &nodeLeft [2];
      &nodeLeft [2] = &nodeRight [2];
      &nodeRight [2] = &any;
      &nodeLeft = &nodeLeft [3];
      &nodeRight = &nodeRight [1];
      &i = &i + 1;
   End-While;
end-method;

method exchange
   /+ &index1 as Integer, +/
   /+ &index2 as Integer +/
   Local array &node1 = %This.get(&index1);
   Local array &node2 = %This.get(&index2);
   Local any &any = &node1 [2];
   &node1 [2] = &node2 [2];
   &node2 [2] = &any;
end-method;

method remove
   /+ &index as Integer +/
   If &index = 1 Then
      %This.removeFirst();
      Return;
   Else
      If &index = %This.size Then
         %This.removeLast();
         Return;
      End-If;
   End-If;
   Local array &node = %This.get(&index);
   &node [1][3] = &node [3];
   &node [3][1] = &node [1];
   %This.size = %This.size - 1;
end-method;

method removeFirst
   If %This.size < 2 Then
      %This.firstNode = Null;
      %This.lastNode = Null;
      %This.size = 0;
   Else
      %This.firstNode = %This.firstNode [3];
      %This.firstNode [1] = Null;
      %This.size = %This.size - 1;
   End-If;
end-method;

method removeLast
   If %This.size < 2 Then
      %This.firstNode = Null;
      %This.lastNode = Null;
      %This.size = 0;
   Else
      %This.lastNode = %This.lastNode [1];
      %This.lastNode [3] = Null;
      %This.size = %This.size - 1;
   End-If;
end-method;

method getSize
   /+ Returns Integer +/
   Return %This.size;
end-method;

method initializePointerToFirst
   %This.pointer = %This.firstNode;
end-method;

method initializePointerToLast
   %This.pointer = %This.lastNode;
end-method;

method initializePointerToIndex
   /+ &index as Integer +/
   %This.pointer = %This.getNode(&index);
end-method;

method hasNext
   /+ Returns Boolean +/
   Return (%This.pointer <> Null);
end-method;

method next
   /+ Returns Any +/
   Local array &nd = %This.pointer;
   %This.pointer = %This.pointer [3];
   Return &nd [2];
end-method;

method hasPrevious
   /+ Returns Boolean +/
   Return (%This.pointer <> Null);
end-method;

method previous
   /+ Returns Any +/
   Local array &nd = %This.pointer;
   %This.pointer = %This.pointer [1];
   Return &nd [2];
end-method;

以下是向第一位插入2万个元素测试，对比Array：

向最后一位插入2万个元素对比：

以下是旧实现代码，节点使用实体类实现，更便于理解。仅用于示例，代码不再更新。

LinkedList类：

/* CSQ ADD 链表集合类 
	基于链表实现的列表集合
	在执行向头部插入(unshift)或删除(removeFirst)和两个集合合并(addLinkedList)或插入(setLinkedList)时速度远远高于Array
	在执行截取(interceptList)时速度远高于Array
	在执行随机插入(set)和替换(replace)时整体速度高于Array
	在执行末尾部插入或删除时速度与Array基本相同
	执行倒序(Reverse)时速度稍低于Array
	随机取数和使用for遍历时速度远低于Array，遍历时应使用迭代遍历或指针遍历方式
*/
import COMMON:util:entity:LinkedNode;

class LinkedList
   /* 集合长度 */
   property integer len get;
   /* 添加元素到集合末尾 */
   method add(&element As any);
   /* 添加节点到集合末尾。注意：此方法会改变&node的前后指针，导致原本引用此节点的LinkedList实例的结构失效！ */
   method addNode(&node As COMMON:util:entity:LinkedNode);
   /* 添加集合到集合末尾。注意：此方法会改变&linkedList的指针数据，导致传入的&linkedList不可用！ */
   method addLinkedList(&linkedList As COMMON:util:LinkedList);
   
   /* 添加元素到集合前面 */
   method unshift(&element As any);
   /* 添加节点到集合前面。注意：此方法会改变&node的前后指针，导致原本引用此节点的LinkedList实例的结构失效！ */
   method unshiftNode(&node As COMMON:util:entity:LinkedNode);
   /* 添加集合到集合前面。注意：此方法会改变&linkedList的指针数据，导致传入的&linkedList不可用！ */
   method unshiftLinkedList(&linkedList As COMMON:util:LinkedList);
   
   /* 插入元素到集合&index位置 */
   method set(&index As integer, &element As any);
   /* 插入节点到集合&index位置。注意：此方法会改变&node的前后指针，导致原本引用此节点的LinkedList实例的结构失效！ */
   method setNode(&index As integer, &node As COMMON:util:entity:LinkedNode);
   /* 插入集合到集合&index位置。注意：此方法会改变&linkedList的指针数据，导致传入的&linkedList不可用！ */
   method setLinkedList(&index As integer, &linkedList As COMMON:util:LinkedList);
   
   /* 获取集合内第&index个元素 */
   method get(&index As integer) Returns any;
   /* 获取集合内第&index个节点 */
   method getNode(&index As integer) Returns COMMON:util:entity:LinkedNode;
   /* 获取集合内第一个元素 */
   method getFirst() Returns any;
   /* 获取集合内第一个节点 */
   method getFirstNode() Returns COMMON:util:entity:LinkedNode;
   /* 获取集合内最后一个元素 */
   method getLast() Returns any;
   /* 获取集合内最后一个节点 */
   method getLastNode() Returns COMMON:util:entity:LinkedNode;
   
   /* 替换&startIndex到&endIndex元素为&element */
   method replace(&startIndex As integer, &endIndex As integer, &element As any);
   /* 替换&startIndex到&endIndex节点为&element。注意：此方法会改变&node的前后指针，导致原本引用此节点的LinkedList实例的结构失效！ */
   method replaceNode(&startIndex As integer, &endIndex As integer, &node As COMMON:util:entity:LinkedNode);
   /* 替换&startIndex到&endIndex节点为&linkedList。注意：此方法会改变&linkedList的指针数据，导致传入的&linkedList不可用！ */
   method replaceToLinkedList(&startIndex As integer, &endIndex As integer, &linkedList As COMMON:util:LinkedList);
   /* 截取列表，保留从&startIndex到&endIndex的元素 */
   method interceptList(&startIndex As integer, &endIndex As integer);
   
   /* 倒序当前列表集合 */
   method reverse();
   
   /* 交换&index1和&index2的位置 */
   method exchange(&index1 As integer, &index2 As integer);
   
   /* 移除稽核内第&index个元素 */
   method remove(&index As integer);
   /* 移除稽核内第一个元素 */
   method removeFirst();
   /* 移除稽核内最后一个元素 */
   method removeLast();
   
   /* 返回集合长度 */
   method getSize() Returns integer;
   
   
   /* 以下为指针遍历LinkedList相关方法。
		正序遍历示例：
		&linkedList.initializePointerToFirst();
		while &linkedList.hasNext()
			&anyValue = &linkedList.next();	 
		end-while;
		倒序遍历示例：
		&linkedList.initializePointerToLast();
		while &linkedList.hasPrevious()
			&anyValue = &linkedList.previous();	 
		end-while;
   */
   method initializePointerToFirst();
   method initializePointerToLast();
   /* 初始化指针到指定的&index位置上 */
   method initializePointerToIndex(&index As integer);
   
   method hasNext() Returns boolean;
   method next() Returns any;
   method hasPrevious() Returns boolean;
   method previous() Returns any;
   
private
   instance integer &size;
   instance COMMON:util:entity:LinkedNode &pointer;
   instance COMMON:util:entity:LinkedNode &firstNode;
   instance COMMON:util:entity:LinkedNode &lastNode;
end-class;

get len
   /+ Returns Integer +/
   Return %This.size;
end-get;

method add
   /+ &element as Any +/
   Local COMMON:util:entity:LinkedNode &node = create COMMON:util:entity:LinkedNode(&element);
   %This.addNode(&node);
end-method;

method addNode
   /+ &node as COMMON:util:entity:LinkedNode +/
   If %This.firstNode = Null Then
      %This.firstNode = &node;
      %This.lastNode = &node;
   Else
      %This.lastNode.nextNode = &node;
      &node.previousNode = %This.lastNode;
      %This.lastNode = &node;
   End-If;
   %This.size = %This.size + 1;
end-method;

method addLinkedList
   /+ &linkedList as COMMON:util:LinkedList +/
   If &linkedList.len = 0 Then
      Return;
   Else
      If %This.size = 0 Then
         %This.firstNode = &linkedList.getFirstNode();
         %This.lastNode = &linkedList.getLastNode();
         %This.size = &linkedList.len;
         Return;
      End-If;
   End-If;
   Local COMMON:util:entity:LinkedNode &node = &linkedList.getFirstNode();
   %This.lastNode.nextNode = &node;
   &node.previousNode = %This.lastNode;
   %This.lastNode = &linkedList.getLastNode();
   %This.size = %This.size + &linkedList.len;
end-method;

method unshift
   /+ &element as Any +/
   Local COMMON:util:entity:LinkedNode &node = create COMMON:util:entity:LinkedNode(&element);
   %This.unshiftNode(&node);
end-method;

method unshiftNode
   /+ &node as COMMON:util:entity:LinkedNode +/
   If %This.firstNode = Null Then
      %This.firstNode = &node;
      %This.lastNode = &node;
   Else
      %This.firstNode.previousNode = &node;
      &node.previousNode = Null;
      &node.nextNode = %This.firstNode;
      %This.firstNode = &node;
   End-If;
   %This.size = %This.size + 1;
end-method;

method unshiftLinkedList
   /+ &linkedList as COMMON:util:LinkedList +/
   If &linkedList.len = 0 Then
      Return;
   Else
      If %This.size = 0 Then
         %This.firstNode = &linkedList.getFirstNode();
         %This.lastNode = &linkedList.getLastNode();
         %This.size = &linkedList.len;
         Return;
      End-If;
   End-If;
   Local COMMON:util:entity:LinkedNode &node = &linkedList.getLastNode();
   %This.firstNode.previousNode = &node;
   &node.nextNode = %This.firstNode;
   %This.firstNode = &linkedList.getFirstNode();
   %This.size = %This.size + &linkedList.len;
end-method;

method set
   /+ &index as Integer, +/
   /+ &element as Any +/
   Local COMMON:util:entity:LinkedNode &node = create COMMON:util:entity:LinkedNode(&element);
   %This.setNode(&index, &node);
end-method;

method setNode
   /+ &index as Integer, +/
   /+ &node as COMMON:util:entity:LinkedNode +/
   If &index = 1 Then
      %This.firstNode.previousNode = &node;
      &node.previousNode = Null;
      &node.nextNode = %This.firstNode;
      %This.firstNode = &node;
   Else
      Local COMMON:util:entity:LinkedNode &node2 = %This.getNode(&index);
      Local COMMON:util:entity:LinkedNode &node1 = &node2.previousNode;
      &node.previousNode = &node1;
      &node1.nextNode = &node;
      &node.nextNode = &node2;
      &node2.previousNode = &node;
   End-If;
   %This.size = %This.size + 1;
end-method;

method setLinkedList
   /+ &index as Integer, +/
   /+ &linkedList as COMMON:util:LinkedList +/
   If &linkedList.len = 0 Then
      Return;
   End-If;
   If &index = 1 Then
      Local COMMON:util:entity:LinkedNode &node = &linkedList.getLastNode();
      %This.firstNode.previousNode = &node;
      &node.nextNode = %This.firstNode;
      %This.firstNode = &linkedList.getFirstNode();
   Else
      Local COMMON:util:entity:LinkedNode &node2 = %This.getNode(&index);
      Local COMMON:util:entity:LinkedNode &node1 = &node2.previousNode;
      Local COMMON:util:entity:LinkedNode &nodeSet1 = &linkedList.getFirstNode();
      Local COMMON:util:entity:LinkedNode &nodeSet2 = &linkedList.getLastNode();
      &nodeSet1.previousNode = &node1;
      &node1.nextNode = &nodeSet1;
      &nodeSet2.nextNode = &node2;
      &node2.previousNode = &nodeSet2;
   End-If;
   %This.size = %This.size + &linkedList.len;
end-method;

method get
   /+ &index as Integer +/
   /+ Returns Any +/
   Return %This.getNode(&index).anyProperty;
end-method;

method getNode
   /+ &index as Integer +/
   /+ Returns COMMON:util:entity:LinkedNode +/
   If &index > %This.size Then
      throw CreateException(0, 0, "数组越界:&index-" | &index | "不在集合1到" | %This.size | "范围内");
   End-If;
   Local COMMON:util:entity:LinkedNode &node;
   Local integer &i;
   If (%This.size - &index) < &index Then /* &index靠后，从末尾开始查找 */
      &node = %This.lastNode;
      For &i = %This.size To 1 Step - 1
         If &index = &i Then
            Return &node;
         End-If;
         &node = &node.previousNode;
      End-For;
   Else /* &index靠前，从头部开始查找 */
      &node = %This.firstNode;
      For &i = 1 To %This.size
         If &index = &i Then
            Return &node;
         End-If;
         &node = &node.nextNode;
      End-For;
   End-If;
end-method;

method getFirst
   /+ Returns Any +/
   Return %This.firstNode.anyProperty;
end-method;

method getFirstNode
   /+ Returns COMMON:util:entity:LinkedNode +/
   Return %This.firstNode;
end-method;

method getLast
   /+ Returns Any +/
   Return %This.lastNode.anyProperty;
end-method;

method getLastNode
   /+ Returns COMMON:util:entity:LinkedNode +/
   Return %This.lastNode;
end-method;

method replace
   /+ &startIndex as Integer, +/
   /+ &endIndex as Integer, +/
   /+ &element as Any +/
   Local COMMON:util:entity:LinkedNode &node = create COMMON:util:entity:LinkedNode(&element);
   %This.replaceNode(&startIndex, &endIndex, &node);
end-method;

method replaceNode
   /+ &startIndex as Integer, +/
   /+ &endIndex as Integer, +/
   /+ &node as COMMON:util:entity:LinkedNode +/
   If &startIndex > &endIndex Then
      Local integer &i = &startIndex;
      &startIndex = &endIndex;
      &endIndex = &i;
   End-If;
   Local COMMON:util:entity:LinkedNode &node2 = %This.get(&endIndex).nextNode;
   Local COMMON:util:entity:LinkedNode &node1 = %This.get(&startIndex).previousNode;
   If &node2 = Null Then
      %This.lastNode = &node;
   Else
      &node2.previousNode = &node;
   End-If;
   &node.nextNode = &node2;
   &node.previousNode = &node1;
   If &node1 = Null Then
      %This.firstNode = &node;
   Else
      &node1.nextNode = &node;
   End-If;
   %This.size = %This.size + &endIndex - &startIndex + 2;
end-method;

method replaceToLinkedList
   /+ &startIndex as Integer, +/
   /+ &endIndex as Integer, +/
   /+ &linkedList as COMMON:util:LinkedList +/
   If &startIndex > &endIndex Then
      Local integer &i = &startIndex;
      &startIndex = &endIndex;
      &endIndex = &i;
   End-If;
   Local COMMON:util:entity:LinkedNode &node2 = %This.get(&endIndex).nextNode;
   Local COMMON:util:entity:LinkedNode &node1 = %This.get(&startIndex).previousNode;
   Local COMMON:util:entity:LinkedNode &nodeR2 = &linkedList.getLastNode();
   Local COMMON:util:entity:LinkedNode &nodeR1 = &linkedList.getFirstNode();
   If &node2 = Null Then
      %This.lastNode = &nodeR2;
   Else
      &node2.previousNode = &nodeR2;
   End-If;
   &nodeR2.nextNode = &node2;
   &nodeR1.previousNode = &node1;
   If &node1 = Null Then
      %This.firstNode = &nodeR1;
   Else
      &node1.nextNode = &nodeR1;
   End-If;
   %This.size = %This.size + &endIndex - &startIndex + 1 + &linkedList.len;
end-method;

method interceptList
   /+ &startIndex as Integer, +/
   /+ &endIndex as Integer +/
   If &startIndex > &endIndex Then
      Local integer &i = &startIndex;
      &startIndex = &endIndex;
      &endIndex = &i;
   End-If;
   Local COMMON:util:entity:LinkedNode &node1 = %This.get(&startIndex);
   Local COMMON:util:entity:LinkedNode &node2 = %This.get(&endIndex);
   %This.firstNode = &node1;
   %This.lastNode = &node2;
   %This.firstNode.previousNode = Null;
   %This.lastNode.nextNode = Null;
   %This.size = &endIndex - &startIndex + 1;
end-method;

method reverse
   /* Local COMMON:util:entity:LinkedNode &node1 = %This.firstNode;
   %This.firstNode = %This.lastNode;
   %This.lastNode = &node1;
   Local integer &i;
   Local COMMON:util:entity:LinkedNode &node2 = &node1.nextNode;
   Local COMMON:util:entity:LinkedNode &node3;
   For &i = 1 To %This.size
      If &node2 = Null Then
         Break;
      End-If;
      &node3 = &node2.nextNode;
      &node2.nextNode = &node1;
      &node1.previousNode = &node2;
      &node1 = &node2;
      &node2 = &node3;
   End-For;
   %This.firstNode.previousNode = Null;
   %This.lastNode.nextNode = Null; */
   Local COMMON:util:entity:LinkedNode &nodeLeft = %This.firstNode;
   Local COMMON:util:entity:LinkedNode &nodeRight = %This.lastNode;
   Local integer &i = 1;
   Local any &any;
   While True
      If &i * 2 > %This.size Then
         Return;
      End-If;
      &any = &nodeLeft.anyProperty;
      &nodeLeft.anyProperty = &nodeRight.anyProperty;
      &nodeRight.anyProperty = &any;
      &nodeLeft = &nodeLeft.nextNode;
      &nodeRight = &nodeRight.previousNode;
      &i = &i + 1;
   End-While;
end-method;

method exchange
   /+ &index1 as Integer, +/
   /+ &index2 as Integer +/
   Local COMMON:util:entity:LinkedNode &node1 = %This.get(&index1);
   Local COMMON:util:entity:LinkedNode &node2 = %This.get(&index2);
   Local any &any = &node1.anyProperty;
   &node1.anyProperty = &node2.anyProperty;
   &node2.anyProperty = &any;
end-method;

method remove
   /+ &index as Integer +/
   If &index = 1 Then
      %This.removeFirst();
      Return;
   Else
      If &index = %This.size Then
         %This.removeLast();
         Return;
      End-If;
   End-If;
   Local COMMON:util:entity:LinkedNode &node = %This.get(&index);
   &node.previousNode.nextNode = &node.nextNode;
   &node.nextNode.previousNode = &node.previousNode;
   %This.size = %This.size - 1;
end-method;

method removeFirst
   If %This.size < 2 Then
      %This.firstNode = Null;
      %This.lastNode = Null;
      %This.size = 0;
   Else
      %This.firstNode = %This.firstNode.nextNode;
      %This.firstNode.previousNode = Null;
      %This.size = %This.size - 1;
   End-If;
end-method;

method removeLast
   If %This.size < 2 Then
      %This.firstNode = Null;
      %This.lastNode = Null;
      %This.size = 0;
   Else
      %This.lastNode = %This.lastNode.previousNode;
      %This.lastNode.nextNode = Null;
      %This.size = %This.size - 1;
   End-If;
end-method;

method getSize
   /+ Returns Integer +/
   Return %This.size;
end-method;

method initializePointerToFirst
   %This.pointer = %This.firstNode;
end-method;

method initializePointerToLast
   %This.pointer = %This.lastNode;
end-method;

method initializePointerToIndex
   /+ &index as Integer +/
   %This.pointer = %This.getNode(&index);
end-method;

method hasNext
   /+ Returns Boolean +/
   Return (%This.pointer <> Null);
end-method;

method next
   /+ Returns COMMON:util:entity:LinkedNode +/
   Local COMMON:util:entity:LinkedNode &nd = %This.pointer;
   %This.pointer = %This.pointer.nextNode;
   Return &nd.anyProperty ;
end-method;

method hasPrevious
   /+ Returns Boolean +/
   Return (%This.pointer <> Null);
end-method;

method previous
   /+ Returns COMMON:util:entity:LinkedNode +/
   Local COMMON:util:entity:LinkedNode &nd = %This.pointer;
   %This.pointer = %This.pointer.previousNode;
   Return &nd.anyProperty ;
end-method;

LinkedNode类：

/* 此类是一个链表集合节点实体类 */

class LinkedNode
   /* 上一个节点 */
   property GT_COMMON:UTIL:entity:LinkedNode previousNode;
   /* 下一个节点 */
   property GT_COMMON:UTIL:entity:LinkedNode nextNode;
   
   /* 存放节点信息 */
   property any anyProperty;
   
   method LinkedNode(&property As any);
end-class;

method LinkedNode
   /+ &property as Any +/
   %This.anyProperty = &property;
end-method;

qq_28371343
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Peoplesoft Peoplecode介绍
05-07
介绍Peoplecode基本变量类型，基本属性，代码书写规范，常用语法，触发顺序等。
peoplecode:PeopleCode示例和模板
04-10
虽然PeopleCode主要在服务器端运行，但与JavaScript的配合可以在客户端实现更丰富的用户交互。例如，JavaScript可以用于前端的表单验证，而PeopleCode在后台处理验证结果并执行相应的业务逻辑。这种前后端协作提升了...
PeopleCode中文API
01-20
其中，classname是要定义的接口类名，Extends和Implements是可选的关键字，用于继承或实现其他接口或类。Method_declarations是方法声明，Property_declarations是属性声明，Protected是保护区域，Instance_...
PeopleCodeParser:使用ANTLR4构建的PeopleCode解析器
03-30
使用ANTLR4构建的PeopleCode解析器关于该项目为所有类型的程序（事件PeopleCode和应用程序类）提供了PeopleCode解析器的实现。 它最初是基于PeopleTools 8.56的，但是语法中没有单独引用内置功能（最容易在...
peoplecode书籍
11-04
### PeopleCode书籍知识点详解 #### 一、书籍概述 《PeopleCode书籍》是一部关于Peoplesoft开发技术的专业书籍，主要面向Peoplesoft平台的开发者和技术人员。本书详细介绍了Peoplesoft的核心开发语言——...
去去去去去去去去去前期前期前期
08-12
去去去去去去去去去前期前期前期前期前期前期
计组P1 单周期MIPS处理器
08-12
实验报告+项目 Verilog语言
Spring Boot原创歌曲分享平台.zip
08-12
该平台严格按照需求分析制作相关模块，并利用所学知识尽力完成，但是本人由于学识浅薄，无法真正做到让该程序可以投入市场使用，仅仅简单实现部分功能，希望日后还能改善。 本平台具有以下优点： 该平台具有较高的适用性，选用B/S结构，可以在绝大部分个人平台上使用该平台。 平台将用户权限进行划分，管理员和用户都能看到及操作的信息不一样，两者具备不同的操作权限。 该平台操作界面简单明了，大部分人都可以正常使用。 但也存在以下问题需要改进： 运行时窗口不能被刷新，可以改进。 平台过于简单，显示的信息有限。 不能添加多个管理员账号，如果可以则将利于发展原创歌曲分享规模，便于原创歌曲分享信息集中管理。 不能实时预约接待消息，容易被忽视，不利于管理员服务用户。
100天拿下Python - Day 16-20（附源码）
08-12
Python语言进阶 1.数据结构和算法 2.函数的使用方式 3.面向对象相关知识 4.迭代器和生成器 5.并发编程 文件类型：markdown文档
中国对世界各国商品贸易进出口数据2000-2022年.xlsx
08-12
特点：今年全新，手工精心整理，放心引用，数据来自权威，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理 ## 数据指标说明 海关统计显示，2022年我国货物贸易进出口总值42.07万亿元，比2021年增长7.7%。其中，出口23.97万亿元，增长10.5%；进口18.1万亿元，增长4.3%。分季度看，一、二季度进出口总值分别超过9万亿元和10万亿元，三季度进出口总值增长至11.3万亿元，四季度进出口总值继续保持11万亿元的水平。从贸易方式看，一般贸易增长快、比重升。2022年，我国一般贸易进出口26.81万亿元，增长11.5%，占进出口总值的63.7%，较上年提升2.2个百分点。 进出口研究是目前经济管理类研究的热点问题，本数据可以研究中国对各国的多年进出口数据变化及趋势。 数据名称：中国对225个国家地区进出口面板数据 数据年份：2000-2022年 数据格式：EXCEL数据 数据来源：UN Comtra
集成电路设计的现状与未来.ppt
最新发布
08-12
集成电路设计的现状与未来.ppt集成电路设计的现状与未来.ppt集成电路设计的现状与未来.ppt集成电路设计的现状与未来.ppt集成电路设计的现状与未来.ppt集成电路设计的现状与未来.ppt
玻璃式集装箱活动房模型3D图纸 Solidworks设计.zip
08-12
玻璃式集装箱活动房模型3D图纸 Solidworks设计.zip
基于javaScript开发的鼠标移动阴影效果+源码+demo演示
08-12
基于javaScript开发的鼠标移动阴影效果+源码+demo演示 基于javaScript开发的鼠标移动阴影效果+源码+demo演示 基于javaScript开发的鼠标移动阴影效果+源码+demo演示 基于javaScript开发的鼠标移动阴影效果+源码+demo演示 基于javaScript开发的鼠标移动阴影效果+源码+demo演示 基于javaScript开发的鼠标移动阴影效果+源码+demo演示 基于javaScript开发的鼠标移动阴影效果+源码+demo演示 基于javaScript开发的鼠标移动阴影效果+源码+demo演示
超越记忆：模型泛化能力的深度解析
08-12
机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习并做出决策或预测，而无需进行明确的编程。机器学习算法可以分析大量数据，识别模式和趋势，并根据这些模式做出预测或决策。它包括几种不同的方法，包括： 1. **监督学习**：算法从标记的训练数据中学习，以便对新的输入数据进行分类或预测。 2. **无监督学习**：算法尝试在没有标记的训练数据中找到模式或结构。 3. **半监督学习**：结合了监督学习和无监督学习的方法，使用少量标记数据和大量未标记数据。 4. **强化学习**：算法通过与环境交互来学习，目标是最大化某种累积奖励。 机器学习在许多领域都有应用，包括图像识别、自然语言处理、医疗诊断、股市分析、自动驾驶车辆等。随着技术的发展，机器学习正变得越来越重要，并在不断扩展其应用范围。
可图LoRA-TASK01
08-12
可图LoRA-TASK01
十字悬臂激光雕刻机.zip
08-12
激光雕刻源码，学习交流使用
Android UI与JS互操作创新策略.zip
08-12
Android UI与JS互操作创新策略资源概述 随着移动互联网技术的飞速发展，Android UI与JavaScript（JS）的互操作成为跨平台开发中的一项重要创新策略。这种策略通过WebView组件，将JS代码嵌入Android应用中，实现了Android平台与Web技术的无缝融合。这不仅降低了开发成本，提高了开发效率，还通过丰富的Web页面效果显著提升了用户体验。 在互操作实现上，Android提供了多种灵活的方法，如通过WebView的loadUrl()和evaluateJavascript()方法调用JS代码，以及通过addJavascriptInterface()等方式实现JS对Android代码的调用。这些方法使得Android UI与JS之间的交互更加直接和高效。 为了进一步优化这一策略，开发者可以采取模块化设计、组件化开发、代码复用和性能优化等逻辑构建策略。通过将这些策略融入开发流程，可以显著提升项目的可维护性和可扩展性，同时降低后期维护成本。 总之，Android UI与JS互操作的创新策略为跨平台开发带来了全新的可能性和优势。它不仅推动了技术的融合.
基于opencv实现photoshop算法图像旋转C++源码.7z
08-12
【测试环境】 vs2019 opencv==4.8.0 更多信息参考博文：https://blog.csdn.net/FL1623863129/article/details/141143018
Huawei CE9800-V200R023SPH150
08-12
Huawei CE9800_V200R023SPH150，里面包含补丁说明书和补丁安装指导书，该补丁支持哪些型号，支持哪些版本可以安装当前补丁，请参考补丁说明书和补丁安装指导书。
PeopleCode入门与常用函数详解
通过学习这些函数和代码示例，初学者可以逐渐理解如何在PeopleCode中实现特定的业务逻辑，而进阶开发者则可以在此基础上进行更复杂的功能扩展和性能优化。对于每个函数和语句的理解，都需要结合PeopleSoft系统的具体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值