Merge pull request #6 from FreeTymeKiyan/xinyu-liu

C++/162_Find_Peak_Element.cpp

Author: xliu45

C++/081_Search in Rotated Sorted Array II.cpp

@@ -0,0 +1,79 @@
+//   Problem 81, Search in Rotated Sorted Array II
+
+//   Follow up for "Search in Rotated Sorted Array":
+//   What if duplicates are allowed?
+//   Would this affect the run-time complexity? How and why?
+//   Write a function to determine if a given target is in the array.
+//
+//   FYI: "Search in Rotated Sorted Array":
+//   Suppose a sorted array is rotated at some pivot unknown to you beforehand.
+//   (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
+//   You are given a target value to search. If found in the array return its index, otherwise return -1.
+//   You may assume no duplicate exists in the array.
+
+#include <stddef.h>
+#include <vector>
+#include <string.h>
+#include <stdio.h>
+#include <algorithm> 
+#include <iostream>
+#include <map>
+
+using namespace std;
+
+class Solution {
+public:
+    bool search(vector<int>& nums, int target) {
+        
+        int start = 0; 
+        int end = nums.size()-1;
+        
+        while(start <= end){
+            // skip the repeating numbers on both sides
+            while(start < end && nums[start] == nums[start + 1]) start++;
+            while(start < end && nums[end] == nums[end - 1]) end--;
+            
+            int mid = (start + end)/2;
+            if(nums[mid] == target) return true; // found
+            if(nums[mid] < target){
+                // for cases like {6 7 0 1 2 4 5} mid is 1, start is 6, end is 5, target is 2
+                // and cases like {2 4 5 6 7 0 1} mid is 6, start is 2, end is 1, target is 7
+                if(nums[start] > target || nums[mid] >= nums[start])
+                    start = mid + 1;
+                else
+                    end = mid - 1;
+            }
+            else{
+                // for cases like {4 5 6 7 0 1 2}, mid is 7, start is 4, end is 2, target is 5
+                // and cases like {6 7 0 1 2 4 5}, mid is 1, start is 6, end is 5, target is 0
+                if(nums[start] <= target || nums[mid] < nums[start])
+                    end = mid - 1;
+                else
+                    start = mid + 1;
+            }
+        }
+        return false;
+    }
+};
+int main()
+{
+	Solution* sol = new Solution();
+	vector<int> nums;
+	nums.push_back(4);
+	nums.push_back(5);
+	nums.push_back(6);
+	nums.push_back(7);
+	nums.push_back(0);
+	nums.push_back(1);
+	nums.push_back(2);
+
+	cout<<sol->search(nums,3)<<endl;
+	cout<<sol->search(nums,0)<<endl;
+	cout<<sol->search(nums,6)<<endl;
+	cout<<sol->search(nums,5)<<endl;
+	
+	char c;
+	cin>>c;
+
+	return 0;
+}

C/162_Find_Peak_Element.cpp

@@ -0,0 +1,52 @@
+/*
+A peak element is an element that is greater than its neighbors.
+Given an input array where num[i] ≠ num[i+1], find a peak element and return its index.
+The array may contain multiple peaks, in that case return the index to any one of the peaks is fine.
+You may imagine that num[-1] = num[n] = -∞.
+
+Example:
+in array [1, 2, 3, 1], 3 is a peak element and your function should return the index number 2.
+
+Tag: Array, Binary Search
+
+Author: Xinyu Liu
+*/
+
+#include <iostream>
+#include <vector>
+using namespace std;
+
+class Solution {
+
+public:
+    int findPeakElement(vector<int>& nums) {
+        int sz = nums.size();
+	if (sz == 1)
+	    return 0;
+	if (nums.at(0) > nums.at(1)) 
+	    return 0;
+	if (nums.at(sz-1) > nums.at(sz-2)) 
+	    return sz-1;
+
+	for(int i = 1; i < nums.size(); i++)
+	{
+	    if (nums.at(i-1) < nums.at(i) & nums.at(i) > nums.at(i+1))
+	        return i;
+	}
+	return -1;
+    }
+};
+
+void main(int argc, char ** argv){
+
+    // Initialize vector
+    int myints[] = {1,2,3,4,3};
+    int index;
+    std::vector<int> test (myints, myints + sizeof(myints) / sizeof(int) );
+
+    Solution sol;
+    index = sol.findPeakElement (test);
+
+    printf("%i \n",index);
+
+}