DSA をマスターするための注意事項:

マスター DSA は、S/W Ers に提供される高額給与の「資格」を獲得します。
DSA はソフトウェア エンジニアリングの主要部分です。
コードを記述する前に、全体像を理解し、詳細を掘り下げてください。
概念を視覚的に理解し、DSA は言語に依存しないため、それらの概念を任意の I/G 経由でコードに変換することがすべてです。
今後のコンセプトはすべて、何らかの形で以前のコンセプトとリンクしています。したがって、練習してコンセプトを徹底的にマスターするまでは、トピックを飛び越えたり、先に進んだりしないでください。
概念を視覚的に学ぶと、内容をより深く理解できるようになり、その結果、知識を長期間保持することができます。
これらのアドバイスに従えば、失うものは何もありません。

Linear DS:
Arrays
LinkedList(LL) & Doubly LL (DLL)
Stack
Queue & Circular Queue

Non-linear DS:
Trees
Graphs

ビッグオー表記

アルゴのパフォーマンス比較には、この表記法を理解することが不可欠です。
これは、アルゴの効率を比較するための数学的な方法です。

時間計算量

コードの実行速度が速くなるほど、速度は低くなります
V. ほとんどのインタビューに同意します。

空間の複雑さ

ストレージコストが低いため、時間の複雑さに比べてほとんど考慮されません。
面接官がこの点からも質問する可能性があるため、理解する必要があります。

3 つのギリシャ文字:

1. オメガ
2. シータ
3. オミクロン、つまりビッグオー [最も頻繁に見られる]

アルゴリズムの事例

1. 最良のケース [オメガを使用して表現]
2. 平均ケース [Theta を使用して表現]
3. 最悪のケース [Omicron を使用して表される]

技術的には、平均的なケース Big-O に匹敵する最良のケースはありません。それぞれオメガとシータを使用して表されます。
私たちは常に最悪のケースを測定しています。

## O(n): Efficient Code
Proportional
Its simplified by dropping the constant values.
An operation happens 'n' times, where n is passed as an argument as shown below.
Always going to be a straight line having slope 1, as no of operations is proportional to n.
X axis - value of n.
Y axis - no of operations 

// O(n)
function printItems(n){
  for(let i=1; i





## O(n^2):
Nested loops.
No of items which are output in this case are n*n for a 'n' input.
function printItems(n){
  for(let i=0; i





## O(n^3):
No of items which are output in this case are n*n*n for a 'n' input.
// O(n*n*n)
function printItems(n){
  for(let i=0; i O(n*n)


## Drop non-dominants:
function xxx(){
  // O(n*n)
  Nested for loop

  // O(n)
  Single for loop
}
Complexity for the below code will O(n*n)   O(n) 
By dropping non-dominants, it will become O(n*n) 
As O(n) will be negligible as the n value grows. O(n*n) is dominant term, O(n) is non-dominnat term here.






## O(1):
Referred as Constant time i.e No of operations do not change as 'n' changes.
Single operation irrespective of no of operands.
MOST EFFICIENT. Nothing is more efficient than this. 
Its a flat line overlapping x-axis on graph.


// O(1)
function printItems(n){
  return n n n n;
}
printItems(3);


## Comparison of Time Complexity:
O(1) > O(n) > O(n*n)






## O(log n)
Divide and conquer technique.
Partitioning into halves until goal is achieved.

log(base2) of 8 = 3 i.e we are basically saying 2 to what power is 8. That power denotes the no of operations to get to the result.

Also, to put it in another way we can say how many times we need to divide 8 into halves(this makes base 2 for logarithmic operation) to get to the single resulting target item which is 3.

Ex. Amazing application is say for a 1,000,000,000 array size, how many times we need to cut to get to the target item.
log(base 2) 1,000,000,000 = 31 times
i.e 2^31 will make us reach the target item.

Hence, if we do the search in linear fashion then we need to scan for billion items in the array.
But if we use divide & conquer approach, we can find it in just 31 steps.
This is the immense power of O(log n)

## Comparison of Time Complexity:
O(1) > O(log n) > O(n) > O(n*n)
Best is O(1) or O(log n)
Acceptable is O(n)






O(n log n) : 
Used in some sorting Algos.
Most efficient sorting algo we can make unless we are sorting only nums.






Tricky Interview Ques: Different Terms for Inputs.
function printItems(a,b){
  // O(a)
  for(let i=0; i





## Arrays
No reindexing is required in arrays for push-pop operations. Hence both are O(1).
Adding-Removing from end in array is O(1)

Reindexing is required in arrays for shift-unshift operations. Hence, both are O(n) operations, where n is no of items in the array.
Adding-Removing from front in array is O(n)

Inserting anywhere in array except start and end positions:
myArr.splice(indexForOperation, itemsToBeRemoved, ContentTobeInsterted)
Remaining array after the items has to be reindexed.
Hence, it will be O(n) and not O(0.5 n) as Big-O always meassures worst case, and not avg case. 0.5 is constant, hence its droppped.
Same is applicable for removing an item from an array also as the items after it has to be reindexed.


Finding an item in an array:
if its by value: O(n)
if its by index: O(1)

Select a DS based on the use-case.
For index based, array will be a great choice.
If a lot of insertion-deletion is perform in the begin, then use some other DS as reindexing will make it slow.





  
  
  n=100 の時間計算量の比較:


O(1) = 1

O(log 100) = 7

O(100) = 100

O(n^2) = 10,000


  
  
  n=1000 の時間計算量の比較:


O(1) = 1

O(log 1000) = ~10

O(1000) = 1000

O(1000*1000) = 1,000,000

主に次の 4 つに焦点を当てます:

Big O(n*n): ネストされたループ

Big O(n): 比例

Big O(log n): 分割統治

Big O(1): 定数

O(n!) は通常、意図的に悪いコードを書いたときに発生します。

O(n*n) はひどいアルゴリズムです

O(n log n) は許容され、特定の並べ替えアルゴリズムで使用されます

O(n) : 許容可能

O(log n), O(1) : ベスト

空間の複雑さはすべての DS、つまり O(n) でほぼ同じです。 

空間複雑度は、ソート アルゴリズム 
 を使用すると、O(n) から O(log n) または O(1) まで変化します。

時間計算量はアルゴリズムによって異なります

文字列などの数値以外のソートの最適な時間計算量は、Quick、Merge、Time、Heap ソートでは O(n log n) です。


  
  
  学んだことを応用する最善の方法は、できるだけ多くのコードを作成することです。


各 DS の長所と短所に基づいて、どの問題ステートメントでどの DS を選択するかを選択します。

詳細については、bigocheatsheet.com
を参照してください。