算法题——数组

1.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

思路1：所有非零数字，从0给数组赋值（双指针）。时间复杂度O(n)，空间复杂度O(1)。

void moveZeroes(int* nums, int numsSize){
    int k=0;//第一个零数字下标
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]!=0)
        {
            nums[k]=nums[i];
            k++;
        }        
    }
    for(;k<numsSize;k++)
    {
        nums[k]=0;
    }
}

思路2（优化）：把前面的0，交换到后面。时间复杂度O(n)，空间复杂度O(1)。

void moveZeroes(int* nums, int numsSize){
    for(int k=0,i=0;i<numsSize;i++)
    {
        if(nums[i]!=0)
        {
            //swap(nums[k++],nums[i]);
            int  temp=nums[k];
            nums[k++]=nums[i];
            nums[i]=temp;
        }        
    }
}

2.颜色分类

数组中只有0、1、2三个值的整数。原地对它们进行排序，使得相同数值的元素相邻，并按照0、1、2顺序排列。

思路1：执行两个for循环，一个数，一个写。时间复杂度O(n)，空间复杂度O(1)。

void sortColors(int* nums, int numsSize){
    int a=0,b=0;//a-0,b-1
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]==0) a++;
        if(nums[i]==1) b++;
    }
    for(int i=0;i<numsSize;i++)
    {
        if(a!=0)
        {
            nums[i]=0;a--;continue;
        }
        if(b!=0)
        {
            nums[i]=1;b--;continue;
        }
        nums[i]=2;
    }
}

思路2（优化）：仅使用常数空间的一趟扫描算法。i从前向后遍历，p1指向0，p2指向2。i扫描到2与p2交换，p2–；i扫描到0与p1交换，p1++；i。

void sortColors(int* nums, int numsSize){
    int p1=0,p2=numsSize-1,i=0;
    while(i<=p2)
    {
        if(nums[i]==0)
        {
            //swap(nums[p1++],nums[i++]);
            int temp=nums[i];
            nums[i++]=nums[p1];
            nums[p1++]=temp;//扫描到0，i后移，因为i一定指向比0大的数
        }
        else if(nums[i]==2)
        {
            //swap(nums[p2--],nums[i]);
            int temp=nums[i];
            nums[i]=nums[p2];
            nums[p2--]=temp;//注意，扫描到2，i不后移，因为可能i指向了0
        }
        else
        {i++;}
    }
}

3. 数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。

思路一：先使用排序算法，数组从大到小排序。在输出a[k-1]。
（1）冒泡排序

int findKthLargest(int* nums, int numsSize, int k){
    for(int i=0;i<numsSize;i++)
    {
        for(int j=numsSize-1;j>i;j--)
        {
            if(nums[j-1]<nums[j])
            {
                int temp=nums[j-1];
                nums[j-1]=nums[j];
                nums[j]=temp;
            }
        }
    }
    return nums[k-1];
}

（2）快速排序

void quickSort(int *arr,int begin,int end)
{
	if(begin>=end)//!!!!!这一句不可以删除
		return;
	//第一个数为基准
	int temp=arr[begin];
	int i=begin,j=end;
	while(i<j)
	{
		while(i<j&&arr[j]>temp)
			j--;
		arr[i]=arr[j];
		while(i<j&&arr[i]<=temp)
			i++;
		arr[j]=arr[i];
	}
	//基准元素入位
	arr[i]=temp;
	quickSort(arr,begin,i-1);
	quickSort(arr,i+1,end);
	return;
}

int findKthLargest(int* nums, int numsSize, int k){
    quickSort(nums,0,numsSize-1);
    return nums[numsSize-k];
}

思路二：基于堆排序的选择方法。建立一个大根堆，做k-1次删除，堆顶即为答案。

堆的操作

1. 建堆
2. 调整
3. 删除

void maxHeapify(int* a, int i, int heapSize) {
    int l = i * 2 + 1, r = i * 2 + 2, largest = i;
    if (l < heapSize && a[l] > a[largest]) {
        largest = l;
    }
    if (r < heapSize && a[r] > a[largest]) {
        largest = r;
    }
    if (largest != i) {
        int t = a[i];
        a[i] = a[largest], a[largest] = t;
        maxHeapify(a, largest, heapSize);
    }
}

void buildMaxHeap(int* a, int heapSize) {
    for (int i = heapSize / 2; i >= 0; --i) {
        maxHeapify(a, i, heapSize);
    }
}

int findKthLargest(int* nums, int numsSize, int k) {
    int heapSize = numsSize;
    buildMaxHeap(nums, heapSize);
    for (int i = numsSize - 1; i >= numsSize - k + 1; --i) {
        int t = nums[0];
        nums[0] = nums[i], nums[i] = t;
        --heapSize;
        maxHeapify(nums, 0, heapSize);
    }
    return nums[0];
}

4.两数之和 II - 输入有序数组

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

思路一、二分查找法。时间复杂度：O(nlogn)，空间复杂度：O(1)。

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        //遍历法，选第一个数
        for(int i=0;i<numbers.size();i++)
        {
            //二分查找法，，选第二个数。目标在(i+1,numbers.size()-1),找target-numbers[i]
            int low=i+1,high=numbers.size()-1;
            while(low<=high)
            {
                int mid=(high-low)/2+low;
                if(numbers[mid]==target-numbers[i])
                    return {i+1,mid+1};
                else if(numbers[mid]>target-numbers[i])
                    high=mid-1;
                else 
                    low=mid+1;
            }
        }
        return {-1,-1};
    }
};

思路二、双指针法。时间复杂度：O(n)，空间复杂度：O(1)。

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int low=0,high=numbers.size()-1;
        while(low<=high)
        {
            int sum=numbers[low]+numbers[high];
            if(sum==target)
                return {low+1,high+1};
            else if(sum>target)
                high--;
            else 
                low++;
        }
        return {-1,-1};
    }
};

5.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

思路一、暴力法。时间复杂度：O(n²)，空间复杂度：O(1)。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n=nums.size(),ans=INT_MAX;
        if(n==0)
            return 0;
        for(int i=0;i<n;i++)
        {
            int sum=0;
            for(int j=i;j<n;j++)
            {
                sum+=nums[j];
                if(sum>=s)
                {
                    ans=min(ans,j-i+1);
                    break;
                }
            }
        }
        return ans==INT_MAX?0:ans;
    }
};

思路二、双指针法。时间复杂度：O(n)，空间复杂度：O(1)。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n=nums.size();
        if(n==0)
            return 0;
        int start=0,end=0,sum=0,ans=INT_MAX;
        while(end<n)
        {
            sum+=nums[end];
            while(sum>=s)
            {
                ans=min(ans,end-start+1);
                sum-=nums[start];
                start++;
            }
            end++;
        }
        return ans==INT_MAX?0:ans;
    }
};

6.无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

思路：滑动窗口法。遇到下一个元素，与窗口内无重复——纳入；有重复——找到与窗口内无重复元素的位置，开头滑到它后面，结尾滑到新元素后面。eg.

时间复杂度：O(n)，空间复杂度：O(m)。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.length()==0)
            return 0;
        unordered_map<char,int>hashTable;//建立一个无序哈希表，下标为char类型，数组内容为int类型
        int maxLength=0,currentLength=0,startIndex=0;

        //从左到右遍历字符串
        for(int i=0;i<s.length();i++)
        {
            //若没有出现过，加入子串
            if(hashTable.find(s[i])==hashTable.end())//find() 根据键值，查找某个元素，返回迭代器，如果没找到元素，则返回unordered_map.end()迭代器，指示没有该元素。
            {
                currentLength++;
                hashTable[s[i]]=i;
            }
            //重复出现了,则收缩窗口
            else
            {
                if(currentLength>maxLength)
                    maxLength=currentLength;
                startIndex=max(hashTable[s[i]],startIndex);
                currentLength=i-startIndex;
                hashTable[s[i]]=i;
            }
        }
        if(currentLength>maxLength)
            maxLength=currentLength;

        return maxLength;
    }
};

7.验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

C语言库函数

1. isalnum()：判断字符变量c是否为字母或数字，若是则返回非零，否则返回零。
2. tolower是一种函数，功能是把字母字符转换成小写，非字母字符不做出处理。

class Solution {
public:
    bool isPalindrome(string s) {
        int low=0,high=s.size();
        while(low<high)
        {
            //跳过非字母字符
            while(low<high&&!isalnum(s[low]))
                low++;
            while(low<high&&!isalnum(s[high]))
                high--;    
            //比较是否相同
            if(low<high)
            {
                //不相同
                if(tolower(s[low])!=tolower(s[high]))
                {
                    return false;
                }
                //相同
                low++;
                high--;
            }
        }
        return true;
    }
};