LeetCode简单算法笔记

1.冒泡排序
对一串数组 [5,2,3,1] 进行从小到大排序
解题1：

   public int[] sortArray(int[] nums) {
    //    Arrays.sort(nums);
    //    return nums;

    //冒泡排序
    //外圈控制比较次数 i= 1，2，3
    //     for (int i = 0; i < nums.length-1; i++)
    //     {
    //         //两个邻近元素比较，当前者大于后者，则调换元素位置
    //         for (int j = 0; j < nums.length-1-i; j++)
    //         {
    //             int index = 0;
    //             if (nums[j] > nums[j + 1])
    //             {
    //                 index = nums[j];
    //                 nums[j] = nums[j + 1];
    //                 nums[j + 1] = index;
    //             }
    //         }

    //     }
    //     return nums;
    // }
    partition(nums,0,nums.length-1);
    return nums;
    }
            //快速排序
        public void partition (int [] nums , int l , int r)
        {
            // 错误，退出
            if(l>=r ) return;
            //i = 最小长度   j = 最大长度
            int i =l , j = r;
            int tmp = nums[l];
            while(l<r)
            {
                while(l<r && nums[r] >= tmp)
                {
                    r--;
                }
                    nums[l] = nums[r];
                
                while(l<r && nums[l]<= tmp)
                {  
                    l++;
                }
                    nums[r] = nums[l];
            }
            nums[l]  = tmp;
            partition(nums,i,l-1);
            partition(nums,l+1,j);
        }

2.整数反转
注意：要考虑整型的区间范围

//  力扣算法 7. 整数反转
  public int reverse(int x) {
        // long result = 0 ;
        // while ( x != 0)
        // {
        //     result = result * 10 + x % 10;
        //     x = x/10; 
        // }
        // if(result> Integer.MAX_VALUE || result< Integer.MIN_VALUE)
        // {
        //     return 0 ; 
        // }
        // return (int) result;

        //官方解答
        
        //当x 处于 Integer.MIN_VALUE  
        if(x == Integer.MIN_VALUE ) return 0;
        //当x 为负数  的情况下
        int neg = x <0 ? -1:1;
        //将负数 先转化为整数
        x *= neg;
        //ret为新数字
        int ret =0 ;
        while(x>0)
        {
            //n为新数字
            int  n = ret ;
            n *= 10;
            n+= x % 10 ;
            x/=10;
            if(n/10!=ret ) return 0;
            ret = n;
        }
        return ret * neg ;
    }

3.两数之和

//  力扣算法 1.两数之和
 public int[] twoSum(int[] nums, int target) {
        
         //创建一个新的数组存起来
        int i ,j ;
        int[] result = new int[2];

        for ( i = 0; i < nums.length; i++)
        {
            for ( j = i+1; j < nums.length; j++)
            {
                if (nums[i] + nums[j] == target)
                {
                    result [0] = i;
                    result [1] = j;
                }
            }
        }
        return result;
    }

4.回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例1 :
输入: 121
输出: true

示例2 :
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

// 力扣算法 9.回文数

    public static boolean isPalindrome(int x) {
        //首先判断它必须>=0
        int k = x;
        if(k<0) return false;
        //新值
        int number = 0;
        while (k > 0)
        {
            number = k % 10 + number * 10;
            k /= 10;
        }
        return ( x== number) ? true : false;
    }
//-------------------------------------------------------------	
		//官方解法
        //考虑 x = 负数 和 x = 10的倍数
        if(x<0 || (x!=0 && x%10 ==0)) return false;
        //定义新值
        int n = 0;
        while (x > n)
        {
            n *= 10;
            n += x % 10;
            x /= 10;
        }
        //这里考虑 1 和 0 的情况
        return  (x==n) || (n/10 ==x) ;

5.最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: [“flower”,“flow”,“flight”]
输出: “fl”

示例 2:

输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。

//力扣算法 14.最长公共前缀
public static String longestCommonPrefix(String[] strs)
    {
        //判断字符串为空 && null
        if(strs == null || strs.length==0) return "";
        //设置前缀为第一个字符串
        String prefix = strs[0];

        //遍历所有字符串
        for (String s : strs)
        {
            //匹配 如果完全匹配 返回值为0的时候 表示是一个值
            //完全匹配索引不为0 则对prefix进行尾切
            while(s.indexOf(prefix) != 0)
            {
                // 不匹配  切分最长公共前缀
                prefix= prefix.substring(0, prefix.length() - 1);
            }
        }
        return prefix;
     }

6.罗马数字转整数
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 - 数值
I -------- 1
V ------- 5
X ------ 10
L ------- 50
C ------ 100
D ------ 500
M ----- 1000

//  力扣算法13. 罗马数字转整数
public  static int romanToInt(String s)
    {
        // 定义和数      IV（ 1 && 5） ==4
        int sum = 0;
        //定义上一个数 / 当前为个位数时
        int preNum = getValue(s.charAt(0)); // 1
        for (int i = 1; i < s.length(); i++)
        {
            //当前数字
            int num = getValue(s.charAt(i));  //4

            if (num > preNum)
            {
                sum -= preNum;  //sum = 0-1 = -1;
            } else
            {
                sum += preNum;  // sum = 0+1 = 1;
            }
            preNum = num;  //preNum =5
        }
        sum += preNum;  // sum = -1 + 5
        return sum;
    }
    public static int getValue(char ch)
    {
        switch (ch)
        {
            case 'I': return  1;
            case 'V': return  5;
            case 'X': return 10;
            case 'L': return 50;
            case 'C': return 100;
            case 'D': return 500;
            case 'M': return 1000;
            default: return 0;
        }
    }

所有材料及题解来源均出于：力扣（LeetCode）
链接：https://leetcode-cn.com/problems
申明：著作权归领扣网络所有，商业转载请联系官方授权。