জাভাস্ক্রিপ্টে স্ট্যাক এবং একটি সারি কার্যকর করার সর্বোত্তম উপায় কী?
আমি শান্টিং-ইয়ার্ড অ্যালগরিদম করতে চাই এবং আমি এই ডেটা-কাঠামোগুলি প্রয়োজন।
জাভাস্ক্রিপ্টে স্ট্যাক এবং একটি সারি কার্যকর করার সর্বোত্তম উপায় কী?
আমি শান্টিং-ইয়ার্ড অ্যালগরিদম করতে চাই এবং আমি এই ডেটা-কাঠামোগুলি প্রয়োজন।
উত্তর:
var stack = [];
stack.push(2); // stack is now [2]
stack.push(5); // stack is now [2, 5]
var i = stack.pop(); // stack is now [2]
alert(i); // displays 5
var queue = [];
queue.push(2); // queue is now [2]
queue.push(5); // queue is now [2, 5]
var i = queue.shift(); // queue is now [5]
alert(i); // displays 2"থেকে নেওয়া 9 জাভাস্ক্রিপ্ট টিপস আপনি হয়তো জানেন না "
জাভাস্ক্রিপ্টে পুশ এবং পপ পদ্ধতি রয়েছে, যা সাধারণ জাভাস্ক্রিপ্ট অ্যারে অবজেক্টগুলিতে কাজ করে।
সারিগুলির জন্য, এখানে দেখুন:
http://safalra.com/web-design/javascript/queues/
অ্যারে অবজেক্টের পুশ এবং শিফট পদ্ধতি বা আনশিফ্ট এবং পপ পদ্ধতি ব্যবহার করে জাভাস্ক্রিপ্টে সারিগুলি প্রয়োগ করা যেতে পারে। যদিও এটি সারিগুলি প্রয়োগ করার একটি সহজ উপায়, এটি বড় কাতারের জন্য খুব অদক্ষ - কারণ পদ্ধতিগুলি অ্যারেতে চালিত হয়, শিফট এবং আনশিফ্ট পদ্ধতিগুলি প্রতিটি বার যখন ডাকা হয় তখন অ্যারেতে প্রতিটি উপাদান সরিয়ে নিয়ে যায়।
কুই.ইজেএস জাভাস্ক্রিপ্টের জন্য একটি সহজ এবং দক্ষ ক্যু বাস্তবায়ন যাঁর ডিক্যু ফাংশনটি নিয়মিত সময়ে চালিত হয়। ফলস্বরূপ, বৃহত্তর সারিতে, এটি ব্যবহারের চেয়ে তাড়াতাড়ি দ্রুত হতে পারে।
অ্যারেগুলির।
স্ট্যাক:
var stack = [];
//put value on top of stack
stack.push(1);
//remove value from top of stack
var value = stack.pop();কিউ:
var queue = [];
//put value on end of queue
queue.push(1);
//Take first value from queue
var value = queue.shift();pushএবং popপদ্ধতিগুলি প্রয়োগ করে থাকেন, তবে সমস্যা সমাধান হয়েছে। আমি এখানে সত্যিই আপনার পয়েন্ট দেখতে পাচ্ছি না।
আপনি যদি নিজের নিজস্ব ডেটা স্ট্রাকচার তৈরি করতে চান, আপনি নিজের তৈরি করতে পারেন:
var Stack = function(){
this.top = null;
this.size = 0;
};
var Node = function(data){
this.data = data;
this.previous = null;
};
Stack.prototype.push = function(data) {
var node = new Node(data);
node.previous = this.top;
this.top = node;
this.size += 1;
return this.top;
};
Stack.prototype.pop = function() {
temp = this.top;
this.top = this.top.previous;
this.size -= 1;
return temp;
};এবং সারি জন্য:
var Queue = function() {
this.first = null;
this.size = 0;
};
var Node = function(data) {
this.data = data;
this.next = null;
};
Queue.prototype.enqueue = function(data) {
var node = new Node(data);
if (!this.first){
this.first = node;
} else {
n = this.first;
while (n.next) {
n = n.next;
}
n.next = node;
}
this.size += 1;
return node;
};
Queue.prototype.dequeue = function() {
temp = this.first;
this.first = this.first.next;
this.size -= 1;
return temp;
};Nodeপপিং / ডিসকুইংয়ের সময় তৈরি হওয়াগুলি মুছে ফেলা দেখতে পাচ্ছি না ... ব্রাউজার ক্রাশ না হওয়া পর্যন্ত তারা কেবল মেমরি হোগিংয়ের আশেপাশে বসে থাকবে না?
deleteকীওয়ার্ড রয়েছে তবে এটি কেবলমাত্র কোনও সামগ্রীর উপস্থিতি অ-উপস্থিত হিসাবে চিহ্নিতundefined করার জন্য কার্যকর — যা কেবলমাত্র সম্পত্তি অর্পণ থেকে পৃথক । জাভাস্ক্রিপ্টেরও একটি newঅপারেটর রয়েছে, তবে এটি thisকোনও ফাংশন কল করার সময় একটি নতুন ফাঁকা বস্তুতে সেট করতে ব্যবহৃত হয় । সি ++ এ আপনাকে প্রত্যেকের newসাথে একটি যুক্ত করতে হবে deleteতবে জাভাস্ক্রিপ্টে নয় কারণ জিসি। জাভাস্ক্রিপ্টে মেমরি ব্যবহার বন্ধ করতে, কেবলমাত্র অবজেক্টটি উল্লেখ করা বন্ধ করুন এবং শেষ পর্যন্ত এটি পুনরুদ্ধার করা হবে।
আমার প্রয়োগ Stackএবং Queueব্যবহারLinked List
// Linked List
function Node(data) {
this.data = data;
this.next = null;
}
// Stack implemented using LinkedList
function Stack() {
this.top = null;
}
Stack.prototype.push = function(data) {
var newNode = new Node(data);
newNode.next = this.top; //Special attention
this.top = newNode;
}
Stack.prototype.pop = function() {
if (this.top !== null) {
var topItem = this.top.data;
this.top = this.top.next;
return topItem;
}
return null;
}
Stack.prototype.print = function() {
var curr = this.top;
while (curr) {
console.log(curr.data);
curr = curr.next;
}
}
// var stack = new Stack();
// stack.push(3);
// stack.push(5);
// stack.push(7);
// stack.print();
// Queue implemented using LinkedList
function Queue() {
this.head = null;
this.tail = null;
}
Queue.prototype.enqueue = function(data) {
var newNode = new Node(data);
if (this.head === null) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
this.tail = newNode;
}
}
Queue.prototype.dequeue = function() {
var newNode;
if (this.head !== null) {
newNode = this.head.data;
this.head = this.head.next;
}
return newNode;
}
Queue.prototype.print = function() {
var curr = this.head;
while (curr) {
console.log(curr.data);
curr = curr.next;
}
}
var queue = new Queue();
queue.enqueue(3);
queue.enqueue(5);
queue.enqueue(7);
queue.print();
queue.dequeue();
queue.dequeue();
queue.print();জাভাস্ক্রিপ্ট অ্যারে শিফট () ধীরে ধীরে বিশেষত যখন অনেক উপাদান থাকে holding মোড়কযুক্ত ও (1) জটিলতার সাথে সারিটি প্রয়োগ করার দুটি উপায় আমি জানি।
প্রথমটি হল বিজ্ঞপ্তি বাফার এবং টেবিল দ্বিগুণ করে। আমি এর আগেও এটি বাস্তবায়ন করেছি। আপনি আমার উত্স কোডটি এখানে https://github.com/kevyuu/rapid-queue দেখতে পারেন
দ্বিতীয় উপায়টি দুটি স্ট্যাক ব্যবহার করে। এটি দুটি স্ট্যাকের সাথে সারির কোড
function createDoubleStackQueue() {
var that = {};
var pushContainer = [];
var popContainer = [];
function moveElementToPopContainer() {
while (pushContainer.length !==0 ) {
var element = pushContainer.pop();
popContainer.push(element);
}
}
that.push = function(element) {
pushContainer.push(element);
};
that.shift = function() {
if (popContainer.length === 0) {
moveElementToPopContainer();
}
if (popContainer.length === 0) {
return null;
} else {
return popContainer.pop();
}
};
that.front = function() {
if (popContainer.length === 0) {
moveElementToPopContainer();
}
if (popContainer.length === 0) {
return null;
}
return popContainer[popContainer.length - 1];
};
that.length = function() {
return pushContainer.length + popContainer.length;
};
that.isEmpty = function() {
return (pushContainer.length + popContainer.length) === 0;
};
return that;}এটি jscreen ব্যবহার করে পারফরম্যান্স তুলনা
সার্কুলারকিউ.শিফ্ট () বনাম অ্যারে.শફ્ટ ()
http://jsperf.com/rapidqueue-shift-vs-array-shift
আপনি দেখতে পাচ্ছেন এটি বড় ডেটাসেটের সাথে উল্লেখযোগ্যভাবে দ্রুত
বেশ কয়েকটি কয়েকটি উপায় রয়েছে যা আপনি জাভাস্ক্রিপ্টে স্ট্যাকস এবং কুইউগুলি প্রয়োগ করতে পারেন। উপরের উত্তরগুলির বেশিরভাগগুলি বেশ অগভীর বাস্তবায়ন এবং আমি আরও কিছু পাঠযোগ্য (এস -6 এর নতুন সিনট্যাক্স বৈশিষ্ট্যগুলি ব্যবহার করে) এবং শক্তিশালী করার চেষ্টা করব।
এখানে স্ট্যাক বাস্তবায়ন:
class Stack {
constructor(...items){
this._items = []
if(items.length>0)
items.forEach(item => this._items.push(item) )
}
push(...items){
//push item to the stack
items.forEach(item => this._items.push(item) )
return this._items;
}
pop(count=0){
//pull out the topmost item (last item) from stack
if(count===0)
return this._items.pop()
else
return this._items.splice( -count, count )
}
peek(){
// see what's the last item in stack
return this._items[this._items.length-1]
}
size(){
//no. of items in stack
return this._items.length
}
isEmpty(){
// return whether the stack is empty or not
return this._items.length==0
}
toArray(){
return this._items;
}
}এবং এইভাবে আপনি স্ট্যাকটি ব্যবহার করতে পারেন:
let my_stack = new Stack(1,24,4);
// [1, 24, 4]
my_stack.push(23)
//[1, 24, 4, 23]
my_stack.push(1,2,342);
//[1, 24, 4, 23, 1, 2, 342]
my_stack.pop();
//[1, 24, 4, 23, 1, 2]
my_stack.pop(3)
//[1, 24, 4]
my_stack.isEmpty()
// false
my_stack.size();
//3আপনি যদি এই বাস্তবায়ন সম্পর্কে আরও বিশদ বিবরণ দেখতে চান এবং এটি কীভাবে আরও উন্নত হতে পারে তবে আপনি এখানে পড়তে পারেন: http://jschap.com/data-structures-in-javascript-stack/
এস in এ সারি বাস্তবায়নের জন্য কোডটি এখানে রয়েছে:
class Queue{
constructor(...items){
//initialize the items in queue
this._items = []
// enqueuing the items passed to the constructor
this.enqueue(...items)
}
enqueue(...items){
//push items into the queue
items.forEach( item => this._items.push(item) )
return this._items;
}
dequeue(count=1){
//pull out the first item from the queue
this._items.splice(0,count);
return this._items;
}
peek(){
//peek at the first item from the queue
return this._items[0]
}
size(){
//get the length of queue
return this._items.length
}
isEmpty(){
//find whether the queue is empty or no
return this._items.length===0
}
}আপনি এই প্রয়োগটি কীভাবে ব্যবহার করতে পারেন তা এখানে:
let my_queue = new Queue(1,24,4);
// [1, 24, 4]
my_queue.enqueue(23)
//[1, 24, 4, 23]
my_queue.enqueue(1,2,342);
//[1, 24, 4, 23, 1, 2, 342]
my_queue.dequeue();
//[24, 4, 23, 1, 2, 342]
my_queue.dequeue(3)
//[1, 2, 342]
my_queue.isEmpty()
// false
my_queue.size();
//3কীভাবে এই ডেটা স্ট্রাকচারগুলি প্রয়োগ করা হয়েছে এবং কীভাবে এগুলি আরও উন্নত করা যায় তার সম্পূর্ণ টিউটোরিয়ালটি দেখতে আপনি jschap.com- এ 'জাভাস্ক্রিপ্টে ডেটা স্ট্রাকচারের সাথে বাজানো' সিরিজটি যেতে চাইতে পারেন। কাতারের লিঙ্কগুলি এখানে - http://jschap.com/playing-data-structures- জাভাস্ক্রিপ্ট- queues/
আপনি ধারণার উপর ভিত্তি করে নিজের কাস্টমাইজ ক্লাসটি ব্যবহার করতে পারেন, এখানে কোড স্নিপেট যা আপনি স্টাফটি করতে ব্যবহার করতে পারেন
/*
* Stack implementation in JavaScript
*/
function Stack() {
this.top = null;
this.count = 0;
this.getCount = function() {
return this.count;
}
this.getTop = function() {
return this.top;
}
this.push = function(data) {
var node = {
data: data,
next: null
}
node.next = this.top;
this.top = node;
this.count++;
}
this.peek = function() {
if (this.top === null) {
return null;
} else {
return this.top.data;
}
}
this.pop = function() {
if (this.top === null) {
return null;
} else {
var out = this.top;
this.top = this.top.next;
if (this.count > 0) {
this.count--;
}
return out.data;
}
}
this.displayAll = function() {
if (this.top === null) {
return null;
} else {
var arr = new Array();
var current = this.top;
//console.log(current);
for (var i = 0; i < this.count; i++) {
arr[i] = current.data;
current = current.next;
}
return arr;
}
}
}এবং এটিতে আপনার কনসোলটি ব্যবহার করে তা পরীক্ষা করতে এবং এই লাইনগুলিকে একে একে চেষ্টা করে দেখুন।
>> var st = new Stack();
>> st.push("BP");
>> st.push("NK");
>> st.getTop();
>> st.getCount();
>> st.displayAll();
>> st.pop();
>> st.displayAll();
>> st.getTop();
>> st.peek();/*------------------------------------------------------------------
Defining Stack Operations using Closures in Javascript, privacy and
state of stack operations are maintained
@author:Arijt Basu
Log: Sun Dec 27, 2015, 3:25PM
-------------------------------------------------------------------
*/
var stackControl = true;
var stack = (function(array) {
array = [];
//--Define the max size of the stack
var MAX_SIZE = 5;
function isEmpty() {
if (array.length < 1) console.log("Stack is empty");
};
isEmpty();
return {
push: function(ele) {
if (array.length < MAX_SIZE) {
array.push(ele)
return array;
} else {
console.log("Stack Overflow")
}
},
pop: function() {
if (array.length > 1) {
array.pop();
return array;
} else {
console.log("Stack Underflow");
}
}
}
})()
// var list = 5;
// console.log(stack(list))
if (stackControl) {
console.log(stack.pop());
console.log(stack.push(3));
console.log(stack.push(2));
console.log(stack.pop());
console.log(stack.push(1));
console.log(stack.pop());
console.log(stack.push(38));
console.log(stack.push(22));
console.log(stack.pop());
console.log(stack.pop());
console.log(stack.push(6));
console.log(stack.pop());
}
//End of STACK Logic
/* Defining Queue operations*/
var queue = (function(array) {
array = [];
var reversearray;
//--Define the max size of the stack
var MAX_SIZE = 5;
function isEmpty() {
if (array.length < 1) console.log("Queue is empty");
};
isEmpty();
return {
insert: function(ele) {
if (array.length < MAX_SIZE) {
array.push(ele)
reversearray = array.reverse();
return reversearray;
} else {
console.log("Queue Overflow")
}
},
delete: function() {
if (array.length > 1) {
//reversearray = array.reverse();
array.pop();
return array;
} else {
console.log("Queue Underflow");
}
}
}
})()
console.log(queue.insert(5))
console.log(queue.insert(3))
console.log(queue.delete(3))অন্যথায় আপনি সারি ডেটা কাঠামো প্রয়োগ করতে দুটি অ্যারে ব্যবহার করতে পারেন।
var temp_stack = new Array();
var stack = new Array();
temp_stack.push(1);
temp_stack.push(2);
temp_stack.push(3);আমি যদি এখনই উপাদানগুলিকে পপ করি তবে আউটপুট 3,2,1 হবে। তবে আমরা ফিফোর কাঠামো চাই যাতে আপনি নিম্নলিখিতটি করতে পারেন।
stack.push(temp_stack.pop());
stack.push(temp_stack.pop());
stack.push(temp_stack.pop());
stack.pop(); //Pop out 1
stack.pop(); //Pop out 2
stack.pop(); //Pop out 3pushপ্রথমবারের পরে কখনও হন নাpop
এখানে দুটি লক্ষ্য সহ মোটামুটি সহজ সারি প্রয়োগকরণ রয়েছে:
স্ট্যাক বাস্তবায়ন কেবল দ্বিতীয় লক্ষ্য শেয়ার করে।
// Queue
function Queue() {
this.q = new Array(5);
this.first = 0;
this.size = 0;
}
Queue.prototype.enqueue = function(a) {
var other;
if (this.size == this.q.length) {
other = new Array(this.size*2);
for (var i = 0; i < this.size; i++) {
other[i] = this.q[(this.first+i)%this.size];
}
this.first = 0;
this.q = other;
}
this.q[(this.first+this.size)%this.q.length] = a;
this.size++;
};
Queue.prototype.dequeue = function() {
if (this.size == 0) return undefined;
this.size--;
var ret = this.q[this.first];
this.first = (this.first+1)%this.q.length;
return ret;
};
Queue.prototype.peek = function() { return this.size > 0 ? this.q[this.first] : undefined; };
Queue.prototype.isEmpty = function() { return this.size == 0; };
// Stack
function Stack() {
this.s = new Array(5);
this.size = 0;
}
Stack.prototype.push = function(a) {
var other;
if (this.size == this.s.length) {
other = new Array(this.s.length*2);
for (var i = 0; i < this.s.length; i++) other[i] = this.s[i];
this.s = other;
}
this.s[this.size++] = a;
};
Stack.prototype.pop = function() {
if (this.size == 0) return undefined;
return this.s[--this.size];
};
Stack.prototype.peek = function() { return this.size > 0 ? this.s[this.size-1] : undefined; };অন্যান্য উত্তরে বর্ণিত হিসাবে স্ট্যাকের প্রয়োগটি তুচ্ছ।
তবে জাভাস্ক্রিপ্টে একটি সারি প্রয়োগের জন্য আমি এই থ্রেডে কোনও সন্তোষজনক উত্তর পাই না, তাই আমি নিজের তৈরি করেছি।
এই থ্রেডে তিন ধরণের সমাধান রয়েছে:
array.shift() বড় অ্যারে করে খুব অদক্ষ।বিলম্বিত শিফট অ্যারেগুলি আমার মনের মধ্যে সবচেয়ে সন্তোষজনক সমাধান, তবে তারা এখনও একটি বড় সংমিশ্রিত অ্যারেতে সমস্ত কিছু সংরক্ষণ করে যা সমস্যাযুক্ত হতে পারে এবং অ্যারেটি কেটে গেলে অ্যাপ্লিকেশনটি স্তব্ধ হয়ে যায়।
আমি ছোট অ্যারেগুলির লিঙ্কযুক্ত তালিকাগুলি ব্যবহার করে একটি বাস্তবায়ন করেছি (প্রতিটি 1000 টির বেশি উপাদান)। অ্যারে বিলম্বিত শিফট অ্যারের মতো আচরণ করে, এগুলি ছাড়া কখনও সেগুলি কাটা হয় না: অ্যারের প্রতিটি উপাদান সরিয়ে ফেলা হলে অ্যারেটি কেবল ফেলে দেওয়া হয়।
প্যাকেজটি এনপিএম হয়বুনিয়াদী ফিফোর কার্যকারিতা সহ রয়েছে, আমি সম্প্রতি এটিকে ধাক্কা দিয়েছি। কোডটি দুটি ভাগে বিভক্ত।
এখানে প্রথম অংশ
/** Queue contains a linked list of Subqueue */
class Subqueue <T> {
public full() {
return this.array.length >= 1000;
}
public get size() {
return this.array.length - this.index;
}
public peek(): T {
return this.array[this.index];
}
public last(): T {
return this.array[this.array.length-1];
}
public dequeue(): T {
return this.array[this.index++];
}
public enqueue(elem: T) {
this.array.push(elem);
}
private index: number = 0;
private array: T [] = [];
public next: Subqueue<T> = null;
}এবং এখানে প্রধান Queueবর্গ:
class Queue<T> {
get length() {
return this._size;
}
public push(...elems: T[]) {
for (let elem of elems) {
if (this.bottom.full()) {
this.bottom = this.bottom.next = new Subqueue<T>();
}
this.bottom.enqueue(elem);
}
this._size += elems.length;
}
public shift(): T {
if (this._size === 0) {
return undefined;
}
const val = this.top.dequeue();
this._size--;
if (this._size > 0 && this.top.size === 0 && this.top.full()) {
// Discard current subqueue and point top to the one after
this.top = this.top.next;
}
return val;
}
public peek(): T {
return this.top.peek();
}
public last(): T {
return this.bottom.last();
}
public clear() {
this.bottom = this.top = new Subqueue();
this._size = 0;
}
private top: Subqueue<T> = new Subqueue();
private bottom: Subqueue<T> = this.top;
private _size: number = 0;
}প্রকার টীকা ( : X) সহজে ES6 জাভাস্ক্রিপ্ট কোড প্রাপ্ত সরানো হতে পারে।
আপনি যদি পুশ () এবং পপ () ফাংশনগুলির সাথে স্ট্যাকগুলি বুঝতে পারেন তবে সারি এই অপারেশনগুলির একটি অপোসাইট অর্থে তৈরি করার জন্য। পুশ () এর অপোসাইট হ'ল আনশিফ্ট () এবং পপ () এস শিফট () এর অপোসাইট। তারপর:
//classic stack
var stack = [];
stack.push("first"); // push inserts at the end
stack.push("second");
stack.push("last");
stack.pop(); //pop takes the "last" element
//One way to implement queue is to insert elements in the oposite sense than a stack
var queue = [];
queue.unshift("first"); //unshift inserts at the beginning
queue.unshift("second");
queue.unshift("last");
queue.pop(); //"first"
//other way to do queues is to take the elements in the oposite sense than stack
var queue = [];
queue.push("first"); //push, as in the stack inserts at the end
queue.push("second");
queue.push("last");
queue.shift(); //but shift takes the "first" element.shift()পদ্ধতি একটি সঠিক কিউ বাস্তবায়ন নয়। এটি ও (1) এর চেয়ে ও (এন), এবং বড় কাতারের জন্য ধীর হবে।
এখানে একটি সারিটির লিঙ্কযুক্ত তালিকার সংস্করণটি দেওয়া হয়েছে যা এতে শেষ নোডও রয়েছে যা @ স্পারকিনস পরামর্শ দিয়েছিলেন এবং এটি সবচেয়ে উপযুক্ত।
// QUEUE Object Definition
var Queue = function() {
this.first = null;
this.last = null;
this.size = 0;
};
var Node = function(data) {
this.data = data;
this.next = null;
};
Queue.prototype.enqueue = function(data) {
var node = new Node(data);
if (!this.first){ // for empty list first and last are the same
this.first = node;
this.last = node;
} else { // otherwise we stick it on the end
this.last.next=node;
this.last=node;
}
this.size += 1;
return node;
};
Queue.prototype.dequeue = function() {
if (!this.first) //check for empty list
return null;
temp = this.first; // grab top of list
if (this.first==this.last) {
this.last=null; // when we need to pop the last one
}
this.first = this.first.next; // move top of list down
this.size -= 1;
return temp;
};আপনি যদি কিছু বেসিক ক্রিয়াকলাপ (লিঙ্কযুক্ত তালিকার উপর ভিত্তি করে) স্ট্যাক এবং কুইউ ডেটা স্ট্রাকচারের ES6 OOP বাস্তবায়ন সন্ধান করছেন তবে এটি এর মতো দেখতে পাওয়া যাবে:
Queue.js
import LinkedList from '../linked-list/LinkedList';
export default class Queue {
constructor() {
this.linkedList = new LinkedList();
}
isEmpty() {
return !this.linkedList.tail;
}
peek() {
if (!this.linkedList.head) {
return null;
}
return this.linkedList.head.value;
}
enqueue(value) {
this.linkedList.append(value);
}
dequeue() {
const removedHead = this.linkedList.deleteHead();
return removedHead ? removedHead.value : null;
}
toString(callback) {
return this.linkedList.toString(callback);
}
}Stack.js
import LinkedList from '../linked-list/LinkedList';
export default class Stack {
constructor() {
this.linkedList = new LinkedList();
}
/**
* @return {boolean}
*/
isEmpty() {
return !this.linkedList.tail;
}
/**
* @return {*}
*/
peek() {
if (!this.linkedList.tail) {
return null;
}
return this.linkedList.tail.value;
}
/**
* @param {*} value
*/
push(value) {
this.linkedList.append(value);
}
/**
* @return {*}
*/
pop() {
const removedTail = this.linkedList.deleteTail();
return removedTail ? removedTail.value : null;
}
/**
* @return {*[]}
*/
toArray() {
return this.linkedList
.toArray()
.map(linkedListNode => linkedListNode.value)
.reverse();
}
/**
* @param {function} [callback]
* @return {string}
*/
toString(callback) {
return this.linkedList.toString(callback);
}
}এবং উপরের উদাহরণগুলিতে স্ট্যাক এবং ক্যুয়ের জন্য ব্যবহৃত লিংকডলিস্ট বাস্তবায়ন এখানে গিটহাবের মধ্যে পাওয়া যেতে পারে ।
কোনও অ্যারে (গুলি) নেই
//Javascript stack linked list data structure (no array)
function node(value, noderef) {
this.value = value;
this.next = noderef;
}
function stack() {
this.push = function (value) {
this.next = this.first;
this.first = new node(value, this.next);
}
this.pop = function () {
var popvalue = this.first.value;
this.first = this.first.next;
return popvalue;
}
this.hasnext = function () {
return this.next != undefined;
}
this.isempty = function () {
return this.first == undefined;
}
}
//Javascript stack linked list data structure (no array)
function node(value, noderef) {
this.value = value;
this.next = undefined;
}
function queue() {
this.enqueue = function (value) {
this.oldlast = this.last;
this.last = new node(value);
if (this.isempty())
this.first = this.last;
else
this.oldlast.next = this.last;
}
this.dequeue = function () {
var queuvalue = this.first.value;
this.first = this.first.next;
return queuvalue;
}
this.hasnext = function () {
return this.first.next != undefined;
}
this.isempty = function () {
return this.first == undefined;
}
}জাভাস্ক্রিপ্টে নিয়মিত অ্যারে কাঠামো হ'ল একটি স্ট্যাক (প্রথমে শেষ, শেষ) এবং আপনি যে কলগুলি করেছেন তার উপর ভিত্তি করে একটি সারি (প্রথম প্রথম, প্রথম আউট) হিসাবেও ব্যবহার করা যেতে পারে।
কীভাবে ক্যারির মতো অ্যারেটি করা যায় তা দেখতে এই লিঙ্কটি দেখুন:
শুভেচ্ছা সহ,
জাভাস্ক্রিপ্টে স্ট্যাক এবং সারিগুলির প্রয়োগ নিম্নরূপ:
স্ট্যাক: স্ট্যাক হ'ল অবজেক্টের একটি ধারক যা সর্বশেষে প্রথম-আউট (লিফো) নীতি অনুসারে andোকানো হয় এবং সরিয়ে ফেলা হয়।
সারি: একটি সারি হ'ল বস্তুগুলির একটি ধারক (একটি লিনিয়ার সংগ্রহ) যা প্রথম-ইন-ফার্স্ট-আউট (ফিফো) নীতি অনুসারে .োকানো এবং সরানো হয়।
আনশিফ্ট: পদ্ধতিটি অ্যারের শুরুতে এক বা একাধিক উপাদান যুক্ত করে।
শিফট: পদ্ধতিটি অ্যারের থেকে প্রথম উপাদানটি সরিয়ে দেয়।
let stack = [];
stack.push(1);//[1]
stack.push(2);//[1,2]
stack.push(3);//[1,2,3]
console.log('It was inserted 1,2,3 in stack:', ...stack);
stack.pop(); //[1,2]
console.log('Item 3 was removed:', ...stack);
stack.pop(); //[1]
console.log('Item 2 was removed:', ...stack);
let queue = [];
queue.push(1);//[1]
queue.push(2);//[1,2]
queue.push(3);//[1,2,3]
console.log('It was inserted 1,2,3 in queue:', ...queue);
queue.shift();// [2,3]
console.log('Item 1 was removed:', ...queue);
queue.shift();// [3]
console.log('Item 2 was removed:', ...queue); var x = 10;
var y = 11;
var Queue = new Array();
Queue.unshift(x);
Queue.unshift(y);
console.log(Queue)
// Output [11, 10]
Queue.pop()
console.log(Queue)
// Output [11]আমার কাছে মনে হচ্ছে বিল্ট ইন অ্যারে স্ট্যাকের জন্য ভাল। আপনি যদি টাইপস্ক্রিপ্টে একটি সারি চান তা এখানে একটি বাস্তবায়ন
/**
* A Typescript implementation of a queue.
*/
export default class Queue {
private queue = [];
private offset = 0;
constructor(array = []) {
// Init the queue using the contents of the array
for (const item of array) {
this.enqueue(item);
}
}
/**
* @returns {number} the length of the queue.
*/
public getLength(): number {
return (this.queue.length - this.offset);
}
/**
* @returns {boolean} true if the queue is empty, and false otherwise.
*/
public isEmpty(): boolean {
return (this.queue.length === 0);
}
/**
* Enqueues the specified item.
*
* @param item - the item to enqueue
*/
public enqueue(item) {
this.queue.push(item);
}
/**
* Dequeues an item and returns it. If the queue is empty, the value
* {@code null} is returned.
*
* @returns {any}
*/
public dequeue(): any {
// if the queue is empty, return immediately
if (this.queue.length === 0) {
return null;
}
// store the item at the front of the queue
const item = this.queue[this.offset];
// increment the offset and remove the free space if necessary
if (++this.offset * 2 >= this.queue.length) {
this.queue = this.queue.slice(this.offset);
this.offset = 0;
}
// return the dequeued item
return item;
};
/**
* Returns the item at the front of the queue (without dequeuing it).
* If the queue is empty then {@code null} is returned.
*
* @returns {any}
*/
public peek(): any {
return (this.queue.length > 0 ? this.queue[this.offset] : null);
}
}এবং Jestএটির জন্য এখানে একটি পরীক্ষা
it('Queue', () => {
const queue = new Queue();
expect(queue.getLength()).toBe(0);
expect(queue.peek()).toBeNull();
expect(queue.dequeue()).toBeNull();
queue.enqueue(1);
expect(queue.getLength()).toBe(1);
queue.enqueue(2);
expect(queue.getLength()).toBe(2);
queue.enqueue(3);
expect(queue.getLength()).toBe(3);
expect(queue.peek()).toBe(1);
expect(queue.getLength()).toBe(3);
expect(queue.dequeue()).toBe(1);
expect(queue.getLength()).toBe(2);
expect(queue.peek()).toBe(2);
expect(queue.getLength()).toBe(2);
expect(queue.dequeue()).toBe(2);
expect(queue.getLength()).toBe(1);
expect(queue.peek()).toBe(3);
expect(queue.getLength()).toBe(1);
expect(queue.dequeue()).toBe(3);
expect(queue.getLength()).toBe(0);
expect(queue.peek()).toBeNull();
expect(queue.dequeue()).toBeNull();
});আশা করি কেউ এটি দরকারী খুঁজে পেয়েছেন,
চিয়ার্স,
স্টু
ক্লাসগুলির একটি জুড়ি তৈরি করুন যা এই প্রতিটি ডেটা স্ট্রাকচারের বিভিন্ন ধরণের পদ্ধতি সরবরাহ করে (ধাক্কা, পপ, পিক ইত্যাদি)। এখন পদ্ধতিগুলি বাস্তবায়ন করুন। যদি আপনি স্ট্যাক / সারির পিছনে ধারণাগুলির সাথে পরিচিত হন তবে এটি বেশ সহজবোধ্য হওয়া উচিত। আপনি অবশ্যই অ্যারে এবং একটি লিঙ্কযুক্ত তালিকার একটি সারি দিয়ে স্ট্যাকটি বাস্তবায়ন করতে পারেন, যদিও এটির অন্যান্য উপায় অবশ্যই রয়েছে। জাভাস্ক্রিপ্ট এটিকে সহজ করে দেবে, কারণ এটি দুর্বলভাবে টাইপ করা হয়েছে, তাই আপনার জেনেরিক ধরণের সম্পর্কেও চিন্তা করতে হবে না, যা আপনি জাভা বা সি # তে প্রয়োগ করে থাকলে আপনাকে করতে হবে।
এখানে আমার স্ট্যাকের বাস্তবায়ন।
function Stack() {
this.dataStore = [];
this.top = 0;
this.push = push;
this.pop = pop;
this.peek = peek;
this.clear = clear;
this.length = length;
}
function push(element) {
this.dataStore[this.top++] = element;
}
function peek() {
return this.dataStore[this.top-1];
}
function pop() {
return this.dataStore[--this.top];
}
function clear() {
this.top = 0;
}
function length() {
return this.top;
}
var s = new Stack();
s.push("David");
s.push("Raymond");
s.push("Bryan");
console.log("length: " + s.length());
console.log(s.peek());আপনি ES6 শ্রেণিতে ব্যক্তিগত সম্পত্তি বাস্তবায়নের জন্য এবং জাভাস্ক্রিপ্ট ভাষায় স্ট্রিং প্রপেসি এবং পদ্ধতিগুলির সুবিধাগুলির জন্য WeakMaps ব্যবহার করতে পারেন:
const _items = new WeakMap();
class Stack {
constructor() {
_items.set(this, []);
}
push(obj) {
_items.get(this).push(obj);
}
pop() {
const L = _items.get(this).length;
if(L===0)
throw new Error('Stack is empty');
return _items.get(this).pop();
}
peek() {
const items = _items.get(this);
if(items.length === 0)
throw new Error ('Stack is empty');
return items[items.length-1];
}
get count() {
return _items.get(this).length;
}
}
const stack = new Stack();
//now in console:
//stack.push('a')
//stack.push(1)
//stack.count => 2
//stack.peek() => 1
//stack.pop() => 1
//stack.pop() => "a"
//stack.count => 0
//stack.pop() => Error Stack is emptyদুটি স্ট্যাক ব্যবহার করে একটি সারি তৈরি করুন।
ও (1) উভয় তীরচিহ্ন এবং শিরোনাম ক্রিয়াকলাপের জন্য।
class Queue {
constructor() {
this.s1 = []; // in
this.s2 = []; // out
}
enqueue(val) {
this.s1.push(val);
}
dequeue() {
if (this.s2.length === 0) {
this._move();
}
return this.s2.pop(); // return undefined if empty
}
_move() {
while (this.s1.length) {
this.s2.push(this.s1.pop());
}
}
}