LeetCode014:Longest Common Prefix

原题目:
Write a function to find the longest common prefix string amongst an array of strings.
找到一个字符串数组中,最长的公共前缀子串,并输出。

算法分析:

算法1:各种错误,各种提交不通过,各种特殊情况没考虑,服了!

算法2:
纵向扫描,从位置0开始,对每一个位置比较所有字符串,直到遇到一个不匹配。 时间复杂度为O(n1+n2+n3+...)

算法3:
横向扫描,每个字符串与第0个字符串,从左到右比较,直到遇到一个不匹配,然后下一个字符串。 时间复杂度O(n1+n2+n3+...)


错误代码:
错误1:没有考虑空字符串的情况。
解决办法:可以通过str.isEmpty判断一个字符串是否为空。不能用null,或“”,因为null代表一个对象的值。

LeetCode014:Longest Common Prefix_第1张图片
 
错误2:
都为空的情况,没有考虑。
  LeetCode014:Longest Common Prefix_第2张图片
错误3:
字符串数组越界。
  LeetCode014:Longest Common Prefix_第3张图片

LeetCode提交源码:

算法1:错误代码!
     
     
     
     
  1. public String longestCommonPrefix(String[] strs){
  2. if(strs == null || strs.length <=0){
  3. return "";
  4. }
  5. if(strs.length == 1)
  6. return strs[0];
  7. int shortlen = 1;
  8. String result = "";
  9. for(int i = 1; i < strs.length; i++){
  10. shortlen=Math.min(shortlen,strs[i-1].length());
  11. if(strs[i].isEmpty()){
  12. return result;
  13. }
  14. }
  15. System.out.println("shortlen=" + shortlen);
  16. /*for(int i = 0; i < strs.length; i++){
  17. if(strs[i].isEmpty()){
  18. //System.out.println("flag");
  19. strs[i] = strs[i+1];
  20. }
  21. System.out.println("strs=" + strs[i]);
  22. }
  23. */
  24. for(int j = shortlen-1; j >= 0; j--){
  25. System.out.println("j = " + j);
  26. for(int i = 0; i < strs.length - 1; i++){
  27. System.out.println("i=" + i);
  28. if(strs[i].charAt(j) != strs[i+1].charAt(j)){
  29. result = "";
  30. break;
  31. }
  32. if(i ==strs.length - 2){
  33. result = strs[i].charAt(j) + result;
  34. }
  35. }
  36. }
  37. return result;
  38. }

算法2:
     
     
     
     
  1. /*算法2:纵向扫描,从位置0开始,对每一个位置比较所有字符串,直到遇到一个不匹配
  2. 时间复杂度为O(n1+n2+n3+...)*/
  3. class SolutionMethod2{
  4. public String longestCommonPrefix(String[] strs){
  5. if(strs.length == 0)
  6. return "";
  7. /*直接用字符数组中的第一个字符串作为判断比较依据*/
  8. for(int j = 0; j < strs[0].length();++j){
  9. for(int i = 1; i < strs.length;++i){
  10. if(j == strs[i].length() || //用于判断某个字符串是否为空
  11. strs[i].charAt(j) != strs[0].charAt(j))
  12. return strs[0].substring(0,j); //通过substring来截取相同前缀的字符串
  13. }
  14. }
  15. return strs[0];
  16. }
  17. }
  LeetCode014:Longest Common Prefix_第4张图片
算法3:
     
     
     
     
  1. /*
  2. 算法3:横向扫描,每个字符串与第0个字符串,从左到右比较,直到遇到一个不匹配,然后下一个字符串
  3. 时间复杂度O(n1+n2+n3+...)*/
  4. class SolutionMethod3{
  5. public String longestCommonPrefix(String[] strs){
  6. if(strs.length == 0)
  7. return "";
  8. int right_most = strs[0].length();
  9. for(int i = 1; i < strs.length; ++i){
  10. for(int j = 0; j < right_most; j++){
  11. if(j == strs[i].length() ||
  12. strs[i].charAt(j) != strs[0].charAt(j))
  13. right_most = j;
  14. }
  15. }
  16. return strs[0].substring(0,right_most);
  17. }
  18. }
 
LeetCode014:Longest Common Prefix_第5张图片
完整运行程序:

     
     
     
     
  1. /**************************************************************
  2. * Copyright (c) 2016
  3. * All rights reserved.
  4. * 版 本 号:v1.0
  5. * 题目描述: Write a function to find the longest common prefix string amongst an array of strings.
  6. *
  7. * 输入描述:请输入一个字符串数组,用空格隔开:
  8. * abc abcdeagad abcdfadgasd abcdfadg abcfdfdaf
  9. * 程序输出:算法1输出:
  10. * a
  11. * 算法2输出:
  12. * abc
  13. * 算法1输出:
  14. * abc
  15. * 问题分析:无
  16. * 算法描述:算法2:纵向扫描,从位置0开始,对每一个位置比较所有字符串,直到遇到一个不匹配
  17. * 时间复杂度为O(n1+n2+n3+...)
  18. * 横向扫描,每个字符串与第0个字符串,从左到右比较,直到遇到一个不匹配,然后下一个字符串
  19. * 时间复杂度O(n1+n2+n3+...)
  20. * 完成时间:2016-11-28
  21. ***************************************************************/
  22. package org.GuoGuoFighting.LeetCode014;
  23. import java.util.Scanner;
  24. //算法1:非正确答案,针对某些特殊情况无法返回正确值
  25. class SolutionMethod1{
  26. public String longestCommonPrefix(String[] strs){
  27. if(strs == null || strs.length <=0){
  28. return "";
  29. }
  30. if(strs.length == 1)
  31. return strs[0];
  32. int shortlen = 1;
  33. String result = "";
  34. for(int i = 1; i < strs.length; i++){
  35. shortlen=Math.min(shortlen,strs[i-1].length());
  36. if(strs[i].isEmpty()){
  37. return result;
  38. }
  39. }
  40. for(int j = shortlen-1; j >= 0; j--){
  41. for(int i = 0; i < strs.length - 1; i++){
  42. if(strs[i].charAt(j) != strs[i+1].charAt(j)){
  43. result = "";
  44. break;
  45. }
  46. if(i ==strs.length - 2){
  47. result = strs[i].charAt(j) + result;
  48. }
  49. }
  50. }
  51. return result;
  52. }
  53. }
  54. /*算法2:纵向扫描,从位置0开始,对每一个位置比较所有字符串,直到遇到一个不匹配
  55. 时间复杂度为O(n1+n2+n3+...)*/
  56. class SolutionMethod2{
  57. public String longestCommonPrefix(String[] strs){
  58. if(strs.length == 0)
  59. return "";
  60. /*直接用字符数组中的第一个字符串作为判断比较依据*/
  61. for(int j = 0; j < strs[0].length();++j){
  62. for(int i = 1; i < strs.length;++i){
  63. if(j == strs[i].length() || //用于判断某个字符串是否为空
  64. strs[i].charAt(j) != strs[0].charAt(j))
  65. return strs[0].substring(0,j); //通过substring来截取相同前缀的字符串
  66. }
  67. }
  68. return strs[0];
  69. }
  70. }
  71. /*
  72. 算法3:横向扫描,每个字符串与第0个字符串,从左到右比较,直到遇到一个不匹配,然后下一个字符串
  73. 时间复杂度O(n1+n2+n3+...)*/
  74. class SolutionMethod3{
  75. public String longestCommonPrefix(String[] strs){
  76. if(strs.length == 0)
  77. return "";
  78. int right_most = strs[0].length();
  79. for(int i = 1; i < strs.length; ++i){
  80. for(int j = 0; j < right_most; j++){
  81. if(j == strs[i].length() ||
  82. strs[i].charAt(j) != strs[0].charAt(j))
  83. right_most = j;
  84. }
  85. }
  86. return strs[0].substring(0,right_most);
  87. }
  88. }
  89. public class LongestCommonPrefix {
  90. public static void main(String[] args){
  91. Scanner scanner = new Scanner(System.in);
  92. System.out.println("请输入一个字符串数组,用空格隔开:");
  93. String str = scanner.nextLine();
  94. String[] tmp = str.split(" ");
  95. scanner.close();
  96. for(int i = 0; i < tmp.length; i++){
  97. System.out.print(tmp[i] + ",");
  98. }
  99. SolutionMethod1 solution1 = new SolutionMethod1();
  100. System.out.println("算法1输出:");
  101. System.out.println(solution1.longestCommonPrefix(tmp));
  102. SolutionMethod2 solution2 = new SolutionMethod2();
  103. System.out.println("算法2输出:");
  104. System.out.println(solution2.longestCommonPrefix(tmp));
  105. SolutionMethod3 solution3 = new SolutionMethod3();
  106. System.out.println("算法1输出:");
  107. System.out.println(solution3.longestCommonPrefix(tmp));
  108. }
  109. }


程序运行结果:

  LeetCode014:Longest Common Prefix_第6张图片

你可能感兴趣的:(LeetCode)