SqList

1. DelMin

int DelMin(SqList &L){
   
    if(!L.length){
   
        cout << "Error!" << endl;
        exit(0);
    }
    int min = L.data[0], loc = 0;
    for(int i = 1; i < L.length; i++){
   
        if(L.data[i] < min){
   
            loc = i;
            min = L.data[i];
        }
    }
    for(int j = loc + 1; j < L.length; j++)
        L.data[j - 1] = L.data[j];

    L.length--;
    return min;
}

2. Reverse

void Reverse(SqList &L){
   
    for(int i = 0 i < L.length / 2; i++)
        swap(L.data[i], L.data[L.length - 1 - i]);
}

3. Del_X_O1_S1

void Del_X_O1_S1(SqList &L, int x){
       //O(n), S(1)
    int k = 0;
    for(int i = 0; i < L.length; i++){
   
        if(L.data[i] != x)
            L.data[k++] = L.data[i];
    }
    L.length = k;
}

4. Del_s2t_open_domain_Sorted

bool Del_s2t_open_domain_Sorted(SqList &L, int s, int t){
   
    if(!L.length || s >= t)    return false;
    int left, right;
    for(left = 0; left < L.length && L.data[left] < s; left++);
    if(left == L.length)    return false;
    for(right = 0; right < L.length && L.data[right] <= t; right++);
    for(; j < L.length; i++, j++)
        L.data[i] = L.data[j];
    L.length = i;
    return true;
}

5. Del_s2t_close_domain

void DelIndex(SqList &L, int index){
   
    if(!L.length || index < 0 || index >= L.length)    return;
    for(int i = index + 1; i < L.length; i++)
        L.data[i - 1] = L.data[i];
    L.length--;
}
void Del_s2t_close_domain(SqList &L, int s, int t){
   
    if(!L.length || s >= t){
   
        cout << "Error!" << endl;
        exit(0);
    }
    for(int i = 0; i < L.length; i++)
        if(L.data[i] >= s && L.data[i] <= t)
            DelIndex(L, i--);
}

better

bool Del_s2t_close_domain(SqList &L, int s, int t){
   
    int k = 0;
    if(!L.length || s >= t)    return false;
    for(int i = 0; i < L.length; i++){
   
        if(L.data[i] >= s && L.data[i] <= t){
   
            k++;
        else
            L.data[i - k] = L.data[i];
    }
    L.length -= k;
    return true;
}

6. MakeSortedArrayElemUnique

void DelIndex(SqList &L, int index){
   
    if(!L.length || index >= L.length || index < 0)    return;
    for(int i = index + 1; i < L.length; i++)
        L.data[i - 1] = L.data[i];
    L.length--;
}
void MakeSortedArrayElemUnique(SqList &L){
   
    if(L.length <= 1)   return;
    for(int i = 0; i < L.length; i++){
   
        for(int j = i + 1; j < L.length; j++){
   
            if(L.data[j] == L.data[i])
                DelIndex(L, j--);
        }
    }
}

better

bool MakeSortedArrayElemUnique(SqList &L) {
   
	if (L.length <= 1)
		return false;
	int i = 0, j = 1;
	for(; j < L.length; j++)
		if(L.data[i] != L.data[j])
			L.data[++i] = L.data[j];
	L.length = 1 + i;
	return true;
}

7. Merge2SortedSqList

SqList Merge2SortedSqList(const SqList &L1, const SqList &L2){
   
    SqList ret;
    int index_ret = 0, index1 = 0, index2= 0;

    while(index1 < L1.length && index2 < L2.length)
        ret.data[index_ret++] = ((L1.data[index1] < L2.data[index2]) ? L1.data[index1++] : L2.data[index2++]);

    while(index1 < L1.length)
        ret.data[index_ret++] = L1.data[index1++];

    while(index2 < L1.length)
        ret.data[index_ret++] = L2.data[index2++];

    ret.length = index_ret;
    return ret;
}

8. ExchangeTwoSqListStoredInOneArray

void ReverseOneArray(int A[], int left, int right) {
   
	if (left >= right)
		return;
	for (int i = left; i <= (left + right) / 2; i++)
		swap(A[i], A[right - (i - left)]);
}
void ExchangeTwoSqListStoredInOneArray(int A[], int m, int n){
     //m + n = A.length
    ReverseOneArray(A, 0, m - 1);
    ReverseOneArray(A, m, m + n - 1);
    ReverseOneArray(A, 0, m + n - 1);
}

9.FindXOrInsert(SqList &L, int x)

bool FindXOrInsert(SqList &L, int x) {
   
	if (!L.length) {
   
		L.data[++L.length] = x;
		return true;
	}
	int l = 0, r = L.length - 1;
	int mid;
	while (l <= r) {
   
		mid = (l + r) / 2;
		if (L.data[mid] < x)
			l = mid + 1;
		else if (L.data[mid] > x)
			r = mid - 1;
		else {
   
			if (mid != L.length - 1)
				swap(L.data[mid], L.data[mid + 1]);
			return true;
		}
	}
	for (int i = L.length - 1; i >= l; i--) //If not find, l and mid will be the starting place to shift elements
		L.data[i + 1] = L.data[i];
	L.data[l] = x;
	L.length++;
	return false;
}

10. RecursiveLeftShiftP(SqList &L, int p)

void Reverse(SqList &L, int left, int right){
   
	if(left >= right)  return;
	for(int i = left; i <= (left + right) / 2; i++)
		swap(L.data[i], L.data[right - (i - left)]);
}
void RecursiveLeftShiftP(SqList &L, int p){
   
	p = p % L.length;
	Reverse(L, 0, L.length - 1);
	Reverse(L, 0, L.length - p - 1);
	Reverse(L, L.length - p, L.length - 1);
}

11. findMedianSortedArrays(const SqList &L1, const SqList &L2)

int findKth(const SqList &L1, size_t start1, const SqList &L2, size_t start2, int k){
   
    if(start1 >= L1.length)    return L2.data[start2 + k - 1];
    if(start2 >= L2.length)    return L1.data[start1 + k - 1];
    if(k == 1)    return min(L1.data[start1], L2.data[start2]);
    int half1 = (start1 + k / 2 - 1) < L1.length ? L1.data[start1 + k / 2 - 1] : INT_MAX;.
    int half2 = (start2 + k / 2 - 1) < L1.length ? L2.data[start2 + k / 2 - 1] : INT_MAX;
    return half1 < half2 ? findKth(L1, start1 + k / 2, L2, start2, k - k / 2) : findKth(L1, start1, L2, start2 + k / 2, k - k / 2);
}
double findMedianSortedArrays(const SqList &L1, const SqList &L2){
   
    size_t len1 = L1.length, len2 = L2.length;
    int left = (len1 + len2 + 1) / 2;
    int right = (len1 + len2 + 2) / 2;
    return (findKth(L1, 0, L2, 0, left) + findKth(L1, 0, L2, 0, right)) / 2.0;
}

12. GetMainElem(const SqList &L)// LintCode ACed

int GetMainElem(const SqList &L) {
   
	int score = 0;
	int curMainElem = L.data[0];
	for (int i = 0; i < L.length; i++) {
   
		if (L.data[i] != curMainElem) {
   
			score--;
			if (score < 0) {
   
				curMainElem = L.data[i];
				score = 0;
			}
		}
        else{
   
			score++;
        }
	}
    score = 0;
	for(int i = 0; i < L.length; i++){
   
		if(L.data[i] == curMainElem)
			score++;
	}
	return (score > L.length / 2) ? curMainElem : -1;
}

13. FindMinIntNotAppear(const SqList &L)

int FindMinIntNotAppear(const SqList &L, int n) {
   
	bool *Appeared = new bool[n]();
	if (!Appeared)
		exit(0);
	for (int i = 0; i < n; i++) {
   
		if (L.data[i] > 0)
			Appeared[L.data[i] - 1] = true;
	}
	int sln = n;
	for (int i = 0; i < n; i++){
   
		if (!Appeared[i]) {
   
			sln = i + 1;
			break;
		}
    }
	delete[]Appeared;
	Appeared = nullptr;
	return (sln == n) ? (n + 1) : sln;
}