diff --git a/src/App.jsx b/src/App.jsx
index 48c315e..083227f 100644
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -1,16 +1,29 @@
 import Player from "./Player/Player";
 import "./Player/player.scss";
-import { songsdata } from "./Player/AudioData.js";
 import { useRef, useState, useEffect } from "react";
+import RedBlackTree from "./algorithms/red_black_tree.js";
+import { song_dll } from "./Player/AudioData.js";
+import { BsArrowsExpandVertical } from "react-icons/bs";
+
+// apil change start
 
 const App = () => {
-  const [songs, setSongs] = useState(songsdata);
+  //Inserting songsdata into redblack tree
+  const songsTree = new RedBlackTree();
+
+  songsdata.forEach((item) => {
+    songsTree.add(item.title, item.url);
+  });
+
+  const [songs, setSongs] = useState(song_dll);
+
   const [isplaying, setisplaying] = useState(false);
-  const [currentSong, setCurrentSong] = useState(songsdata[1]);
+  const [currentSong, setCurrentSong] = useState(window.current_song_ptr);
 
   const audioElem = useRef();
 
   useEffect(() => {
+    songs;
     if (isplaying) {
       audioElem.current.play();
     } else {
@@ -29,9 +42,20 @@ const App = () => {
     });
   };
 
+  //Returns new sorted list of songs object
+  const sortByTitle = (rb_tree) => {
+    const emptyList = [];
+    const sortedList = rb_tree.inOrderTraversal(rb_tree.root, emptyList);
+    return sortedList;
+  };
+
   return (
     <div className="center-content">
-      <audio src={currentSong.url} ref={audioElem} onTimeUpdate={onPlaying} />
+      <audio
+        src={currentSong.data.url}
+        ref={audioElem}
+        onTimeUpdate={onPlaying}
+      />
       <Player
         songs={songs}
         setSongs={setSongs}
diff --git a/src/Player/AudioData.js b/src/Player/AudioData.js
index 07530d6..d2163b1 100644
--- a/src/Player/AudioData.js
+++ b/src/Player/AudioData.js
@@ -1,22 +1,95 @@
+// apil change
+
+// import song1 from "../assets/music/02. Paul Flint - Savage.mp3";
+// import song3 from "../assets/music/03. Retrovision - Puzzle.mp3";
+// import song2 from "../assets/music/04. Syn Cole - Feel Good.mp3";
+
+// import fs from "fs";
+
+// const directoryPath = "../assets/music";
+
+// // Read the contents of the directory
+// const readDirectory = async (directoryPath) => {
+//   const file_array = await fs.readdir(directoryPath, (err, files) => {
+//     const array = [];
+//     if (err) {
+//       console.error("Error reading directory:", err);
+//       return;
+//     }
+
+//     files.forEach((file) => {
+//       array.push(file);
+//     });
+//     return array;
+//   });
+//   return file_array;
+// };
+
+// const data = setTimeout(() => readDirectory(directoryPath), 50);
+// console.log(data);
+
+// const songsdata = [
+//   {
+//     title: "Paul Flint - Savage",
+//     url: song1,
+//   },
+//   {
+//     title: "Retrovision - Puzzle",
+//     url: song2,
+//   },
+//   {
+//     title: "Syn Cole - Feel Good",
+//     url: song3,
+//   },
+// ];
+// export { songsdata };
+
+//apil change end
+
+import DoublyLinkedList from "../algorithms/dll";
 import song1 from "../assets/music/02. Paul Flint - Savage.mp3";
 import song3 from "../assets/music/03. Retrovision - Puzzle.mp3";
 import song2 from "../assets/music/04. Syn Cole - Feel Good.mp3";
+import RedBlackTree from "../algorithms/red_black_tree";
+// import { cursorTo } from "readline";
 
-const songsdata = [
-    {
-        "title": "Paul Flint - Savage",
-        "url": song1
-    },
-    {
-        "title": "Retrovision - Puzzle",
-        "url": song2
-    },
-    {
-        "title": "Syn Cole - Feel Good",
-        "url": song3
-    }
-]
-export { songsdata };
+class song_node {
+  constructor() {
+    this.title = null;
+    this.url = null;
+  }
+}
+
+const s1 = new song_node();
+const s3 = new song_node();
+const s2 = new song_node();
+
+s1.title = "Paul Flint - Savage";
+s1.url = song1;
+
+s2.title = "Syn Cole - Feel Good";
+s2.url = song2;
+
+s3.title = "Retrovision - Puzzle";
+s3.url = song3;
+
+const song_dll = new DoublyLinkedList();
+song_dll.pushBack(s1);
+song_dll.pushBack(s2);
+song_dll.pushBack(s3);
+
+const songTree = new RedBlackTree();
+let cur_ptr = song_dll.head;
+while (cur_ptr != null) {
+  songTree.add(cur_ptr.data.title, cur_ptr.data);
+  cur_ptr = cur_ptr.next;
+}
+
+const sortedList = songTree.inOrderTraversal(songTree.root);
+console.log(sortedList);
+
+window.current_song_ptr = song_dll.head;
+export { song_dll, songTree, sortedList, song_node };
 
 //Better Data
 // let savage = {
@@ -283,4 +356,4 @@ export { songsdata };
 //     audio: null,
 //     isFav: null,
 //     duration: 161,
-//   };
\ No newline at end of file
+//   };
diff --git a/src/Player/Player.jsx b/src/Player/Player.jsx
index fa12ec7..a96e7ab 100644
--- a/src/Player/Player.jsx
+++ b/src/Player/Player.jsx
@@ -1,85 +1,85 @@
-import  { useRef } from 'react';
-import './player.scss';
-import {BsFillPlayCircleFill, BsFillPauseCircleFill, BsFillSkipStartCircleFill, BsFillSkipEndCircleFill} from 'react-icons/bs';
-
-const Player = ({audioElem, isPlaying, setIsPlaying, currentSong, setCurrentSong, songs})=> {
-
+import { useRef } from "react";
+import "./player.scss";
+import {
+  BsFillPlayCircleFill,
+  BsFillPauseCircleFill,
+  BsFillSkipStartCircleFill,
+  BsFillSkipEndCircleFill,
+} from "react-icons/bs";
+const Player = ({
+  audioElem,
+  isPlaying,
+  setIsPlaying,
+  currentSong,
+  setCurrentSong,
+ 
+}) => {
   const clickRef = useRef();
 
-  const PlayPause = ()=>
-  {
+  const PlayPause = () => {
     setIsPlaying(!isPlaying);
+  };
 
-  }
-
-
-  const checkWidth = (e)=>
-  {
+  const checkWidth = (e) => {
     let width = clickRef.current.clientWidth;
     const offset = e.nativeEvent.offsetX;
 
-    const divprogress = offset / width * 100;
-    audioElem.current.currentTime = divprogress / 100 * currentSong.length;
+    const divprogress = (offset / width) * 100;
+    audioElem.current.currentTime = (divprogress / 100) * currentSong.length;
+  };
 
-  }
+  const skipBack = () => {
 
-  const skipBack = ()=>
-  {
-    const index = songs.findIndex(x=>x.title == currentSong.title);
-    if (index == 0)
-    {
-      setCurrentSong(songs[songs.length - 1])
-    }
-    else
-    {
-      setCurrentSong(songs[index - 1])
+    if (window.current_song_ptr.prev !== null) {
+      window.current_song_ptr = window.current_song_ptr.prev;
+      setCurrentSong(window.current_song_ptr);
     }
-    audioElem.current.currentTime = 0;
-    
-  }
 
 
-  const skiptoNext = ()=>
-  {
-    const index = songs.findIndex(x=>x.title == currentSong.title);
+    audioElem.current.currentTime = 0;
+  };
 
-    if (index == songs.length-1)
-    {
-      setCurrentSong(songs[0])
-    }
-    else
-    {
-      setCurrentSong(songs[index + 1])
+  const skiptoNext = () => {
+    if (window.current_song_ptr.next !== null) {
+      window.current_song_ptr = window.current_song_ptr.next;
+      setCurrentSong(window.current_song_ptr);
     }
+
     audioElem.current.currentTime = 0;
-    
-  }
+  };
 
   return (
-    <div className='player_container'>
+    <div className="player_container">
       <div className="title">
         <p>{currentSong.title}</p>
       </div>
       <div className="navigation">
         <div className="navigation_wrapper" onClick={checkWidth} ref={clickRef}>
-          <div className="seek_bar" style={{width: `${currentSong.progress+"%"}`}}></div>
+          <div
+            className="seek_bar"
+            style={{ width: `${currentSong.progress + "%"}` }}
+          ></div>
         </div>
       </div>
       <div className="controls">
-        <BsFillSkipStartCircleFill className='btn_action' onClick={skipBack}/>
-        {isPlaying ? <BsFillPauseCircleFill className='btn_action pp' onClick={PlayPause}/> : <BsFillPlayCircleFill className='btn_action pp' onClick={PlayPause}/>}
-        <BsFillSkipEndCircleFill className='btn_action' onClick={skiptoNext}/>        
+        <BsFillSkipStartCircleFill className="btn_action" onClick={skipBack} />
+        {isPlaying ? (
+          <BsFillPauseCircleFill
+            className="btn_action pp"
+            onClick={PlayPause}
+          />
+        ) : (
+          <BsFillPlayCircleFill className="btn_action pp" onClick={PlayPause} />
+        )}
+        <BsFillSkipEndCircleFill className="btn_action" onClick={skiptoNext} />
       </div>
     </div>
-  
-  )
-}
-
-export default Player
-
-import PropTypes from 'prop-types';
+  );
+};
 
+export default Player;
 
+import PropTypes from "prop-types";
 
 Player.propTypes = {
   audioElem: PropTypes.object, // or other appropriate PropType
@@ -87,5 +87,4 @@ Player.propTypes = {
   setIsPlaying: PropTypes.func,
   currentSong: PropTypes.object,
   setCurrentSong: PropTypes.func,
-  songs: PropTypes.array
-};
\ No newline at end of file
+};
diff --git a/src/algorithms/.gitkeep b/src/algorithms/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/src/algorithms/dll.js b/src/algorithms/dll.js
new file mode 100644
index 0000000..9a71ebc
--- /dev/null
+++ b/src/algorithms/dll.js
@@ -0,0 +1,118 @@
+class Node {
+  constructor(data) {
+    this.data = data;
+    this.prev = null;
+    this.next = null;
+  }
+}
+
+class DoublyLinkedList {
+  constructor() {
+    this.head = null;
+    this.tail = null;
+    this.size = 0;
+  }
+
+  isEmpty() {
+    return this.size === 0;
+  }
+
+  back() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    return this.tail.data;
+  }
+
+  front() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    return this.head.data;
+  }
+
+  pushBack(data) {
+    const newNode = new Node(data);
+    if (this.isEmpty()) {
+      this.head = newNode;
+      this.tail = newNode;
+    } else {
+      this.tail.next = newNode;
+      newNode.prev = this.tail;
+      this.tail = newNode;
+    }
+    this.size++;
+  }
+
+  pushFront(data) {
+    const newNode = new Node(data);
+    if (this.isEmpty()) {
+      this.head = newNode;
+      this.tail = newNode;
+    } else {
+      newNode.next = this.head;
+      this.head.prev = newNode;
+      this.head = newNode;
+    }
+    this.size++;
+  }
+
+  popBack() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    const removedData = this.tail.data;
+    if (this.size === 1) {
+      this.head = null;
+      this.tail = null;
+    } else {
+      this.tail = this.tail.prev;
+      this.tail.next = null;
+    }
+    this.size--;
+    return removedData;
+  }
+
+  popFront() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    const removedData = this.head.data;
+    if (this.size === 1) {
+      this.head = null;
+      this.tail = null;
+    } else {
+      this.head = this.head.next;
+      this.head.prev = null;
+    }
+    this.size--;
+    return removedData;
+  }
+
+ display() {
+    let current = this.head;
+    while (current) {
+      console.log(current.data);
+      current = current.next;
+    }
+  }
+}
+
+export default DoublyLinkedList;
+// Example usage:
+const dll = new DoublyLinkedList();
+dll.pushBack(1);
+dll.pushBack("anup");
+dll.pushBack(3);
+// dll.display(); // Output: 1 anup 3
+var ptr = dll.head;
+ptr= ptr.next;
+ptr = ptr.prev;
+console.log(ptr.data);
+
+// console.log(dll.tail.prev.prev.data);
+
+
+
+
+
diff --git a/src/algorithms/red_black_tree.js b/src/algorithms/red_black_tree.js
new file mode 100644
index 0000000..c6a466f
--- /dev/null
+++ b/src/algorithms/red_black_tree.js
@@ -0,0 +1,241 @@
+class RBT_Node {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+    this.left = null;
+    this.right = null;
+    this.parent = null;
+    this.black = false;
+    this.isLeftChild = false;
+  }
+}
+
+//balanced binary search tree uses color labels of node for rebalancing
+class RedBlackTree {
+  constructor() {
+    this.root = null;
+    this.height = 0;
+    this.size = 0;
+  }
+
+  add(key, value) {
+    const node = new RBT_Node(key, value);
+    if (this.root == null) {
+      this.root = node;
+      this.root.black = true;
+      this.size++;
+      return;
+    }
+    this.insert(this.root, node);
+    this.size++;
+  }
+
+  insert(parent, newNode) {
+    if (this.isNewnodeKeyGreater(newNode, parent)) {
+      if (parent.right == null) {
+        parent.right = newNode;
+        newNode.parent = parent;
+        newNode.isLeftChild = false;
+      } else {
+        this.insert(parent.right, newNode);
+      }
+    } else {
+      if (parent.left == null) {
+        parent.left = newNode;
+        newNode.parent = parent;
+        newNode.isLeftChild = true;
+      } else {
+        this.insert(parent.left, newNode);
+      }
+    }
+    this.checkColor(newNode);
+    return;
+  }
+
+  //checks for if two consecutive trees are red
+  checkColor(node) {
+    if (node == this.root) {
+      node.black = true;
+      return;
+    }
+    if (!node) {
+      if (!node.parent) {
+        if (!node.black && !node.parent.black) {
+          this.correctTree(node);
+        }
+        this.checkColor(node.parent);
+      }
+    }
+  }
+
+  //corrects tree
+  correctTree(node) {
+    if (node.parent.isLeftChild) {
+      //aunt is grandparent's irght
+      if (node.parent.parent.right == null || node.parent.parent.right.black) {
+        //rotation
+        this.rotate(node);
+        return;
+      }
+      if (node.parent.parent.right != null) {
+        node.parent.parent.right.black = true;
+      }
+      node.parent.parent.black = false;
+      node.parent.black = true;
+      return;
+    }
+
+    //aunt is grandparent's left i.e. parent is rightChild of node
+    if (node.parent.parent.left == null || node.parent.parent.left.black) {
+      //rotation
+      this.rotate(node);
+      return;
+    }
+    if (node.parent.parent.left != null) {
+      node.parent.parent.left.black = true;
+    }
+    node.parent.parent.black = false;
+    node.parent.black = true;
+    return;
+  }
+
+  //interface for calling which type of rotation
+  rotate(node) {
+    if (node.isLeftChild) {
+      if (node.parent.isLeftChild) {
+        //actual rotation is done with respect to grandparent
+        this.rightRotate(node.parent.parent);
+        node.parent.black = true;
+        node.black = false;
+        //set sibling red
+        if (node.parent.right != null) {
+          node.parent.right.black = true;
+        }
+        return;
+      }
+      //is node is left but node's parent is right child
+      this.rightLeftRotate(node.parent.parent);
+      node.black = true;
+      node.right.black = false;
+      node.left.black = false;
+      return;
+    }
+    //node and node's parent both are right child
+    if (!node.parent.isLeftChild) {
+      this.leftRotate(node.parent.parent);
+      node.black = false;
+      node.parent.black = true;
+      if (node.parent.left != null) {
+        node.parent.left.black = false;
+      }
+      return;
+    }
+    this.leftRightRotate(node.parent.parent);
+    node.black = true;
+    node.right.black = false;
+    node.left.black = false;
+    return;
+  }
+
+  //grandparent node passed of node which disturbed balance
+  leftRotate(node) {
+    //RR heavy tree
+    const temp = node.right;
+    node.right = temp.left;
+    if (node.right != null) {
+      node.right.parent = node;
+      node.right.isLeftChild = false;
+    }
+    if (node.parent == null) {
+      this.root = temp;
+      temp.parent = null;
+    } else {
+      temp.parent = node.parent;
+      if (node.isLeftChild) {
+        temp.isLeftChild = true;
+        node.parent.left = temp;
+      } else {
+        temp.isLeftChild = false;
+        node.parent.right = temp;
+      }
+    }
+    temp.left = node;
+    temp.isLeftChild = true;
+    node.parent = temp;
+  }
+
+  rightRotate(node) {
+    const temp = node.left;
+    node.left = temp.right;
+    if (node.left != null) {
+      node.left.parent = node;
+      node.left.isLeftChild = true;
+    }
+    if (node.parent == null) {
+      this.root = temp;
+      temp.parent = null;
+    } else {
+      temp.parent = node.parent;
+      if (node.isLeftChild) {
+        temp.isLeftChild = true;
+        node.parent.left = temp;
+      } else {
+        temp.isLeftChild = false;
+        node.parent.right = temp;
+      }
+    }
+    temp.right = node;
+    node.isLeftChild = false;
+    node.parent = temp;
+  }
+
+  leftRightRotate(node) {
+    this.leftRotate(node.left);
+    this.rightRotate(node);
+  }
+
+  rightLeftRotate(node) {
+    this.rightRotate(node.right);
+    this.leftRotate(node);
+  }
+
+  isNewnodeKeyGreater(newNode, parent) {
+    return newNode.key > parent.key;
+  }
+
+  inOrderTraversal(node, sortedArray = []) {
+    if (node == null) {
+      return;
+    }
+    this.inOrderTraversal(node.left, sortedArray);
+    sortedArray.push(node.value);
+    this.inOrderTraversal(node.right, sortedArray);
+    return sortedArray;
+  }
+
+  reverseOrderTraversal(node, sortedArray = []) {
+    if (node == null) {
+      return;
+    }
+    this.inOrderTraversal(node.right, sortedArray);
+    sortedArray.push(node.value);
+    this.inOrderTraversal(node.left, sortedArray);
+    return sortedArray;
+  }
+}
+
+export default RedBlackTree;
+
+//Implementation example
+
+// const tree = new RedBlackTree();
+// tree.add("apil", 10);
+// tree.add("bily", 5);
+// tree.add("anup", 1);
+// tree.add("kshitiz", 40);
+// tree.add("aang", 2);
+// tree.add("zing", 6);
+// tree.add("zong", 23);
+// tree.ascendingOrder();
+// console.log(" ");
+// tree.descendingOrder();