revising basic cconcepts

Author: piyushkhemka

234. Palindrome Linked List.cpp

@@ -0,0 +1,71 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+
+    ListNode* reverselist(ListNode *head, ListNode *end) {
+        if(!head || !head->next)
+            return head;
+
+        ListNode *cur = head;
+        ListNode *next = head;
+        ListNode *prev = nullptr;
+        ListNode *last = end->next;
+
+        while(cur && cur!=last) {
+            next = cur->next;
+            cur->next = prev;
+            prev = cur;
+            cur = next;
+        }
+
+        return prev;
+    }
+
+
+public:
+    bool isPalindrome(ListNode* head) {
+
+        if(!head || !head->next)
+            return true;
+
+        ListNode* slow = head;
+        ListNode* fast = head;
+        ListNode* prev = nullptr;
+        ListNode* right = nullptr;
+
+        while(fast && fast->next) {
+            prev = slow;
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+
+        if(!fast) { //even linked list
+            right = slow;
+            slow = prev;
+        }
+        else { // odd linked list
+            right = slow->next;
+            slow = prev;
+        }
+
+        reverselist(head, slow);
+
+        while(slow && right) {
+            if(slow->val != right->val)
+                return false;
+            slow = slow->next;
+            right = right->next;
+        }
+
+        if(slow || right)
+            return false;
+
+        return true;
+    }
+};

451. Sort Characters By Frequency.cpp

@@ -30,3 +30,35 @@ class Solution {
 
     }
 };
+
+
+----------
+
+class Solution {
+public:
+    string frequencySort(string s) {
+
+        unordered_map<char, int> m;
+        string res = "";
+
+        for(int i = 0;i<s.length(); ++i) {
+            m[s[i]]++;
+        }
+
+        vector<pair<char, int> > v;
+
+        for(auto i:m) {
+            v.push_back(make_pair(i.first, i.second));
+        }
+
+        sort(v.begin(), v.end(), [] (const pair<char, int> &i1, const pair<char, int> &i2) {return i1.second > i2.second;});
+
+        for(auto i: v) {
+            while(i.second--)
+                res += i.first;
+        }
+
+        return res;
+
+    }
+};

643. Maximum Average Subarray I.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    double findMaxAverage(vector<int>& nums, int k) {
+
+        deque<int> window;
+        double ans = INT_MIN;
+        double avg = 0.0;
+        int sum = 0;
+        for(auto i:nums) {
+
+            window.push_back(i);
+            sum+=i;
+
+            if(window.size() > k) {
+                sum -= window.front();
+                window.pop_front();
+            }
+
+            if(window.size() == k) {
+                avg = double(sum)/double(k);
+                ans = max(avg, ans);
+            }
+        }
+
+        return ans;
+
+    }
+};

9. Palindrome Number.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    bool isPalindrome(int x) {
+
+        if (x < 0 || (x!=0 && x%10 == 0))
+            return false;
+
+        int rev = 0;
+
+        while(x > rev) {
+            rev = 10*rev + x%10;
+            x = x/10;
+        }
+
+        return x == rev || x == rev/10;
+
+    }
+};