数据结构与算法继续数组问题leetcode 005

最新推荐文章于 2024-11-25 23:02:28 发布

原创最新推荐文章于 2024-11-25 23:02:28 发布 · 161 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法之leetcode 专栏收录该内容

14 篇文章

订阅专栏

本文解析了LeetCode上的经典数组操作问题，包括移除零元素、删除重复项、颜色排序等，并提供了多种优化方案，如双指针法，以达到更优的时间和空间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

由于数组问题是最常见的所以继续对数组问题进行相应的求解;

leetcode283. Move Zeroes

此题是一道简单题，解决方案，

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int i=0;
        int size=nums.size();
        vector<int> result(size,0);
        int j=0;
        for(int i=0;i<size;i++){
            if(nums[i]!=0){
                result[j++]=nums[i];
            }
        }
        for(int i=0;i<size;i++){
            nums[i]=result[i];
        }
        return;
    }
};

这样解决的时间复杂度是O（n）,但是空间复杂度是O(n)

算法改进使得时间复杂度为O(n)，空间复杂度为O(1).在原址上进行处理，采用两个指针的方式来进行相应的处理；

        int i=0;
        int size=nums.size();
        int j=0;
        for(i;i<size;i++){
            if(nums[i]!=0){
                nums[j++]=nums[i];
            }
        }
        for(j;j<size;j++){
            nums[j]=0;
        }
        return;

leetcode26Remove Duplicates from Sorted Array

删除数组中的重复元素问题：

        int size=nums.size();
        if(size==0) return 0;
        int numbers=1;
        int i=0;
        int j;
        while(i<size-1){
            if(nums[i]==nums[i+1]){
                for(j=i;j<size-1;j++){//需要删除nums[i]元素  很基本的  插入元素呢 也是很基本的
                    nums[j]=nums[j+1];
                }
                size--;
            }
            else
            {   i++;
                numbers++;
            }
        }
        return numbers;

这个算法的时间复杂度是O(n*n) 空间复杂度为O(1)

算法改进：由于题目中没有提示需要返回相应删除后的数组，所以直接返回删除后数据的个数即可；

int removeDuplicates(vector<int>& nums) {
        
        //改进算法
        //采用两个指针的方式：
        int i=0;
        int size=nums.size();
        if(size==0){
            return 0;
        }
        int j=0;
        for(i;i<size;i++){
            if(nums[i]!=nums[j]){
                j++;
                nums[j]=nums[i];
            }
        }
        return j+1;
    }

时间复杂度为O(n);

leetcode27 Remove Element

int removeElement(vector<int>& nums, int val) {
        int ret = 0; 
        int n=nums.size();
        for (int i = 0; i < n; i++)  
            if (nums[i] != val)  
                nums[ret++] = nums[i];  
        return ret; 
        }

思想和上面的题型是相同的

leetcode80：Given sorted array nums = [1,1,1,2,2,3],Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3. It doesn't matter what you leave beyond the new length

解题思路：使用使用一个标签来统计相应的相同数字出现的次数吗，同样使用两个指针类维护

int removeDuplicates(vector<int>& nums) {
        //使用一个count来统计相同数字出现的次数 
        if (nums.size() <= 2) return nums.size();
        int first = 1;
        int second = 1;
        int count = 1;
        while (second<nums.size())
        {
            if (nums[second-1] == nums[second] )
            {
                if (count<2)
                {
                    nums[first++] = nums[second];
                    count++;
                }
            }
            else
            {
                count = 1;
                nums[first++] = nums[second];
            }
            second++;
        }
        return second;
    }

leetcode75 Sort Colors 对相应的颜色进行排序，不能使用库函数中的排序算法；

class Solution {
public:
    void sortColors(vector<int>& nums) {
        //首先维护一个用于存储的数组
        vector<int> color(3);//对于范围一定的数据可以进行计数排序
        int i=0;
        int size=nums.size();
        for(i;i<size;i++){
            if(nums[i]==0){
                color[0]++;
            }
            if(nums[i]==1){
                color[1]++;
            }
            if(nums[i]==2){
                color[2]++;
            }
        }
        for(int k=0;k<color[0];k++){
                nums[k]=0;
            }
        for(int m=0;m<color[1];m++){
            nums[color[0]+m]=1;
        }
        for(int n=0;n<color[2];n++){
            nums[color[0]+color[1]+n]=2;
        }
        }
    
};

计数排序的时间复杂度是O(n)也就是说有限次的遍历一轮即可得到；