openharmony/js_util_module
1
0
Fork 0
mirror of https://github.com/openharmony/js_util_module.git synced 2026-07-19 10:17:53 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add the entire TS container class

Browse Source 
Adjust the code for the inconsistency between the linear nonlinear container and the interface description

Signed-off-by: shisan_forwork <chengjunxiong@huawei.com>
This commit is contained in:
shisan_forwork
2022-02-08 09:23:15 +00:00
parent 278ec6881c
commit 57eedbe87e
15 changed files with 686 additions and 624 deletions
Download Patch File Download Diff File Expand all files Collapse all files
container/arraylist/js_arraylist.ts
+43 -35
View File
@@ -35,7 +35,7 @@ if (flag || fastArrayList == undefined) {
return obj[prop];
}
set(obj: ArrayList<T>, prop: any, value: T) {
if (prop === "_length" || prop === "_capacity") {
if (prop === "elementNum" || prop === "capacity") {
obj[prop] = value;
return true;
}
@@ -95,33 +95,33 @@ if (flag || fastArrayList == undefined) {
};
}
class ArrayList<T> {
private _length: number = 0;
private _capacity: number = 10;
private elementNum: number = 0;
private capacity: number = 10;
constructor() {
return new Proxy(this, new HandlerArrayList());
}
get length() {
return this._length;
return this.elementNum;
}
add(element: T): boolean {
if (this.isFull()) {
this.resize();
}
this[this._length++] = element;
this[this.elementNum++] = element;
return true;
}
insert(element: T, index: number): void {
if (this.isFull()) {
this.resize();
}
for (let i = this._length; i > index; i--) {
for (let i = this.elementNum; i > index; i--) {
this[i] = this[i - 1];
}
this[index] = element;
this._length++;
this.elementNum++;
}
has(element: T): boolean {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
if (this[i] === element) {
return true;
}
@@ -129,32 +129,37 @@ if (flag || fastArrayList == undefined) {
return false;
}
getIndexOf(element: T): number {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
if (element === this[i]) {
return i;
}
}
return -1;
}
removeByIndex(index: number): void {
for (let i = index; i < this._length - 1; i++) {
removeByIndex(index: number): T {
if (index < 0 || index >= this.elementNum) {
throw new Error("removeByIndex is out-of-bounds");
}
let result = this[index];
for (let i = index; i < this.elementNum - 1; i++) {
this[i] = this[i + 1];
}
this._length--;
this.elementNum--;
return result;
}
remove(element: T): boolean {
if (this.has(element)) {
let index = this.getIndexOf(element);
for (let i = index; i < this._length - 1; i++) {
for (let i = index; i < this.elementNum - 1; i++) {
this[i] = this[i + 1];
}
this._length--;
this.elementNum--;
return true;
}
return false;
}
getLastIndexOf(element: T): number {
for (let i = this._length - 1; i >= 0; i--) {
for (let i = this.elementNum - 1; i >= 0; i--) {
if (element === this[i]) {
return i;
}
@@ -165,31 +170,31 @@ if (flag || fastArrayList == undefined) {
if (fromIndex >= toIndex) {
throw new Error(`fromIndex cannot be less than or equal to toIndex`);
}
toIndex = toIndex >= this._length - 1 ? this._length - 1 : toIndex;
toIndex = toIndex >= this.elementNum - 1 ? this.elementNum - 1 : toIndex;
let i = fromIndex;
for (let j = toIndex; j < this._length; j++) {
for (let j = toIndex; j < this.elementNum; j++) {
this[i] = this[j];
i++;
}
this._length -= toIndex - fromIndex;
this.elementNum -= toIndex - fromIndex;
}
replaceAllElements(callbackfn: (value: T, index?: number, arraylist?: ArrayList<T>) => T,
thisArg?: Object): void {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
this[i] = callbackfn.call(thisArg, this[i], i, this);
}
}
forEach(callbackfn: (value: T, index?: number, arraylist?: ArrayList<T>) => void,
thisArg?: Object): void {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
callbackfn.call(thisArg, this[i], i, this);
}
}
sort(comparator?: (firstValue: T, secondValue: T) => number): void {
let isSort = true;
if (comparator) {
for (let i = 0; i < this._length; i++) {
for (let j = 0; j < this._length - 1 - i; j++) {
for (let i = 0; i < this.elementNum; i++) {
for (let j = 0; j < this.elementNum - 1 - i; j++) {
if (comparator(this[j], this[j + 1]) > 0) {
isSort = false;
let temp = this[j];
@@ -200,7 +205,7 @@ if (flag || fastArrayList == undefined) {
}
} else {
for (var i = 0; i < this.length - 1; i++) {
for (let j = 0; j < this._length - 1 - i; j++) {
for (let j = 0; j < this.elementNum - 1 - i; j++) {
if (this.asciSort(this[j], this[j + 1])) {
isSort = false;
let temp = this[j];
@@ -232,7 +237,10 @@ if (flag || fastArrayList == undefined) {
if (fromIndex >= toIndex) {
throw new Error(`fromIndex cannot be less than or equal to toIndex`);
}
toIndex = toIndex >= this._length - 1 ? this._length - 1 : toIndex;
if (fromIndex >= this.elementNum || fromIndex < 0 || toIndex < 0) {
throw new Error(`fromIndex or toIndex is out-of-bounds`);
}
toIndex = toIndex > this.elementNum ? this.elementNum - 1 : toIndex;
let arraylist = new ArrayList<T>();
for (let i = fromIndex; i < toIndex; i++) {
arraylist.add(this[i]);
@@ -240,48 +248,48 @@ if (flag || fastArrayList == undefined) {
return arraylist;
}
clear(): void {
this._length = 0;
this.elementNum = 0;
}
clone(): ArrayList<T> {
let clone = new ArrayList<T>();
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
clone.add(this[i]);
}
return clone;
}
getCapacity(): number {
return this._capacity;
return this.capacity;
}
convertToArray(): Array<T> {
let arr = [];
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
arr[i] = this[i];
}
return arr;
}
private isFull(): boolean {
return this._length === this._capacity;
return this.elementNum === this.capacity;
}
private resize(): void {
this._capacity = 1.5 * this._capacity;
this.capacity = 1.5 * this.capacity;
}
isEmpty(): boolean {
return this._length == 0;
return this.elementNum == 0;
}
increaseCapacityTo(newCapacity: number): void {
if (newCapacity >= this._length) {
this._capacity = newCapacity;
if (newCapacity >= this.elementNum) {
this.capacity = newCapacity;
}
}
trimToCurrentLength(): void {
this._capacity = this._length;
this.capacity = this.elementNum;
}
[Symbol.iterator](): IterableIterator<T> {
let count = 0;
let arraylist = this;
return {
next: function () {
var done = count >= arraylist._length;
var done = count >= arraylist.elementNum;
var value = !done ? arraylist[count++] : undefined;
return {
done: done,
container/deque/js_deque.ts
+31 -31
View File
@@ -35,7 +35,7 @@ if (flag || fastDeque == undefined) {
return obj[prop];
}
set(obj: Deque<T>, prop: any, value: T): boolean {
if (prop === "_front" || prop === "_capacity" || prop === "_rear") {
if (prop === "front" || prop === "capacity" || prop === "rear") {
obj[prop] = value;
return true;
}
@@ -84,38 +84,38 @@ if (flag || fastDeque == undefined) {
};
}
class Deque<T> {
private _front: number;
private _capacity: number;
private _rear: number;
private front: number;
private capacity: number;
private rear: number;
constructor() {
this._front = 0;
this._capacity = 8;
this._rear = 0;
this.front = 0;
this.capacity = 8;
this.rear = 0;
return new Proxy(this, new HandlerDeque());
}
get length(){
let result = (this._rear - this._front + this._capacity) % this._capacity;
let result = (this.rear - this.front + this.capacity) % this.capacity;
return result;
}
insertFront(element: T): void {
if (this.isFull()) {
this.increaseCapacity();
}
this._front = (this._front - 1 + this._capacity) % this._capacity;
this[this._front] = element;
this.front = (this.front - 1 + this.capacity) % this.capacity;
this[this.front] = element;
}
insertEnd(element: T): void {
if (this.isFull()) {
this.increaseCapacity();
}
this[this._rear] = element;
this._rear = (this._rear + 1) % (this._capacity + 1);
this[this.rear] = element;
this.rear = (this.rear + 1) % (this.capacity + 1);
}
getFirst(): T {
return this[this._front];
return this[this.front];
}
getLast(): T {
return this[this._rear - 1];
return this[this.rear - 1];
}
has(element: T): boolean {
let result = false;
@@ -127,24 +127,24 @@ if (flag || fastDeque == undefined) {
return result;
}
popFirst(): T {
let result = this[this._front];
this._front = (this._front + 1) % (this._capacity + 1);
let result = this[this.front];
this.front = (this.front + 1) % (this.capacity + 1);
return result;
}
popLast(): T {
let result = this[this._rear - 1];
this._rear = (this._rear + this._capacity) % (this._capacity + 1);
let result = this[this.rear - 1];
this.rear = (this.rear + this.capacity) % (this.capacity + 1);
return result;
}
forEach(callbackfn: (value: T, index?: number, deque?: Deque<T>) => void,
thisArg?: Object): void {
let k = 0;
let i = this._front;
let i = this.front;
while (true) {
callbackfn.call(thisArg, this[i], k, this);
i = (i + 1) % this._capacity;
i = (i + 1) % this.capacity;
k++;
if (i === this._rear) {
if (i === this.rear) {
break;
}
}
@@ -154,30 +154,30 @@ if (flag || fastDeque == undefined) {
let arr = [];
let length = this.length;
while (true) {
arr[count++] = this[this._front];
this._front = (this._front + 1) % this._capacity;
if (this._front === this._rear) {
arr[count++] = this[this.front];
this.front = (this.front + 1) % this.capacity;
if (this.front === this.rear) {
break;
}
}
for (let i = 0; i < length; i++) {
this[i] = arr[i];
}
this._capacity = 2 * this._capacity;
this._front = 0;
this._rear = length;
this.capacity = 2 * this.capacity;
this.front = 0;
this.rear = length;
}
private isFull(): boolean {
return (this._rear + 1) % this._capacity === this._front;
return (this.rear + 1) % this.capacity === this.front;
}
[Symbol.iterator](): IterableIterator<T> {
let deque = this;
let count = deque._front;
let count = deque.front;
return {
next: function () {
var done = count == deque._rear;
var done = count == deque.rear;
var value = !done ? deque[count] : undefined;
count = (count + 1) % deque._capacity;
count = (count + 1) % deque.capacity;
return {
done: done,
value: value,
container/hashmap/js_hashmap.ts
+12 -11
View File
@@ -67,15 +67,12 @@ if (flag || fastHashMap === undefined) {
return super.Values().indexOf(value) > -1;
}
get(key: K): V {
let result = super.getValueByKey(key);
if (result === undefined)
throw new Error("this hashmap don't find the key");
return result;
return this.getValueByKey(key);
}
setAll(map: HashMap<K, V>): void {
let memebers = this.keyValueArray;
let memebers = map.keyValueArray;
for (let i = 0; i < memebers.length; i++) {
map.put(memebers[i].key, memebers[i].value);
this.put(memebers[i].key, memebers[i].value);
}
}
set(key: K, value: V): Object {
@@ -83,7 +80,7 @@ if (flag || fastHashMap === undefined) {
}
remove(key: K): V {
let result = this.removeMember(key);
if (result === null) {
if (result === undefined) {
throw new Error("The removed element does not exist in this container");
}
return result;
@@ -97,7 +94,8 @@ if (flag || fastHashMap === undefined) {
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].key : undefined;
var value = !done ? data.keyValueArray[count].key : undefined;
count++;
return {
done: done,
value: value,
@@ -111,7 +109,8 @@ if (flag || fastHashMap === undefined) {
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].value : undefined;
var value = !done ? data.keyValueArray[count].value : undefined;
count++;
return {
done: done,
value: value,
@@ -135,7 +134,8 @@ if (flag || fastHashMap === undefined) {
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].entry() : undefined;
var value = !done ? data.keyValueArray[count].entry() : undefined;
count++;
return {
done: done,
value: value,
@@ -149,7 +149,8 @@ if (flag || fastHashMap === undefined) {
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].entry() : undefined;
var value = !done ? data.keyValueArray[count].entry() : undefined;
count++;
return {
done: done,
value: value,
container/hashset/js_hashset.ts
+8 -5
View File
@@ -62,14 +62,14 @@ if (flag || fastHashSet === undefined) {
return this.memberNumber === 0;
}
has(value: T): boolean {
return super.hasKey(value);
return this.hasKey(value);
}
add(value: T): boolean {
if (this.has(value)) return false;
return this.put(value);
}
remove(value: T): boolean {
if (this.removeMember(value) !== null) return true;
if (this.removeMember(value) !== undefined) return true;
return false;
}
clear(): void {
@@ -88,7 +88,8 @@ if (flag || fastHashSet === undefined) {
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].key : undefined;
var value = !done ? data.keyValueArray[count].key : undefined;
count++;
return {
done: done,
value: value,
@@ -102,7 +103,8 @@ if (flag || fastHashSet === undefined) {
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].entry() : undefined;
var value = !done ? data.keyValueArray[count].entry() : undefined;
count++;
return {
done: done,
value: value,
@@ -116,7 +118,8 @@ if (flag || fastHashSet === undefined) {
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].key : undefined;
var value = !done ? data.keyValueArray[count].key : undefined;
count++;
return {
done: done,
value: value,
container/lightweightmap/js_lightweightmap.ts
+9 -10
View File
@@ -59,8 +59,7 @@ if (flag || fastLightWeightMap === undefined) {
}
hasAll(map: LightWeightMap<K, V>): boolean {
if (map.memberNumber > this.memberNumber) return false;
if (LightWeightAbility.isIncludeToArray(this.members.keys, map.members.keys) &&
LightWeightAbility.isIncludeToArray(this.members.values, map.members.values)) {
if (LightWeightAbility.isIncludeToArray(this.keyValueStringArray(), map.keyValueStringArray()) ) {
return true;
}
return false;
@@ -121,14 +120,14 @@ if (flag || fastLightWeightMap === undefined) {
};
}
setAll(map: LightWeightMap<K, V>): void {
if (map.memberNumber === 0) {
map.members.hashs = this.members.hashs.slice();
map.members.keys = this.members.keys.slice();
map.members.values = this.members.values.slice();
map.memberNumber = this.memberNumber;
if (this.memberNumber === 0) {
this.members.hashs = map.members.hashs.slice();
this.members.keys = map.members.keys.slice();
this.members.values = map.members.values.slice();
this.memberNumber = map.memberNumber;
} else {
for (let i = 0; i < this.memberNumber; i++) {
map.addmember(this.members.keys[i], this.members.values[i]);
for (let i = 0; i < map.memberNumber; i++) {
this.addmember(map.members.keys[i], map.members.values[i]);
}
}
}
@@ -191,7 +190,7 @@ if (flag || fastLightWeightMap === undefined) {
return result.join(",");
}
getValueAt(index: number): V {
return this.members.values[index] as V;
return this.members.values[index];
}
values(): IterableIterator<V> {
let data = this;
container/lightweightset/js_lightweightset.ts
+6 -10
View File
@@ -65,17 +65,12 @@ if (flag || fastLightWeightSet === undefined) {
addAll(set: LightWeightSet<T>): boolean {
let change = false;
if (set.memberNumber == 0) {
set.memberNumber = this.memberNumber;
set.members.hashs = this.members.hashs.slice();
set.members.keys = this.members.keys.slice();
set.members.values = this.members.values.slice();
set.memberNumber = this.memberNumber;
change = true;
change = false;
} else {
for (let i = 0; i < this.memberNumber; i++) {
change = set.add(this.members.keys[i]) || change;
for (let i = 0; i < set.memberNumber; i++) {
change = this.add(set.members.keys[i]) || change;
}
}
}
return change;
}
hasAll(set: LightWeightSet<T>): boolean {
@@ -90,7 +85,7 @@ if (flag || fastLightWeightSet === undefined) {
}
equal(obj: Object): boolean {
if (this.memberNumber === 0) return false;
if (obj.toString() === this.members.keys.toString()) return true;
if (JSON.stringify(obj) === JSON.stringify(this.members.keys)) return true;
return false;
}
increaseCapacityTo(minimumCapacity: number): void {
@@ -136,6 +131,7 @@ if (flag || fastLightWeightSet === undefined) {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.members.keys[count] : undefined;
count++;
return {
done: done,
value: value,
container/linkedlist/js_linkedlist.ts
+80 -71
View File
@@ -32,26 +32,26 @@ if (flag || fastLinkedList == undefined) {
if (index < 0 || index >= length) {
throw new Error("LinkedList: get out-of-bounds");
}
return obj.get(index);
}
return obj[prop];
}
set(obj: LinkedList<T>, prop: any, value: any) {
if (prop === "_length" ||
prop === "_capacity" ||
prop === "_head" ||
if (prop === "elementNum" ||
prop === "capacity" ||
prop === "head" ||
prop == "next" ||
prop == "_tail" ) {
prop == "tail" ) {
obj[prop] = value;
return true;
}
var index = Number.parseInt(prop);
if (Number.isInteger(index)) {
let length = obj.length;
if (index < 0 || index >= length) {
throw new Error("LinkedList: set out-of-bounds");
} else {
obj[index] = value;
obj.set(index, value);
return true;
}
}
@@ -144,58 +144,58 @@ if (flag || fastLinkedList == undefined) {
}
}
class LinkedList<T> {
private _head?: any;
private _tail?: any;
private _length : number;
private _capacity: number;
constructor(_head?: NodeObj<T>, _tail?: NodeObj<T>) {
this._head = _head || null;
this._tail = _tail || null;
this._length = 0;
this._capacity = 10;
private head?: any;
private tail?: any;
private elementNum : number;
private capacity: number;
constructor(head?: NodeObj<T>, tail?: NodeObj<T>) {
this.head = head || null;
this.tail = tail || null;
this.elementNum = 0;
this.capacity = 10;
return new Proxy(this, new HandlerLinkedList());
}
get length() {
return this._length;
return this.elementNum;
}
private getNode(index: number): NodeObj<T> {
let current = this._head;
let current = this.head;
for (let i = 0; i < index; i++) {
current = current["next"];
}
return current;
}
get(index: number): T {
let current = this._head;
let current = this.head;
for (let i = 0; i < index; i++) {
current = current["next"];
}
return current.element;
}
add(element: T): boolean {
if (this._length === 0) {
let head = this._head;
let tail = this._tail;
this._head = this._tail = new NodeObj(element, head, tail);
if (this.elementNum === 0) {
let head = this.head;
let tail = this.tail;
this.head = this.tail = new NodeObj(element, head, tail);
} else {
let prevNode = this.getNode(this._length - 1);
prevNode.next = new NodeObj(element, prevNode["next"], this._tail);
let prevNode = this.getNode(this.elementNum - 1);
prevNode.next = new NodeObj(element, prevNode["next"], this.tail);
}
this._length++;
this.elementNum++;
return true;
}
addFirst(element: T): void {
if (!element) {
throw new Error("element cannot be null");
}
let node = new NodeObj(element, this._head, this._tail);
if (this._length === 0) {
this._head = this._tail = node;
let node = new NodeObj(element, this.head, this.tail);
if (this.elementNum === 0) {
this.head = this.tail = node;
} else {
node.next = this._head;
this._head = node;
node.next = this.head;
this.head = node;
}
this._length++;
this.elementNum++;
}
removeFirst(): T {
let result = this.getNode(0).element;
@@ -208,25 +208,25 @@ if (flag || fastLinkedList == undefined) {
return result;
}
popLast(): T {
let result = this.getNode(this._length - 1).element;
this.removeByIndex(this._length - 1);
let result = this.getNode(this.elementNum - 1).element;
this.removeByIndex(this.elementNum - 1);
return result;
}
removeLast(): T {
let result = this.getNode(this._length - 1).element;
this.removeByIndex(this._length - 1);
let result = this.getNode(this.elementNum - 1).element;
this.removeByIndex(this.elementNum - 1);
return result;
}
clear(): void {
this._head = null;
this._tail = null;
this._length = 0;
this.head = null;
this.tail = null;
this.elementNum = 0;
}
has(element: T): boolean {
if (this._head.element === element) {
if (this.head.element === element) {
return true;
}
const linkIterator = new LinkIterator<T>(this._head);
const linkIterator = new LinkIterator<T>(this.head);
while (linkIterator.hasNext()) {
const newNode = linkIterator.next();
if (newNode.element === element) {
@@ -236,7 +236,7 @@ if (flag || fastLinkedList == undefined) {
return false;
}
getIndexOf(element: T): number {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
const curNode = this.getNode(i);
if (curNode.element === element) {
return i;
@@ -245,7 +245,7 @@ if (flag || fastLinkedList == undefined) {
return -1;
}
getLastIndexOf(element: T): number {
for (let i = this._length - 1; i >= 0; i--) {
for (let i = this.elementNum - 1; i >= 0; i--) {
const curNode = this.getNode(i);
if (curNode.element === element) {
return i;
@@ -254,17 +254,20 @@ if (flag || fastLinkedList == undefined) {
return -1;
}
removeByIndex(index: number): T {
let current = this._head;
if (index < 0 || index >= this.elementNum) {
throw new Error("removeByIndex is out-of-bounds");
}
let current = this.head;
if (index === 0) {
this._head = current && current.next;
if (this._length == 1) {
this._head = this._tail = null;
this.head = current && current.next;
if (this.elementNum == 1) {
this.head = this.tail = null;
} else {
this._head.prev = null;
this.head.prev = null;
}
} else if (index == this._length - 1) {
} else if (index == this.elementNum - 1) {
current = this.getNode(index - 1);
this._tail = current;
this.tail = current;
current.next = null;
} else {
const prevNode = this.getNode(index - 1);
@@ -272,10 +275,13 @@ if (flag || fastLinkedList == undefined) {
prevNode.next = nextNode;
nextNode.prev = prevNode;
}
this._length--;
this.elementNum--;
return current && current.element;
}
remove(element: T): boolean {
if(this.isEmpty()){
return false;
}
if (this.has(element)) {
let index = this.getIndexOf(element);
this.removeByIndex(index);
@@ -307,22 +313,22 @@ if (flag || fastLinkedList == undefined) {
return element;
}
getLast(): T {
let newNode = this.getNode(this._length - 1);
let newNode = this.getNode(this.elementNum - 1);
let element = newNode.element;
return element;
}
insert(index: number, element: T): void {
if (index >= 0 && index < this._length) {
if (index >= 0 && index < this.elementNum) {
let newNode = new NodeObj(element);
let current = this._head;
let current = this.head;
if (index === 0) {
if (this._head === null) {
this._head = newNode;
this._tail = newNode;
if (this.head === null) {
this.head = newNode;
this.tail = newNode;
} else {
newNode.next = this._head;
this._head.prev = newNode;
this._head = newNode;
newNode.next = this.head;
this.head.prev = newNode;
this.head = newNode;
}
} else {
const prevNode = this.getNode(index - 1);
@@ -332,13 +338,13 @@ if (flag || fastLinkedList == undefined) {
current.prev = newNode;
newNode.prev = prevNode;
}
} else if (index === this._length) {
let prevNode = this.getNode(this._length - 1);
prevNode.next = new NodeObj(element, prevNode["next"], this._tail);
} else if (index === this.elementNum) {
let prevNode = this.getNode(this.elementNum - 1);
prevNode.next = new NodeObj(element, prevNode["next"], this.tail);
} else {
throw new Error("index cannot Less than 0 and more than this length");
}
this._length++;
this.elementNum++;
}
set(index: number, element: T): T {
const current = this.getNode(index);
@@ -348,11 +354,11 @@ if (flag || fastLinkedList == undefined) {
convertToArray(): Array<T> {
let arr: Array<T> = [];
let index = 0;
if (this._length <= 0) {
if (this.elementNum <= 0) {
return arr;
}
arr[index] = this._head.element;
const linkIterator = new LinkIterator<T>(this._head);
arr[index] = this.head.element;
const linkIterator = new LinkIterator<T>(this.head);
while (linkIterator.hasNext()) {
const newNode = linkIterator.next();
arr[++index] = newNode.element;
@@ -368,12 +374,15 @@ if (flag || fastLinkedList == undefined) {
}
return clone;
}
private isEmpty(): boolean {
return this.elementNum == 0;
}
forEach(callbackfn: (value: T,index?: number,linkedlist?: LinkedList<T>) => void,
thisArg?: Object): void {
let index = 0;
const linkIterator = new LinkIterator<T>(this._head);
if (this._length > 0) {
callbackfn.call(thisArg, this._head.element, index, this);
const linkIterator = new LinkIterator<T>(this.head);
if (this.elementNum > 0) {
callbackfn.call(thisArg, this.head.element, index, this);
}
while (linkIterator.hasNext()) {
const newNode = linkIterator.next();
@@ -382,10 +391,10 @@ if (flag || fastLinkedList == undefined) {
}
[Symbol.iterator](): IterableIterator<T> {
let count = 0;
let linkedlist = this
let linkedlist = this;
return {
next: function () {
var done = count >= linkedlist._length;
var done = count >= linkedlist.elementNum;
var value = !done ? linkedlist.getNode(count++).element : undefined;
return {
done: done,
container/list/js_list.ts
+60 -53
View File
@@ -31,14 +31,15 @@ if (flag || fastList == undefined) {
if (index < 0 || index >= obj.length) {
throw new Error("List: get out-of-bounds");
}
return obj.get(index);
}
return obj[prop];
}
set(obj: List<T>, prop: any, value: T) {
if (
prop === "_length" ||
prop === "_capacity" ||
prop === "_head" ||
prop === "elementNum" ||
prop === "capacity" ||
prop === "head" ||
prop == "next") {
obj[prop] = value;
return true;
@@ -48,7 +49,7 @@ if (flag || fastList == undefined) {
if (index < 0 || index >= obj.length) {
throw new Error("List: set out-of-bounds");
} else {
obj[index] = value;
obj.set(index, value);
return true;
}
}
@@ -129,52 +130,52 @@ if (flag || fastList == undefined) {
class List<T> {
/* If 'any' is changed to 'NodeObj<T> | null ' here, an error will be reported:
Object may be 'null' */
private _head: any;
private _length: number;
private _capacity: number;
constructor(_head?: NodeObj<T>) {
this._head = _head || null;
this._length = 0;
this._capacity = 10;
private head: any;
private elementNum: number;
private capacity: number;
constructor(head?: NodeObj<T>) {
this.head = head || null;
this.elementNum = 0;
this.capacity = 10;
return new Proxy(this, new HandlerList());
}
get length() {
return this._length;
return this.elementNum;
}
private getNode(index: number): NodeObj<T> {
let current = this._head;
let current = this.head;
for (let i = 0; i < index; i++) {
current = current["next"];
}
return current;
}
get(index: number): T {
let current = this._head;
let current = this.head;
for (let i = 0; i < index; i++) {
current = current["next"];
}
return current.element;
}
add(element: T): boolean {
if (this._length === 0) {
let head = this._head;
this._head = new NodeObj(element, head);
if (this.elementNum === 0) {
let head = this.head;
this.head = new NodeObj(element, head);
} else {
let prevNode = this.getNode(this._length - 1);
let prevNode = this.getNode(this.elementNum - 1);
prevNode.next = new NodeObj(element, prevNode["next"]);
}
this._length++;
this.elementNum++;
return true;
}
clear(): void {
this._head = null;
this._length = 0;
this.head = null;
this.elementNum = 0;
}
has(element: T): boolean {
if (this._head.element === element) {
if (this.head.element === element) {
return true;
}
const linkIterator = new LinkIterator<T>(this._head);
const linkIterator = new LinkIterator<T>(this.head);
while (linkIterator.hasNext()) {
const newNode = linkIterator.next();
if (newNode.element === element) {
@@ -190,8 +191,8 @@ if (flag || fastList == undefined) {
if (!(obj instanceof List)) {
return false;
} else {
let e1 = new LinkIterator<T>(this._head);
let e2 = new LinkIterator<T>(obj._head);
let e1 = new LinkIterator<T>(this.head);
let e2 = new LinkIterator<T>(obj.head);
while (e1.hasNext() && e2.hasNext()) {
const newNode1 = e1.next();
const newNode2 = e2.next();
@@ -204,7 +205,7 @@ if (flag || fastList == undefined) {
return true;
}
getIndexOf(element: T): number {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
const curNode = this.getNode(i);
if (curNode.element === element) {
return i;
@@ -213,7 +214,7 @@ if (flag || fastList == undefined) {
return -1;
}
getLastIndexOf(element: T): number {
for (let i = this._length - 1; i >= 0; i--) {
for (let i = this.elementNum - 1; i >= 0; i--) {
const curNode = this.getNode(i);
if (curNode.element === element) {
return i;
@@ -222,16 +223,19 @@ if (flag || fastList == undefined) {
return -1;
}
removeByIndex(index: number): T {
let oldNode = this._head;
if (index < 0 || index >= this.elementNum) {
throw new Error("removeByIndex is out-of-bounds");
}
let oldNode = this.head;
if (index === 0) {
oldNode = this._head;
this._head = oldNode && oldNode.next;
oldNode = this.head;
this.head = oldNode && oldNode.next;
} else {
let prevNode = this.getNode(index - 1);
oldNode = prevNode.next;
prevNode.next = oldNode.next;
}
this._length--;
this.elementNum--;
return oldNode && oldNode.element;
}
remove(element: T): boolean {
@@ -245,10 +249,10 @@ if (flag || fastList == undefined) {
replaceAllElements(callbackfn: (value: T, index?: number, list?: List<T>) => T,
thisArg?: Object): void {
let index = 0;
const linkIterator = new LinkIterator<T>(this._head);
if (this._length > 0) {
const linkIterator = new LinkIterator<T>(this._head);
this.getNode(index).element = callbackfn.call(thisArg, this._head.element, index, this);
const linkIterator = new LinkIterator<T>(this.head);
if (this.elementNum > 0) {
const linkIterator = new LinkIterator<T>(this.head);
this.getNode(index).element = callbackfn.call(thisArg, this.head.element, index, this);
}
while (linkIterator.hasNext()) {
const newNode = linkIterator.next();
@@ -261,23 +265,23 @@ if (flag || fastList == undefined) {
return element;
}
getLast(): T {
let newNode = this.getNode(this._length - 1);
let newNode = this.getNode(this.elementNum - 1);
let element = newNode.element;
return element;
}
insert(element: T, index: number): void {
let newNode = new NodeObj(element);
if (index >= 0 && index < this._length) {
if (index >= 0 && index < this.elementNum) {
if (index === 0) {
const current = this._head;
const current = this.head;
newNode.next = current;
this._head = newNode;
this.head = newNode;
} else {
const prevNode = this.getNode(index - 1);
newNode.next = prevNode.next;
prevNode.next = newNode;
}
this._length++;
this.elementNum++;
}
}
set(index: number, element: T): T {
@@ -287,8 +291,8 @@ if (flag || fastList == undefined) {
}
sort(comparator: (firstValue: T, secondValue: T) => number): void {
let isSort = true;
for (let i = 0; i < this._length; i++) {
for (let j = 0; j < this._length - 1 - i; j++) {
for (let i = 0; i < this.elementNum; i++) {
for (let j = 0; j < this.elementNum - 1 - i; j++) {
if (comparator(this.getNode(j).element, this.getNode(j + 1).element) > 0) {
isSort = false;
let temp = this.getNode(j).element;
@@ -305,7 +309,10 @@ if (flag || fastList == undefined) {
if (toIndex <= fromIndex) {
throw new Error("toIndex cannot be less than or equal to fromIndex");
}
toIndex = toIndex > this._length ? this._length - 1 : toIndex;
if (fromIndex >= this.elementNum || fromIndex < 0 || toIndex < 0) {
throw new Error(`fromIndex or toIndex is out-of-bounds`);
}
toIndex = toIndex > this.elementNum ? this.elementNum - 1 : toIndex;
let list = new List<T>();
for (let i = fromIndex; i < toIndex; i++) {
let element = this.getNode(i).element;
@@ -319,11 +326,11 @@ if (flag || fastList == undefined) {
convertToArray(): Array<T> {
let arr: Array<T> = [];
let index = 0;
if (this._length <= 0) {
if (this.elementNum <= 0) {
return arr;
}
arr[index] = this._head.element;
const linkIterator = new LinkIterator<T>(this._head);
arr[index] = this.head.element;
const linkIterator = new LinkIterator<T>(this.head);
while (linkIterator.hasNext()) {
const newNode = linkIterator.next();
arr[++index] = newNode.element;
@@ -331,15 +338,15 @@ if (flag || fastList == undefined) {
return arr;
}
isEmpty(): boolean {
return this._length == 0;
return this.elementNum == 0;
}
forEach(callbackfn: (value: T, index?: number, list?: List<T>) => void,
thisArg?: Object): void {
let index = 0;
const linkIterator = new LinkIterator<T>(this._head);
if (this._length > 0) {
const linkIterator = new LinkIterator<T>(this._head);
callbackfn.call(thisArg, this._head.element, index, this);
const linkIterator = new LinkIterator<T>(this.head);
if (this.elementNum > 0) {
const linkIterator = new LinkIterator<T>(this.head);
callbackfn.call(thisArg, this.head.element, index, this);
}
while (linkIterator.hasNext()) {
const newNode = linkIterator.next();
@@ -348,10 +355,10 @@ if (flag || fastList == undefined) {
}
[Symbol.iterator](): IterableIterator<T> {
let count = 0;
let list = this
let list = this;
return {
next: function () {
var done = count >= list._length;
var done = count >= list.elementNum;
var value = !done ? list.getNode(count++).element : undefined;
return {
done: done,
container/plainarray/js_plainarray.ts
+2 -3
View File
@@ -82,7 +82,6 @@ if (flag || fastPlainArray === undefined) {
}
get(key: number): T {
let index = this.binarySearchAtPlain(key);
if (index < 0) throw new Error("Key error found");
return this.members.values[index];
}
getIndexOfKey(key: number): number {
@@ -100,7 +99,7 @@ if (flag || fastPlainArray === undefined) {
}
remove(key: number): T {
let index = this.binarySearchAtPlain(key);
if (index < 0) throw new Error(" element not in this plainarray");
if (index < 0) throw new Error("element not in this plainarray");
return this.deletemember(index);
}
removeAt(index: number): T {
@@ -109,7 +108,7 @@ if (flag || fastPlainArray === undefined) {
}
removeRangeFrom(index: number, size: number): number {
if (index >= this.memberNumber || index < 0) throw new Error("index not in this plainarray range");
let safeSize = (this.memberNumber - (index + size) < 0) ? this.memberNumber - size : size;
let safeSize = (this.memberNumber - (index + size) < 0) ? this.memberNumber - index : size;
this.deletemember(index, safeSize);
return safeSize;
}
container/queue/js_queue.ts
+21 -21
View File
@@ -35,7 +35,7 @@ if (flag || fastQueue == undefined) {
return obj[prop];
}
set(obj: Queue<T>, prop: any, value: T): boolean {
if (prop === "_front" || prop === "_capacity" || prop === "_rear") {
if (prop === "front" || prop === "capacity" || prop === "rear") {
obj[prop] = value;
return true;
}
@@ -81,58 +81,58 @@ if (flag || fastQueue == undefined) {
};
}
class Queue<T> {
private _front: number;
private _capacity: number;
private _rear: number;
private front: number;
private capacity: number;
private rear: number;
constructor() {
this._front = 0;
this._capacity = 8;
this._rear = 0;
this.front = 0;
this.capacity = 8;
this.rear = 0;
return new Proxy(this, new HandlerQueue());
}
get length(){
return this._rear - this._front;
return this.rear - this.front;
}
add(element: T): boolean {
if (this.isFull()) {
this.increaseCapacity();
}
this[this._rear] = element;
this._rear = (this._rear + 1) % (this._capacity + 1);
this[this.rear] = element;
this.rear = (this.rear + 1) % (this.capacity + 1);
return true;
}
getFirst(): T {
return this[this._front];
return this[this.front];
}
pop(): T {
let result = this[this._front];
this._front = (this._front + 1) % (this._capacity + 1);
let result = this[this.front];
this.front = (this.front + 1) % (this.capacity + 1);
return result;
}
forEach(callbackfn: (value: T, index?: number, queue?: Queue<T>) => void,
thisArg?: Object): void {
let k = 0;
let i = this._front;
let i = this.front;
while (true) {
callbackfn.call(thisArg,this[i], k,this);
i = (i + 1) % this._capacity;
i = (i + 1) % this.capacity;
k++;
if (i === this._rear) {
if (i === this.rear) {
break;
}
}
}
private isFull(): boolean {
return this.length === this._capacity;
return this.length === this.capacity;
}
[Symbol.iterator](): IterableIterator<T> {
let count = this._front;
let count = this.front;
let queue = this;
return {
next: function () {
var done = count == queue._rear;
var done = count == queue.rear;
var value = !done ? queue[count] : undefined;
count = (count + 1) % queue._capacity;
count = (count + 1) % queue.capacity;
return {
done: done,
value: value,
@@ -141,7 +141,7 @@ if (flag || fastQueue == undefined) {
};
}
private increaseCapacity(): void {
this._capacity = 2 * this._capacity;
this.capacity = 2 * this.capacity;
}
}
Object.freeze(Queue);
container/stack/js_stack.ts
+10 -10
View File
@@ -36,7 +36,7 @@ if (flag || fastStack == undefined) {
return obj[prop];
}
set(obj: Stack<T>, prop: any, value: T) {
if (prop === "_length" || prop === "_capacity") {
if (prop === "elementNum" || prop === "capacity") {
obj[prop] = value;
return true;
}
@@ -85,24 +85,24 @@ if (flag || fastStack == undefined) {
};
}
class Stack<T> {
private _length: number = 0;
private _capacity: number = 10;
private elementNum: number = 0;
private capacity: number = 10;
constructor() {
return new Proxy(this, new HandlerStack());
}
get length() {
return this._length;
return this.elementNum;
}
push(item: T): T {
if (this.isFull()) {
this.increaseCapacity();
}
this[this._length++] = item;
this[this.elementNum++] = item;
return item;
}
pop(): T {
let result = this[this.length - 1];
this._length--;
this.elementNum--;
return result;
}
peek(): T {
@@ -117,7 +117,7 @@ if (flag || fastStack == undefined) {
return -1;
}
isEmpty(): boolean {
return this._length == 0;
return this.elementNum == 0;
}
forEach(callbackfn: (value: T, index?: number, stack?: Stack<T>) => void,
thisArg?: Object): void {
@@ -126,17 +126,17 @@ if (flag || fastStack == undefined) {
}
}
private isFull(): boolean {
return this._length === this._capacity;
return this.elementNum === this.capacity;
}
private increaseCapacity(): void {
this._capacity = 1.5 * this._capacity;
this.capacity = 1.5 * this.capacity;
}
[Symbol.iterator](): IterableIterator<T> {
let count = 0;
let stack = this;
return {
next: function () {
var done = count >= stack._length;
var done = count >= stack.elementNum;
var value = !done ? stack[count++] : undefined;
return {
done: done,
container/struct/js_struct.ts
+263 -235
View File
@@ -58,6 +58,9 @@ function compareToString(string1: String, string2: String) {
function currencyCompare(a: any, b: any, compareFn?: Function): number {
if (a === b) return ComparResult.EQUALS;
if (a instanceof Pair && b instanceof Pair) {
return currencyCompare(a.key, b.key, compareFn);
}
if (compareFn != undefined) {
return compareFn(a, b) ? ComparResult.BIGGER_THAN : ComparResult.LESS_THAN;
}
@@ -73,8 +76,6 @@ function currencyCompare(a: any, b: any, compareFn?: Function): number {
return ComparResult.BIGGER_THAN;
} else if (typeof a === "number" && typeof b === "string") {
return ComparResult.LESS_THAN;
} else if (a instanceof Pair && b instanceof Pair) {
return currencyCompare(a.key, b.key);
}
throw new Error("This form of comparison is not supported");
}
@@ -122,7 +123,7 @@ class PlainArrayClass<T> {
protected addmember(key: number, value: T) {
let index = this.binarySearchAtPlain(key);
if (index > 0) {
if (index >= 0) {
this.members.keys[index] = key;
this.members.values[index] = value;
} else {
@@ -181,7 +182,7 @@ class LightWeightClass<K, V> {
protected addmember(key: K, value: V = key as unknown as V) {
let hash = hashCode(key);
let index = this.binarySearchAtLightWeight(hash);
if (index > 0) {
if (index >= 0) {
this.members.keys[index] = key;
this.members.values[index] = value;
} else {
@@ -225,10 +226,10 @@ class LightWeightClass<K, V> {
return index;
}
protected keyArray(): Array<K> {
let resultArray: Array<K> = [];
protected keyValueStringArray(): Array<string> {
let resultArray: Array<string> = [];
for (let i = 0; i < this.memberNumber; i++) {
resultArray.push(this.members[i].key);
resultArray.push(JSON.stringify(this.members.keys[i]) + ":" + JSON.stringify(this.members.values[i]));
}
return resultArray;
}
@@ -252,20 +253,20 @@ class LightWeightClass<K, V> {
}
}
type RBTreeNodeColor = "black" | "red";
const BLACK = "black";
const RED = "red";
type RBTreeNodeColor = 0 | 1;
const BLACK = 0;
const RED = 1;
class RBTreeNode<K, V> extends Pair<K, V>{
color: RBTreeNodeColor;
left: RBTreeNode<K, V> | null;
right: RBTreeNode<K, V> | null;
parent: RBTreeNode<K, V> | null;
left: RBTreeNode<K, V> | undefined;
right: RBTreeNode<K, V> | undefined;
parent: RBTreeNode<K, V> | undefined;
constructor(key: K,
value?: V,
color: RBTreeNodeColor = RED,
parent: RBTreeNode<K, V> | null = null,
left: RBTreeNode<K, V> | null = null,
right: RBTreeNode<K, V> | null = null) {
parent?: RBTreeNode<K, V>,
left?: RBTreeNode<K, V>,
right?: RBTreeNode<K, V>) {
super(key, value);
this.color = color;
this.left = left;
@@ -274,15 +275,17 @@ class RBTreeNode<K, V> extends Pair<K, V>{
}
}
class RBTreeClass<K, V> {
private _root: RBTreeNode<K, V> | null;
private root: RBTreeNode<K, V> | undefined;
public memberNumber: number;
private _isChange: boolean;
private _treeArray: Array<RBTreeNode<K, V>>;
constructor(root: RBTreeNode<K, V> | null = null) {
this._root = root;
private isChange: boolean;
private treeNodeArray: Array<RBTreeNode<K, V>>;
private compFun: Function | undefined;
constructor(comparator?: (firstValue: K, secondValue: K) => boolean, root?: RBTreeNode<K, V>) {
this.root = root;
this.compFun = comparator;
this.memberNumber = 0;
this._isChange = true;
this._treeArray = [];
this.isChange = true;
this.treeNodeArray = [];
}
get keyValueArray() {
@@ -291,11 +294,11 @@ class RBTreeClass<K, V> {
}
addNode(key: K, value: V = key as unknown as V): RBTreeClass<K, V> {
if (this._root === null) {
this._root = new RBTreeNode<K, V>(key, value)
this.setColor(this._root, BLACK);
if (this.root === undefined) {
this.root = new RBTreeNode<K, V>(key, value);
this.setColor(BLACK, this.root);
this.memberNumber++;
this._isChange = true;
this.isChange = true;
} else {
this.addProcess(key, value)
}
@@ -303,12 +306,12 @@ class RBTreeClass<K, V> {
}
addProcess(key: K, value: V): RBTreeClass<K, V> {
let leafNode: RBTreeNode<K, V> | null = this._root;
let parentNode: RBTreeNode<K, V> = this._root as RBTreeNode<K, V>;
let leafNode: RBTreeNode<K, V> | undefined = this.root;
let parentNode: RBTreeNode<K, V> = this.root as RBTreeNode<K, V>;
let comp: number = 0;
while (leafNode !== null) {
while (leafNode !== undefined) {
parentNode = leafNode;
comp = currencyCompare(leafNode.key, key);
comp = currencyCompare(leafNode.key, key, this.compFun);
if (comp === 0) {
leafNode.value = value;
return this;
@@ -327,14 +330,14 @@ class RBTreeClass<K, V> {
}
this.insertRebalance(leafNode);
this.memberNumber++;
this._isChange = true;
this.isChange = true;
return this;
}
removeNode(key: K): V | null {
removeNode(key: K): V | undefined {
const removeNode = this.getNode(key);
if (removeNode === null) {
return null;
if (removeNode === undefined) {
return undefined;
} else {
let result = removeNode.value;
this.removeNodeProcess(removeNode);
@@ -343,126 +346,138 @@ class RBTreeClass<K, V> {
}
removeNodeProcess(removeNode: RBTreeNode<K, V>) {
if (removeNode.left !== null && removeNode.right !== null) {
if (removeNode.left !== undefined && removeNode.right !== undefined) {
let successor = removeNode.right;
while (successor.left !== null) {
while (successor.left !== undefined) {
successor = successor.left;
}
removeNode = successor;
removeNode.key = successor.key;
removeNode.value = successor.value;
this.removeNodeProcess(successor); // only once
return;
} else { // one or zero child
let child = (removeNode.left === undefined ? removeNode.right : removeNode.left);
if (removeNode.parent === undefined) { // remove is root
if (child === undefined) {
this.root = undefined;
} else {
child.parent = undefined;
child.color = BLACK;
this.root = child;
}
} else {
if (child != undefined) {
// delete removeNode
if (removeNode.parent.left === removeNode) {
removeNode.parent.left = child;
} else {
removeNode.parent.right = child;
}
if (this.getColor(removeNode) === BLACK) {
this.deleteRebalance(child)
}
} else {
if (this.getColor(removeNode) === BLACK) {
this.deleteRebalance(removeNode)
}
if (removeNode.parent.left === removeNode) {
removeNode.parent.left = child;
} else {
removeNode.parent.right = child;
}
}
}
this.memberNumber--;
this.isChange = true;
}
let replacementNode = (removeNode.right === null ? removeNode.left : removeNode.right);
if (replacementNode !== null) {
replacementNode.parent = removeNode.parent;
if (removeNode.parent === null) {
this._root = replacementNode;
} else if (removeNode === removeNode.parent.right) {
removeNode.parent.right = replacementNode;
} else if (removeNode === removeNode.parent.left) {
removeNode.parent.left = replacementNode;
}
if (this.getColor(removeNode) === BLACK) {
this.deleteRebalance(replacementNode)
}
} else if (removeNode.parent === null) {
// removeNode.right = null; removeNode.left = null
this._root = null;
} else {
if (this.getColor(removeNode) === BLACK) {
this.deleteRebalance(removeNode)
}
if (removeNode === removeNode.parent.left) {
removeNode.parent.left = null;
} else if (removeNode === removeNode.parent.right) {
removeNode.parent.right = null;
}
}
this.memberNumber--;
this._isChange = true;
}
getNode(key: K): RBTreeNode<K, V> | null {
if (this._root === null)
return null;
let removeNode: RBTreeNode<K, V> | null = this._root;
while (removeNode !== null && removeNode.key !== key) {
removeNode = removeNode.key > key ? removeNode.left : removeNode.right;
getNode(key: K): RBTreeNode<K, V> | undefined {
if (this.root === undefined)
return undefined;
let findNode: RBTreeNode<K, V> | undefined = this.root;
while (findNode !== undefined && findNode.key !== key) {
findNode = currencyCompare(findNode.key, key, this.compFun) === ComparResult.BIGGER_THAN ?
findNode.left : findNode.right;
}
return removeNode;
return findNode;
}
findNode(value: V): RBTreeNode<K, V> | null {
let tempNode: RBTreeNode<K, V> | null = null;
findNode(value: V): RBTreeNode<K, V> | undefined {
let tempNode: RBTreeNode<K, V> | undefined = undefined;
this.recordByMinToMax();
for (let i = 0; i < this.memberNumber; i++) {
if (this._treeArray[i].value === value) tempNode = this._treeArray[i];
break;
if (this.treeNodeArray[i].value === value) {
tempNode = this.treeNodeArray[i];
break;
}
}
return tempNode;
}
firstNode(): RBTreeNode<K, V> | null {
let tempNode: RBTreeNode<K, V> | null = this._root;
while (tempNode !== null && tempNode.left !== null) {
firstNode(): RBTreeNode<K, V> | undefined {
let tempNode: RBTreeNode<K, V> | undefined = this.root;
while (tempNode !== undefined && tempNode.left !== undefined) {
tempNode = tempNode.left;
}
return tempNode;
}
lastNode(): RBTreeNode<K, V> | null {
let tempNode: RBTreeNode<K, V> | null = this._root;
while (tempNode !== null && tempNode.right !== null) {
lastNode(): RBTreeNode<K, V> | undefined {
let tempNode: RBTreeNode<K, V> | undefined = this.root;
while (tempNode !== undefined && tempNode.right !== undefined) {
tempNode = tempNode.right;
}
return tempNode;
}
isEmpty(): boolean {
return this._root === null;
return this.root === undefined;
}
setAll(map: RBTreeClass<K, V>) {
this.recordByMinToMax();
for (let i = 0; i < this.memberNumber; i++) {
map.addNode(this._treeArray[i].key, this._treeArray[i].value);
let tempArray = map.recordByMinToMax();
for (let i = 0; i < map.memberNumber; i++) {
this.addNode(tempArray[i].key, tempArray[i].value);
}
}
clearTree() {
this._root = null;
this.root = undefined;
this.memberNumber = 0;
}
private recordByMinToMax(): Array<RBTreeNode<K, V>> {
if (!this._isChange) return this._treeArray;
if (!this.isChange) return this.treeNodeArray;
let stack = [];
this._treeArray = [];
let node = this._root;
while (node != null || stack.length) {
while (node != null) {
this.treeNodeArray = [];
let node = this.root;
while (node != undefined || stack.length) {
while (node != undefined) {
stack.push(node);
node = node.left;
}
let tempNode = stack.pop();
if (tempNode === undefined || tempNode === null)
if (tempNode === undefined || tempNode === undefined)
throw new Error("this function run error");
node = tempNode;
this._treeArray.push(node);
this.treeNodeArray.push(node);
node = node.right;
}
this._isChange = false;
this.memberNumber = this._treeArray.length;
return this._treeArray;
this.isChange = false;
this.memberNumber = this.treeNodeArray.length;
return this.treeNodeArray;
}
private lRotate(datumPointNode: RBTreeNode<K, V>): RBTreeClass<K, V> {
let newTopNode = datumPointNode.right;
if (newTopNode === null)
throw new Error("[rotate right error]: the right child node of the base node === null")
if (newTopNode === undefined)
throw new Error("[rotate right error]: the right child node of the base node === undefined")
datumPointNode.right = newTopNode.left;
datumPointNode.right !== null ? datumPointNode.right.parent = datumPointNode : "";
datumPointNode.right !== undefined ? datumPointNode.right.parent = datumPointNode : "";
newTopNode.parent = datumPointNode.parent;
if (datumPointNode.parent === null) {
this._root = newTopNode;
if (datumPointNode.parent === undefined) {
this.root = newTopNode;
} else if (datumPointNode.parent.left === datumPointNode) {
datumPointNode.parent.left = newTopNode;
} else if (datumPointNode.parent.right === datumPointNode) {
@@ -475,14 +490,14 @@ class RBTreeClass<K, V> {
private rRotate(datumPointNode: RBTreeNode<K, V>): RBTreeClass<K, V> {
const newTopNode = datumPointNode.left;
if (newTopNode === null) {
throw new Error("[rotate right error]: the left child node of the base node === null")
if (newTopNode === undefined) {
throw new Error("[rotate right error]: the left child node of the base node === undefined")
}
datumPointNode.left = newTopNode.right;
datumPointNode.left !== null ? datumPointNode.left.parent = datumPointNode : "";
datumPointNode.left !== undefined ? datumPointNode.left.parent = datumPointNode : "";
newTopNode.parent = datumPointNode.parent
if (datumPointNode.parent === null) {
this._root = newTopNode;
if (datumPointNode.parent === undefined) {
this.root = newTopNode;
} else if (datumPointNode === datumPointNode.parent.left) {
datumPointNode.parent.left = newTopNode;
} else if (datumPointNode === datumPointNode.parent.right) {
@@ -496,23 +511,23 @@ class RBTreeClass<K, V> {
private insertRebalance(fixNode: RBTreeNode<K, V>): RBTreeClass<K, V> {
let parentNode = fixNode.parent;
while (this.getColor(parentNode) === RED &&
parentNode !== null &&
parentNode.parent !== null) {
parentNode !== undefined &&
parentNode.parent !== undefined) {
let grandpaNode = parentNode && parentNode.parent;
if (parentNode === grandpaNode.left &&
this.getColor(grandpaNode.right) === BLACK &&
fixNode === parentNode.left) {
this
.setColor(parentNode, BLACK)
.setColor(grandpaNode, RED)
.setColor(BLACK, parentNode)
.setColor(RED, grandpaNode)
.rRotate(grandpaNode)
break;
} else if (parentNode === grandpaNode.left &&
this.getColor(grandpaNode.right) === BLACK &&
fixNode === parentNode.right) {
this
.setColor(fixNode, BLACK)
.setColor(grandpaNode, RED)
.setColor(BLACK, fixNode)
.setColor(RED, grandpaNode)
.lRotate(parentNode)
.rRotate(grandpaNode)
break;
@@ -520,8 +535,8 @@ class RBTreeClass<K, V> {
this.getColor(grandpaNode.left) === BLACK &&
fixNode === parentNode.left) {
this
.setColor(fixNode, BLACK)
.setColor(grandpaNode, RED)
.setColor(BLACK, fixNode)
.setColor(RED, grandpaNode)
.rRotate(parentNode)
.lRotate(grandpaNode)
break;
@@ -529,64 +544,64 @@ class RBTreeClass<K, V> {
this.getColor(grandpaNode.left) === BLACK &&
fixNode === parentNode.right) {
this
.setColor(parentNode, BLACK)
.setColor(grandpaNode, RED)
.setColor(BLACK, parentNode)
.setColor(RED, grandpaNode)
.lRotate(grandpaNode)
break;
} else if ((parentNode === grandpaNode.right && this.getColor(grandpaNode.left) === RED) ||
(parentNode === grandpaNode.left && this.getColor(grandpaNode.right) === RED)) {
this
.setColor(parentNode, BLACK)
.setColor(parentNode === grandpaNode.left ? grandpaNode.right : grandpaNode.left, BLACK)
.setColor(grandpaNode, RED)
.setColor(BLACK, parentNode)
.setColor(BLACK, parentNode === grandpaNode.left ? grandpaNode.right : grandpaNode.left)
.setColor(RED, grandpaNode)
fixNode = grandpaNode;
parentNode = fixNode.parent;
} else {
throw new Error("Exceptions after adding")
}
}
this._root ? this._root.color = BLACK : "";
this.root ? this.root.color = BLACK : "";
return this;
}
private deleteRebalance(fixNode: RBTreeNode<K, V>) {
while (this.getColor(fixNode) === BLACK && fixNode !== this._root && fixNode.parent) {
let sibling: RBTreeNode<K, V> | null;
while (this.getColor(fixNode) === BLACK && fixNode !== this.root && fixNode.parent) {
let sibling: RBTreeNode<K, V> | undefined;
if (fixNode === fixNode.parent.left) {
sibling = fixNode.parent.right;
if (this.getColor(sibling) === RED) {
this
.setColor(fixNode.parent, RED)
.setColor(sibling, BLACK)
.setColor(RED, fixNode.parent)
.setColor(BLACK, sibling)
.lRotate(fixNode.parent)
sibling = fixNode.parent.right;
}
if (sibling === null) {
throw new Error('Error sibling node is null')
if (sibling === undefined) {
throw new Error('Error sibling node is undefined')
}
if (this.getColor(sibling.left) === BLACK && this.getColor(sibling.right) === BLACK) {
this.setColor(sibling, RED)
this.setColor(RED, sibling)
fixNode = fixNode.parent
} else if (this.getColor(sibling.left) === RED && this.getColor(sibling.right) === BLACK) {
this
.setColor(sibling, RED)
.setColor(sibling.left, BLACK)
.setColor(RED, sibling)
.setColor(BLACK, sibling.left)
.rRotate(sibling);
sibling = fixNode.parent.right
if (sibling === null) {
if (sibling === undefined) {
throw new Error('Error sibling node is empty')
}
this
.setColor(sibling, fixNode.parent.color)
.setColor(fixNode.parent, BLACK)
.setColor(sibling.right, BLACK)
.setColor(fixNode.parent.color, sibling)
.setColor(BLACK, fixNode.parent)
.setColor(BLACK, sibling.right)
.lRotate(fixNode.parent);
break;
} else if (this.getColor(sibling.right) === RED) {
this
.setColor(sibling, fixNode.parent.color)
.setColor(fixNode.parent, BLACK)
.setColor(sibling.right, BLACK)
.setColor(fixNode.parent.color, sibling)
.setColor(BLACK, fixNode.parent)
.setColor(BLACK, sibling.right)
.lRotate(fixNode.parent);
break;
} else {
@@ -596,38 +611,38 @@ class RBTreeClass<K, V> {
sibling = fixNode.parent.left;
if (this.getColor(sibling) === RED) {
this
.setColor(sibling, BLACK)
.setColor(fixNode.parent, RED)
.setColor(BLACK, sibling)
.setColor(RED, fixNode.parent)
.rRotate(fixNode.parent);
sibling = fixNode.parent.left;
}
if (sibling === null) {
throw new Error('Error sibling node is null')
if (sibling === undefined) {
throw new Error('Error sibling node is undefined')
}
if (this.getColor(sibling.left) === BLACK && this.getColor(sibling.right) === BLACK) {
this
.setColor(sibling, RED)
.setColor(RED, sibling)
fixNode = fixNode.parent;
} else if (this.getColor(sibling.left) === BLACK && this.getColor(sibling.right) === RED) {
this
.setColor(sibling, RED)
.setColor(sibling.right, BLACK)
.setColor(RED, sibling)
.setColor(BLACK, sibling.right)
.lRotate(sibling);
sibling = fixNode.parent.left;
if (sibling === null) {
if (sibling === undefined) {
throw new Error('Adjust the error after the error is deleted')
}
this
.setColor(sibling, fixNode.parent.color)
.setColor(fixNode.parent, BLACK)
.setColor(sibling.left, BLACK)
.setColor(fixNode.parent.color, sibling)
.setColor(BLACK, fixNode.parent)
.setColor(BLACK, sibling.left)
.rRotate(fixNode.parent);
break;
} else if (this.getColor(sibling.left) === RED) {
this
.setColor(sibling, fixNode.parent.color)
.setColor(fixNode.parent, BLACK)
.setColor(sibling.left, BLACK)
.setColor(fixNode.parent.color, sibling)
.setColor(BLACK, fixNode.parent,)
.setColor(BLACK, sibling.left)
.rRotate(fixNode.parent);
break;
} else {
@@ -635,15 +650,15 @@ class RBTreeClass<K, V> {
}
}
}
this.setColor(fixNode, BLACK)
this.setColor(BLACK, fixNode)
}
private getColor(node: RBTreeNode<K, V> | null): RBTreeNodeColor {
return node === null ? BLACK : node.color;
private getColor(node: RBTreeNode<K, V> | undefined): RBTreeNodeColor {
return node === undefined ? BLACK : node.color;
}
private setColor(node: RBTreeNode<K, V> | null, color: RBTreeNodeColor): RBTreeClass<K, V> {
if (node === null) {
private setColor(color: RBTreeNodeColor, node: RBTreeNode<K, V> | undefined): RBTreeClass<K, V> {
if (node === undefined) {
throw new Error("Wrong color setting")
} else {
node.color = color
@@ -652,20 +667,20 @@ class RBTreeClass<K, V> {
}
}
const MAX_CAPACITY = 1 << 30;
const MAXcapacity = 1 << 30;
const LOADER_FACTOR = 0.75;
class DictionaryClass<K, V> {
private _tableLink: { [hashIndex: number]: LinkedList<Pair<K, V>> | RBTreeClass<K, V> };
private tableLink: { [hashIndex: number]: LinkedList<Pair<K, V>> | RBTreeClass<K, V> };
protected memberNumber: number;
private _isChange: boolean;
private _memberArray: Array<Pair<K, V>>;
private _capacity: number;
private isChange: boolean;
private memberArray: Array<Pair<K, V>>;
private capacity: number;
constructor() {
this._tableLink = {};
this.tableLink = {};
this.memberNumber = 0;
this._isChange = true;
this._memberArray = [];
this._capacity = 16;
this.isChange = true;
this.memberArray = [];
this.capacity = 16;
}
get keyValueArray() {
@@ -676,8 +691,17 @@ class DictionaryClass<K, V> {
protected getHashIndex(key: K): number {
let h;
let hash = ((key === null) ? 0 : ((h = hashCode(key)) ^ (h >>> 16)));
this.expandCapacity();
let n = this.power(this._capacity);
if (this.expandCapacity()) {
this.keyValues();
this.memberNumber = 0;
this.tableLink = {};
this.isChange = true;
for (let item of this.memberArray) {
this.put(item.key, item.value);
}
this.memberNumber++;
}
let n = this.power(this.capacity);
return (n - 1) & hash;
}
@@ -692,43 +716,46 @@ class DictionaryClass<K, V> {
}
private keyValues(): Pair<K, V>[] {
if (!this._isChange) return this._memberArray;
this._memberArray = [];
const keys = Object.keys(this._tableLink).map((item) => parseInt(item));
if (!this.isChange) return this.memberArray;
this.memberArray = [];
const keys = Object.keys(this.tableLink).map((item) => parseInt(item));
for (let i = 0; i < keys.length; i++) {
const members = this._tableLink[keys[i]];
const members = this.tableLink[keys[i]];
if (members instanceof RBTreeClass) {
let tempArray = members.keyValueArray;
for (let i = 0; i < members.memberNumber; i++) {
this._memberArray.push(new Pair(tempArray[i].key, tempArray[i].value));
this.memberArray.push(new Pair(tempArray[i].key, tempArray[i].value));
}
} else {
if (members != null && !members.isEmpty()) {
if (members != undefined && !members.isEmpty()) {
let current = members.getHead();
while (current != null) {
this._memberArray.push(current.element);
while (current != undefined) {
this.memberArray.push(current.element);
current = current.next;
}
}
}
}
this.memberNumber = this._memberArray.length;
let valuePairs = this._memberArray;
this.memberNumber = this.memberArray.length;
let valuePairs = this.memberArray;
return valuePairs;
}
protected expandCapacity() {
while (this._capacity < this.memberNumber / LOADER_FACTOR && this._capacity < MAX_CAPACITY) {
this._capacity = 2 * this._capacity;
let capacityChange = false;
while (this.capacity < this.memberNumber / LOADER_FACTOR && this.capacity < MAXcapacity) {
this.capacity = 2 * this.capacity;
capacityChange = true;
}
return capacityChange;
}
protected put(key: K, value: V = key as unknown as V): boolean {
if (key != null && value != null) {
this._isChange = true;
this.memberNumber++;
if (key != undefined && value != undefined) {
this.isChange = true;
if (!this.hasKey(key)) this.memberNumber++;
const position = this.getHashIndex(key);
let members = this._tableLink[position];
let members = this.tableLink[position];
if (members instanceof LinkedList && members.count >= 8) {
let newElement = new RBTreeClass<K, V>();
let current = members.getHead();
@@ -739,19 +766,19 @@ class DictionaryClass<K, V> {
current = current.next;
}
newElement.addNode(key, value);
this._tableLink[position] = newElement;
this.tableLink[position] = newElement;
return true;
} else if (members instanceof RBTreeClass) {
members.addNode(key, value);
this._tableLink[position] = members;
this.tableLink[position] = members;
return true;
} else {
if (this._tableLink[position] == null) {
if (this.tableLink[position] == undefined) {
members = new LinkedList<Pair<K, V>>();
}
if (!this.replaceMember(key, value)) {
members.push(new Pair(key, value));
this._tableLink[position] = members;
this.tableLink[position] = members;
}
return true;
}
@@ -761,10 +788,10 @@ class DictionaryClass<K, V> {
protected replaceMember(key: K, value: V = key as unknown as V): boolean {
const position = this.getHashIndex(key);
const members = this._tableLink[position] as LinkedList<Pair<K, V>>;
const members = this.tableLink[position] as LinkedList<Pair<K, V>>;
if (members === null || members === undefined) return false;
let current = members.getHead();
while (current != null || current != undefined) {
while (current != undefined) {
if (current.element.key === key) {
current.element.value = value;
return true;
@@ -776,16 +803,16 @@ class DictionaryClass<K, V> {
protected getValueByKey(key: K): V | undefined {
const position = this.getHashIndex(key);
const members = this._tableLink[position];
const members = this.tableLink[position];
if (members instanceof RBTreeClass) {
let resultNode = members.getNode(key);
if (resultNode === null) return undefined;
if (resultNode === undefined) return undefined;
return resultNode.value;
} else {
if (members != null && !members.isEmpty()) {
if (members != undefined && !members.isEmpty()) {
members as LinkedList<Pair<K, V>>;
let current = members.getHead();
while (current != null) {
while (current != undefined) {
if (current.element.key === key) {
return current.element.value;
}
@@ -796,27 +823,27 @@ class DictionaryClass<K, V> {
return undefined;
}
protected removeMember(key: K): V | null {
protected removeMember(key: K): V | undefined {
const position = this.getHashIndex(key);
const members = this._tableLink[position];
const members = this.tableLink[position];
if (members instanceof RBTreeClass) {
let result = members.removeNode(key);
if (result != null) {
this._isChange = true;
if (result != undefined) {
this.isChange = true;
this.memberNumber--;
return result;
}
} else {
if (members != null && !members.isEmpty()) {
if (members != undefined && !members.isEmpty()) {
let current = members.getHead();
while (current != null) {
while (current != undefined) {
if (current.element.key === key) {
const result = current.element.value;
members.remove(current.element);
if (members.isEmpty()) {
delete this._tableLink[position];
delete this.tableLink[position];
}
this._isChange = true;
this.isChange = true;
this.memberNumber--;
return result;
}
@@ -824,24 +851,25 @@ class DictionaryClass<K, V> {
}
}
}
return null;
return undefined;
}
protected clear() {
this._tableLink = {};
this.tableLink = {};
this.memberNumber = 0;
this._isChange = true;
this.isChange = true;
this.capacity = 16;
}
protected hasKey(key: K): boolean {
const position = this.getHashIndex(key);
const members = this._tableLink[position];
if (members === null || members === undefined) return false;
const members = this.tableLink[position];
if (members === undefined || members === undefined) return false;
if (members instanceof RBTreeClass) {
return members.getNode(key) !== null;
return members.getNode(key) !== undefined;
}
let current = members.getHead();
while (current != null && current != undefined) {
while (current != undefined && current != undefined) {
if (current.element.key === key) {
return true;
}
@@ -851,9 +879,9 @@ class DictionaryClass<K, V> {
}
protected setAll(map: DictionaryClass<K, V>): void {
let memebers = this.keyValues();
let memebers = map.keyValues();
for (let i = 0; i < memebers.length; i++) {
map.put(memebers[i].key, memebers[i].value);
this.put(memebers[i].key, memebers[i].value);
}
}
@@ -867,32 +895,32 @@ class DictionaryClass<K, V> {
}
}
class Node<T>{
class Node<T> {
element: T;
next: Node<T> | null;
constructor(element: T, next: Node<T> | null = null) {
next: Node<T> | undefined;
constructor(element: T, next?: Node<T>) {
this.element = element;
this.next = next;
}
}
class LinkedList<T> {
public count: number;
protected next: Node<T> | null;
protected head: Node<T> | null;
protected next: Node<T> | undefined;
protected head: Node<T> | undefined;
constructor() {
this.count = 0;
this.next = null;
this.head = null;
this.next = undefined;
this.head = undefined;
}
push(element: T) {
const node = new Node(element);
let current;
if (this.head == null) {
if (this.head == undefined) {
this.head = node;
} else {
current = this.head;
while (current.next != null) {
while (current.next != undefined) {
current = current.next;
}
current.next = node;
@@ -903,16 +931,16 @@ class LinkedList<T> {
removeAt(index: number) {
if (index >= 0 && index < this.count) {
let current = this.head;
if (index === 0 && current != null) {
if (index === 0 && current != undefined) {
this.head = current.next;
} else {
const previous = this.getElementAt(index--);
if (previous !== null) {
if (previous !== undefined) {
current = previous.next;
previous.next = (current === null ? null : current.next);
previous.next = (current === undefined ? undefined : current.next);
}
}
if (current !== null) {
if (current !== undefined) {
this.count--;
return current.element;
}
@@ -923,12 +951,12 @@ class LinkedList<T> {
getElementAt(index: number) {
if (index > 0 && index < this.count) {
let current = this.head;
for (let i = 0; i < index && current != null; i++) {
for (let i = 0; i < index && current != undefined; i++) {
current = current.next;
}
return current;
}
return null;
return undefined;
}
insert(element: T, index: number) {
@@ -939,7 +967,7 @@ class LinkedList<T> {
this.head = node;
} else {
const previous = this.getElementAt(index--);
if (previous === null)
if (previous === undefined)
throw new Error("data storage error");
node.next = previous.next;
previous.next = node;
@@ -950,10 +978,10 @@ class LinkedList<T> {
return false;
}
indexOf(element: T) {
indexOf(element: T, compareFn?: Function) {
let current = this.head;
for (let i = 0; i < this.count && current != null; i++) {
if (currencyCompare(element, current.element)) {
for (let i = 0; i < this.count && current != undefined; i++) {
if (currencyCompare(element, current.element, compareFn) === ComparResult.EQUALS) {
return i;
}
current = current.next;
@@ -961,12 +989,12 @@ class LinkedList<T> {
return -1;
}
remove(element: T) {
this.removeAt(this.indexOf(element));
remove(element: T, compareFn?: Function) {
this.removeAt(this.indexOf(element, compareFn));
}
clear() {
this.head = null;
this.head = undefined;
this.count = 0;
}
@@ -979,12 +1007,12 @@ class LinkedList<T> {
}
toString() {
if (this.head == null) {
if (this.head == undefined) {
return "";
}
let objString = `${this.head.element}`;
let current = this.head.next;
for (let i = 1; i < this.count && current != null; i++) {
for (let i = 1; i < this.count && current != undefined; i++) {
objString = `${objString}, ${current.element}`;
current = current.next;
}
container/treemap/js_treemap.ts
+56 -49
View File
@@ -50,81 +50,85 @@ if (flag || fastTreeMap === undefined) {
}
}
class TreeMap<K, V> {
private _constitute: any;
constructor() {
this._constitute = new RBTreeAbility.RBTreeClass();
private constitute: any;
constructor(comparator?: (firstValue: K, secondValue: K) => boolean) {
this.constitute = new RBTreeAbility.RBTreeClass(comparator);
return new Proxy(this, new HandlerTreeMap());
}
}
get length() {
return this._constitute.memberNumber;
return this.constitute.memberNumber;
}
isEmpty() {
return this.constitute.memberNumber === 0;
}
hasKey(key: K): boolean {
return this._constitute.getNode(key) !== null;
return this.constitute.getNode(key) !== undefined;
}
hasValue(value: V): boolean {
return this._constitute.findNode(value) !== null;
return this.constitute.findNode(value) !== undefined;
}
get(key: K): V | null {
let tempNode = this._constitute.getNode(key);
if (tempNode === null)
return null;
get(key: K): V {
let tempNode = this.constitute.getNode(key);
if (tempNode === undefined)
throw new Error("The node of this key does not exist in the tree");
return tempNode.value;
}
getFirstKey(): K {
let tempNode = this._constitute.firstNode();
if (tempNode === null)
throw new Error("don't find this key,this tree is null");
let tempNode = this.constitute.firstNode();
if (tempNode === undefined)
throw new Error("don't find this key,this tree is empty");
return tempNode.key;
}
getLastKey(): K {
let tempNode = this._constitute.lastNode();
if (tempNode === null)
throw new Error("don't find this key,this tree is null");
let tempNode = this.constitute.lastNode();
if (tempNode === undefined)
throw new Error("don't find this key,this tree is empty");
return tempNode.key;
}
setAll(map: TreeMap<K, V>) {
this._constitute.setAll(map._constitute);
this.constitute.setAll(map.constitute);
}
set(key: K, value: V): Object {
return this._constitute.addNode(key, value);
return this.constitute.addNode(key, value);
}
remove(key: K): V | null {
return this._constitute.removeNode(key);
remove(key: K): V {
return this.constitute.removeNode(key);
}
clear() {
this._constitute.clearTree();
this.constitute.clearTree();
}
getLowerKey(key: K): K {
let tempNode = this._constitute.getNode(key);
if (tempNode === null)
let tempNode = this.constitute.getNode(key);
if (tempNode === undefined)
throw new Error("don't find this key,this node is undefine");
if (tempNode.left !== null) return tempNode.left.key;
if (tempNode.left !== undefined) return tempNode.left.key;
let node = tempNode;
while (node.parent !== null) {
while (node.parent !== undefined) {
if (node.parent.right === node) return node.parent.key;
node = node.parent;
}
throw new Error("don't find a key meet the conditions");
}
getHigherKey(key: K): K {
let tempNode = this._constitute.getNode(key);
if (tempNode === null)
let tempNode = this.constitute.getNode(key);
if (tempNode === undefined)
throw new Error("don't find this key,this node is undefine");
if (tempNode.right !== null) return tempNode.right.key;
if (tempNode.right !== undefined) return tempNode.right.key;
let node = tempNode;
while (node.parent !== null) {
while (node.parent !== undefined) {
if (node.parent.left === node) return node.parent.key;
node = node.parent;
}
throw new Error("don't find a key meet the conditions");
}
keys(): IterableIterator<K> {
let data = this._constitute;
let i = 0;
let data = this.constitute;
let count = 0;
return {
next: function () {
var done = i >= data.memberNumber;
var value = !done ? data.keyValueArray[i++].key : undefined;
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count].key : undefined;
count++;
return {
done: done,
value: value,
@@ -133,12 +137,13 @@ if (flag || fastTreeMap === undefined) {
};
}
values(): IterableIterator<V> {
let data = this._constitute;
let i = 0;
let data = this.constitute;
let count = 0;
return {
next: function () {
var done = i >= data.memberNumber;
var value = !done ? data.keyValueArray[i++].value as V : undefined;
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count].value : undefined;
count++;
return {
done: done,
value: value,
@@ -147,26 +152,27 @@ if (flag || fastTreeMap === undefined) {
};
}
replace(key: K, newValue: V): boolean {
let targetNode = this._constitute.getNode(key);
if (targetNode === null) return false;
let targetNode = this.constitute.getNode(key);
if (targetNode === undefined) return false;
targetNode.value = newValue;
return true;
}
forEach(callbackfn: (value?: V, key?: K, map?: TreeMap<K, V>) => void,
thisArg?: Object): void {
let data = this._constitute;
let data = this.constitute;
let tagetArray = data.keyValueArray;
for (let i = 0; i < data.memberNumber; i++) {
callbackfn.call(thisArg, tagetArray[i].value as V, tagetArray[i].key);
}
}
entries(): IterableIterator<[K, V]> {
let data = this._constitute;
let i = 0;
let data = this.constitute;
let count = 0;
return {
next: function () {
var done = i >= data.memberNumber;
var value = !done ? data.keyValueArray[i++].entry() : undefined;
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count].entry() : undefined;
count++;
return {
done: done,
value: value,
@@ -175,12 +181,13 @@ if (flag || fastTreeMap === undefined) {
};
}
[Symbol.iterator](): IterableIterator<[K, V]> {
let data = this._constitute;
let i = 0;
let data = this.constitute;
let count = 0;
return {
next: function () {
var done = i >= data.memberNumber;
var value = !done ? data.keyValueArray[i++].entry() : undefined;
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count].entry() : undefined;
count++;
return {
done: done,
value: value,
container/treeset/js_treeset.ts
+40 -37
View File
@@ -50,90 +50,91 @@ if (flag || fastTreeSet === undefined) {
}
}
class TreeSet<T> {
private _constitute: any;
constructor() {
this._constitute = new RBTreeAbility.RBTreeClass();
private constitute: any;
constructor(comparator?: (firstValue: T, secondValue: T) => boolean) {
this.constitute = new RBTreeAbility.RBTreeClass(comparator);
return new Proxy(this, new HandlerTreeSet());
}
get length() {
return this._constitute.memberNumber;
return this.constitute.memberNumber;
}
isEmpty(): boolean {
return this._constitute.isEmpty();
return this.constitute.isEmpty();
}
has(value: T): boolean {
return this._constitute.getNode(value) !== null;
return this.constitute.getNode(value) !== undefined;
}
add(value: T): boolean {
this._constitute.addNode(value);
this.constitute.addNode(value);
return true;
}
remove(value: T): boolean {
let result = this._constitute.removeNode(value);
return result !== null;
let result = this.constitute.removeNode(value);
return result !== undefined;
}
clear() {
this._constitute.clearTree();
this.constitute.clearTree();
}
getFirstValue(): T {
let tempNode = this._constitute.firstNode();
if (tempNode === null)
throw new Error("don't find this key,this tree is null");
let tempNode = this.constitute.firstNode();
if (tempNode === undefined)
throw new Error("don't find this key,this tree is empty");
return tempNode.key;
}
getLastValue(): T {
let tempNode = this._constitute.lastNode();
if (tempNode === null)
throw new Error("don't find this key,this tree is null");
let tempNode = this.constitute.lastNode();
if (tempNode === undefined)
throw new Error("don't find this key,this tree is empty");
return tempNode.key;
}
getLowerValue(key: T): T {
let tempNode = this._constitute.getNode(key);
if (tempNode === null)
let tempNode = this.constitute.getNode(key);
if (tempNode === undefined)
throw new Error("don't find this key,this node is undefine");
if (tempNode.left !== null) return tempNode.left.key;
if (tempNode.left !== undefined) return tempNode.left.key;
let node = tempNode;
while (node.parent !== null) {
while (node.parent !== undefined) {
if (node.parent.right === node) return node.parent.key;
node = node.parent; // node.parent.left === node is true;
}
throw new Error("don't find a key meet the conditions");
}
getHigherValue(key: T): T {
let tempNode = this._constitute.getNode(key);
if (tempNode === null)
let tempNode = this.constitute.getNode(key);
if (tempNode === undefined)
throw new Error("don't find this key,this node is undefine");
if (tempNode.right !== null) return tempNode.right.key;
if (tempNode.right !== undefined) return tempNode.right.key;
let node = tempNode;
while (node.parent !== null) {
while (node.parent !== undefined) {
if (node.parent.left === node) return node.parent.key;
node = node.parent; // node.parent.right === node is true;
}
throw new Error("don't find a key meet the conditions");
}
popFirst(): T {
let firstNode = this._constitute.firstNode();
if (firstNode === null)
let firstNode = this.constitute.firstNode();
if (firstNode === undefined)
throw new Error("don't find first node,this tree is empty");
let value = firstNode.value;
this._constitute.removeNodeProcess(firstNode);
this.constitute.removeNodeProcess(firstNode);
return value as T;
}
popLast(): T {
let lastNode = this._constitute.lastNode();
if (lastNode === null)
let lastNode = this.constitute.lastNode();
if (lastNode === undefined)
throw new Error("don't find last node,this tree is empty");
let value = lastNode.value;
this._constitute.removeNodeProcess(lastNode);
this.constitute.removeNodeProcess(lastNode);
return value as T;
}
values(): IterableIterator<T> {
let data = this._constitute;
let data = this.constitute;
let count = 0;
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].value as T : undefined;
var value = !done ? data.keyValueArray[count].value as T : undefined;
count++;
return {
done: done,
value: value,
@@ -143,19 +144,20 @@ if (flag || fastTreeSet === undefined) {
}
forEach(callbackfn: (value?: T, key?: T, set?: TreeSet<T>) => void,
thisArg?: Object): void {
let data = this._constitute;
let data = this.constitute;
let tagetArray = data.keyValueArray;
for (let i = 0; i < data.memberNumber; i++) {
callbackfn.call(thisArg, tagetArray[i].value as T, tagetArray[i].key);
}
}
entries(): IterableIterator<[T, T]> {
let data = this._constitute;
let data = this.constitute;
let count = 0;
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].entry() : undefined;
var value = !done ? data.keyValueArray[count].entry() : undefined;
count++;
return {
done: done,
value: value,
@@ -164,12 +166,13 @@ if (flag || fastTreeSet === undefined) {
};
}
[Symbol.iterator](): IterableIterator<T> {
let data = this._constitute;
let data = this.constitute;
let count = 0;
return {
next: function () {
var done = count >= data.memberNumber;
var value = !done ? data.keyValueArray[count++].key : undefined;
var value = !done ? data.keyValueArray[count].key : undefined;
count++;
return {
done: done,
value: value,
container/vector/js_vector.ts
+45 -43
View File
@@ -35,7 +35,7 @@ if (flag || fastVector == undefined) {
return obj[prop];
}
set(obj: Vector<T>, prop: any, value: T) {
if (prop === "_length" || prop === "_capacity") {
if (prop === "elementNum" || prop === "capacity") {
obj[prop] = value;
return true;
}
@@ -95,33 +95,33 @@ if (flag || fastVector == undefined) {
};
}
class Vector<T> {
private _length: number = 0;
private _capacity: number = 10;
private elementNum: number = 0;
private capacity: number = 10;
constructor() {
return new Proxy(this, new HandlerVector());
}
get length() {
return this._length;
return this.elementNum;
}
add(element: T): boolean {
if (this.isFull()) {
this.resize();
}
this[this._length++] = element;
this[this.elementNum++] = element;
return true;
}
insert(element: T, index: number): void {
if (this.isFull()) {
this.resize();
}
for (let i = this._length; i > index; i--) {
for (let i = this.elementNum; i > index; i--) {
this[i] = this[i - 1];
}
this[index] = element;
this._length++;
this.elementNum++;
}
has(element: T): boolean {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
if (this[i] === element) {
return true;
}
@@ -132,7 +132,7 @@ if (flag || fastVector == undefined) {
return this[index];
}
getIndexOf(element: T): number {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
if (element === this[i]) {
return i;
}
@@ -145,28 +145,30 @@ if (flag || fastVector == undefined) {
set(index: number, element: T): void {
this[index] = element;
}
removeByIndex(index: number): void {
for (let i = index; i < this._length - 1; i++) {
removeByIndex(index: number): T {
let result = this[index];
for (let i = index; i < this.elementNum - 1; i++) {
this[i] = this[i + 1];
}
this._length--;
this.elementNum--;
return result;
}
remove(element: T): boolean {
if (this.has(element)) {
let index = this.getIndexOf(element);
for (let i = index; i < this._length - 1; i++) {
for (let i = index; i < this.elementNum - 1; i++) {
this[i] = this[i + 1];
}
this._length--;
this.elementNum--;
return true;
}
return false;
}
getLastElement(): T {
return this[this._length - 1];
return this[this.elementNum - 1];
}
getLastIndexOf(element: T): number {
for (let i = this._length - 1; i >= 0; i--) {
for (let i = this.elementNum - 1; i >= 0; i--) {
if (element === this[i]) {
return i;
}
@@ -185,7 +187,7 @@ if (flag || fastVector == undefined) {
}
getIndexFrom(element: T, index: number): number {
if (this.has(element)) {
for (let i = index; i < this._length; i++) {
for (let i = index; i < this.elementNum; i++) {
if (this[i] === element) {
return i;
}
@@ -194,7 +196,7 @@ if (flag || fastVector == undefined) {
return -1;
}
clear(): void {
this._length = 0;
this.elementNum = 0;
}
removeByRange(fromIndex: number, toIndex: number): void {
if (fromIndex >= toIndex) {
@@ -202,32 +204,32 @@ if (flag || fastVector == undefined) {
}
toIndex = toIndex >= this.length - 1 ? this.length - 1 : toIndex;
let i = fromIndex;
for (let j = toIndex; j < this._length; j++) {
for (let j = toIndex; j < this.elementNum; j++) {
this[i] = this[j];
i++;
}
this._length -= toIndex - fromIndex;
this.elementNum -= toIndex - fromIndex;
}
setLength(newSize: number): void {
this._length = newSize;
this.elementNum = newSize;
}
replaceAllElements(callbackfn: (value: T, index?: number, vector?: Vector<T>) => T,
thisArg?: Object): void {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
this[i] = callbackfn.call(thisArg, this[i], i, this);
}
}
forEach(callbackfn: (value: T, index?: number, vector?: Vector<T>) => void,
thisArg?: Object): void {
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
callbackfn.call(thisArg, this[i], i, this);
}
}
sort(comparator?: (firstValue: T, secondValue: T) => number): void {
let isSort = true;
if (comparator) {
for (let i = 0; i < this._length; i++) {
for (let j = 0; j < this._length - 1 - i; j++) {
for (let i = 0; i < this.elementNum; i++) {
for (let j = 0; j < this.elementNum - 1 - i; j++) {
if (comparator(this[j], this[j + 1]) > 0) {
isSort = false;
let temp = this[j];
@@ -238,7 +240,7 @@ if (flag || fastVector == undefined) {
}
} else {
for (var i = 0; i < this.length - 1; i++) {
for (let j = 0; j < this._length - 1 - i; j++) {
for (let j = 0; j < this.elementNum - 1 - i; j++) {
if (this.asciSort(this[j], this[j + 1])) {
isSort = false;
let temp = this[j];
@@ -270,7 +272,10 @@ if (flag || fastVector == undefined) {
if (fromIndex >= toIndex) {
throw new Error(`fromIndex cannot be less than or equal to toIndex`);
}
toIndex = toIndex >= this._length - 1 ? this._length - 1 : toIndex;
if (fromIndex >= this.elementNum || fromIndex < 0 || toIndex < 0) {
throw new Error(`fromIndex or toIndex is out-of-bounds`);
}
toIndex = toIndex >= this.elementNum - 1 ? this.elementNum - 1 : toIndex;
let vector = new Vector<T>();
for (let i = fromIndex; i < toIndex; i++) {
vector.add(this[i]);
@@ -279,7 +284,7 @@ if (flag || fastVector == undefined) {
}
convertToArray(): Array<T> {
let arr = [];
for (let i = 0; i < this._length; i++) {
for (let i = 0; i < this.elementNum; i++) {
arr[i] = this[i];
}
return arr;
@@ -292,47 +297,44 @@ if (flag || fastVector == undefined) {
}
toString(): string {
let str = `${this[0]}`;
for (let i = 1; i < this._length; i++) {
for (let i = 1; i < this.elementNum; i++) {
str = `${str},${this[i]}`;
}
return str;
}
clone(): Vector<T> {
let clone = new Vector<T>();
for (let i = 0; i < this._length; i++) {
this.add(this[i]);
for (let i = 0; i < this.elementNum; i++) {
clone.add(this[i]);
}
return clone;
}
getCapacity(): number {
return this._capacity;
return this.capacity;
}
private isFull(): boolean {
return this._length === this._capacity;
return this.elementNum === this.capacity;
}
private resize(): void {
this._capacity = 2 * this._capacity;
this.capacity = 2 * this.capacity;
}
increaseCapacityTo(newCapacity: number): void {
if (newCapacity >= this._length) {
this._capacity = newCapacity;
if (newCapacity >= this.elementNum) {
this.capacity = newCapacity;
}
}
trimToCurrentLength(): void {
this._capacity = this._length;
}
setSize(newSize: number): void {
this._length = newSize;
this.capacity = this.elementNum;
}
isEmpty(): boolean {
return this._length == 0;
return this.elementNum == 0;
}
[Symbol.iterator](): IterableIterator<T> {
let count = 0;
let vector = this
let vector = this;
return {
next: function () {
var done = count >= vector._length;
var done = count >= vector.elementNum;
var value = !done ? vector[count++] : undefined;
return {
done: done,