Linux专栏

收录了所有关于Linux系统的文章和教程，从基础命令到高级权限管理

Linux系统完整指南

一、Linux系统概述与配置环境

Linux是一种自由和开放源代码的类UNIX操作系统，由林纳斯·托瓦兹在1991年首次发布。作为服务器领域的霸主，Linux在全球服务器操作系统市场占据了极大的份额，同时在移动嵌入式、云计算以及大数据等领域也有广泛应用。我们熟知的安卓系统就是基于Linux。故学习Linux十分重要

二、Linux基础命令详解

1. 文件与目录操作命令
ls          # 简单列出文件和目录
ls -l       # 长格式显示，包含权限、所有者、大小等信息
ls -a       # 显示所有文件，包括隐藏文件（以.开头的文件）
ls -lh      # 以人类可读格式显示文件大小（KB,MB,GB）
ls -lt      # 按修改时间排序，最新修改的排在最前
ls -ltr     # 按修改时间反向排序，最旧的排在最前
ls -R       # 递归列出子目录内容
ls -d */    # 只列出目录
cd命令 - 切换目录
cd          # 返回用户主目录
cd ~        # 同上，返回用户主目录
cd /path/to/dir  # 使用绝对路径切换目录
cd ..       # 切换到上级目录
cd ../dir   # 使用相对路径切换
cd -        # 返回上一个工作目录

三、Linux权限管理详解

1. 用户与用户组管理
su username              # 切换用户但保留当前环境
su - username            # 完全切换用户，加载新用户环境
su -                     # 切换到root用户
exit                     # 返回原用户
sudo命令 - 以超级用户权限执行
sudo command             # 以root权限执行命令
sudo -u username command # 以指定用户身份执行
sudo -i                  # 启动root shell
sudo -l                  # 列出当前用户可执行的sudo命令

四、高级文件操作与实用技巧

1. 文件查找命令
find / -name "*.txt"           # 按名称查找
find / -type f -name "*.conf"  # 查找普通文件
find / -type d -name "log"     # 查找目录
find / -size +10M              # 查找大于10MB的文件
find / -mtime -7               # 查找7天内修改的文件
find / -user root              # 查找root用户的文件
find / -perm 644              # 查找权限为644的文件
find / -exec ls -l {} \;      # 对找到的文件执行命令
find / -name "*.tmp" -delete  # 查找并删除

五、Linux系统管理基础

1. 进程管理
ps aux                     # 查看所有进程
ps -ef                     # 完整格式显示进程
ps -u username             # 查看指定用户进程
ps -p PID                  # 查看指定PID进程
ps -eo pid,ppid,cmd,%cpu,%mem --sort=-%mem | head  # 查看内存使用前10的进程

六、尾言

文章中如有错误，欢迎各位读者在评论区指正。

向你鞠躬！！

算法专栏

一些算法思想总结（不同步CSDN的博客）

双指针算法思想

常⻅的双指针有两种形式，⼀种是对撞指针，⼀种是左右指针

对撞指针

    ⼀般⽤于顺序结构中，也称左右指针。

    对撞指针从两端向中间移动。⼀个指针从最左端开始，另⼀个从最右端开始，然后逐渐往中间逼近。

    对撞指针的终⽌条件⼀般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循环），也就是：
    ◦ left == right （两个指针指向同⼀个位置）
    ◦ left > right （两个指针错开）

快慢指针

    快慢指针⼜称为⻳兔赛跑算法，其基本思想就是使⽤两个移动速度不同的指针在数组或链表等序列结构上移动。
这种⽅法对于处理环形链表或数组⾮常有⽤。

    其实不单单是环形链表或者是数组，如果我们要研究的问题出现循环往复的情况时，均可考虑使⽤快慢指针的思
想。

    快慢指针的实现⽅式有很多种，最常⽤的⼀种就是：
    • 在⼀次循环中，每次让慢的指针向后移动⼀位，⽽快的指针往后移动两位，实现⼀快⼀慢。

题目示例

1.移动零
Leetcode283（点击跳转题目） 
class Solution 
{
public:
    void moveZeroes(vector& nums) 
    {
	for(int cur = 0 ,dest = -1;cur < nums.size();cur++)
        {
            if(nums[cur])
            {
                swap(nums[++dest],nums[cur]);
            }
        }
    }
};
2.复写零
Leetcode1089（点击跳转题目） 
class Solution {
public:
    void duplicateZeros(vector& arr) 
    {
        int size = arr.size(),cur = 0,dest = -1;
        while(1)
        {
            if(arr[cur])
            {
                dest++;
            }
            else
            {
                dest+=2;
            }
            if(dest>=size-1)
            {
                break;
            }
            cur++;
        }
        if (dest == size) 
        {
            arr[size - 1] = 0;
            dest -= 2;
            cur--;
        }
        while(cur>=0)
        {
            if(arr[cur])
            {
                arr[dest] = arr[cur];
                dest--;
                cur--;
            }
            else
            {
                arr[dest]=arr[cur];
                dest--;
                arr[dest]=arr[cur];
                dest--;
                cur--;
            }
        }
    }
};
3.快乐数
Leetcode202（点击跳转题目） 
class Solution {
public:
//找每一位的平方和
    int bitsum(int n)
    {
        int sum = 0;
        while(n)
        {
            int t = n % 10;
            sum += t * t;
            n /= 10;
        }
        return sum;
    }

    bool isHappy(int n) 
    {
       int slow = n,fast = bitsum(n);
       while(slow != fast)
       {
        slow = bitsum(slow);
        fast = bitsum(bitsum(fast));
       } 
       return  slow == 1;
    }
};
4.盛最多水的容器
Leetcode11（点击跳转题目） 
class Solution {
public:
    int maxArea(vector& height) 
    {
      int left = 0,right = height.size() - 1,ret = 0;
      while(left< right)
      {
        int v = min(height[left],height[right])*(right-left);
        ret = max(ret,v);
        if(height[left] < height[right])
        {
            left++;
        }
        else
        {
            right--;
        }
      }  
      return ret;
    }
};
5.有效三角形的个数
Leetcode611（点击跳转题目） 
class Solution {
public:
    int triangleNumber(vector& nums) 
    {
        sort(nums.begin(),nums.end());
        int ret = 0,n = nums.size();
        for(int i = n-1;i>=2;i--)
        {
            int left = 0,right = i-1;
            while(leftnums[i])
                {
                    ret += right - left;
                    right--;
                }
                else
                {
                    left++;
                }
            }
        }
        return ret;
    }
};
6.查找总价格为目标值的两个商品
LeetcodeLCR179（点击跳转题目） 
class Solution {
public:
    vector twoSum(vector& price, int target) 
    {
        int left = 0,right = price.size()-1;
        while(left target) right--;
            else if(sum < target) left++;
            else return{price[left],price[right]};
        }
        return{-1,-1};
    }
};
7.三数之和
Leetcode15（点击跳转题目） 
class Solution {
public:
    vector> threeSum(vector& nums) 
    {
        sort(nums.begin(),nums.end());
        vector> ret;
        int i = 0,n=nums.size();
        while(i0) break;
            int target = -nums[i],left = i + 1,right = n-1;
            while(left target)
                {
                    --right;
                }
                else if(nums[left] + nums[right] < target)
                {
                    ++left;
                }
                else
                {
                    ret.push_back({nums[i],nums[left],nums[right]});
                    ++left;
                    --right;
                    while(left < right && nums[left-1]==nums[left])
                    {
                        left++;
                    }
                    while(left < right && nums[right]==nums[right+1])
                    {
                        right--;
                    }
                }
            }
            ++i;
            while(i < n && nums[i]==nums[i-1])
            {
                ++i;
            }
        }
        return ret;
    }
};

滑动窗口思想

题目示例

1.⻓度最⼩的⼦数组
Leetcode209（点击跳转题目） 
class Solution {
public:
    int minSubArrayLen(int target, vector& nums)
    {
        int len = INT_MAX, sum = 0;
        for (int left = 0, right = 0; right < nums.size(); ++right)
        {
            sum += nums[right];
            while (sum >= target)
            {
                len = min(len, right - left);
                sum -= nums[left++];
            }
        }
        return len == INT_MAX ? 0 : len + 1;
    }
};
2. ⽆重复字符的最⻓⼦串
Leetcode3（点击跳转题目） 
class Solution {
public:
    int longestOnes(vector& nums, int k)
    {
        int ret = 0;
        for (int left = 0, right = 0, count = 0; right < nums.size(); ++right)
        {
            if (nums[right] == 0) ++count;
            while (count > k)
            {
                if (nums[left++] == 0) --count;
            }
            ret = max(ret, right - left + 1);
        }
        return ret;
    }
};
3. 最⼤连续1的个数
Leetcode1004（点击跳转题目） 
class Solution {
public:
    int lengthOfLongestSubstring(string s)
    {
        int hash[128] = { 0 };
        int left = 0, right = 0, ret = 0, n = s.size();
        while (right < n)
        {
            hash[s[right]]++;
            while (hash[s[right]] > 1)
            {
                hash[s[left++]]--;
            }
            ret = max(ret, right - left + 1);
            ++right;
        }
        return ret;
    }
};