资讯专栏INFORMATION COLUMN

用Java实现一些简单算法

Developer / 584人阅读

摘要:依次类推选择排序基本思路把第一个元素依次和后面的所有元素进行比较。方法一定义计数器定义变量记录出现的位置方法二两个字符串中最大相同的子串。在一个字符串中,统计出现的整数的个数,连续的数字为一个整数不考虑负数,字符串中不包含空格。

for循环,外循环控制的是行数,内循环控制的是每一行的个数。

*****
*****
*****
*****

for (int x = 0; x < 4; x++){// 外循环控制的是行数
    for (int y = 0; y < 5; y++){// 内循环控制的是每一行的个数
        System.out.print("*");
    }
    System.out.println();
}

--------------------------------------------------

*****
****
***
**
*

for (int x = 1; x <= 5; x++) {
    for (int y = x; y <= 5; y++) {
        System.out.print("*");
    }
    System.out.println();
}

--------------------------------------------------

*
**
***
****
*****

for (int x = 1; x <= 5; x++) {
    for (int y = 1; y <= x; y++) {
        System.out.print("*");
    }
    System.out.println();
}

--------------------------------------------------

54321
5432
543
54
5

for (int x = 1; x <= 5; x++) {
    for (int y = 5; y >= x; y--) {
        System.out.print(y);
    }
    System.out.println();
}

--------------------------------------------------

1
22
333
4444
55555

for (int x = 1; x <= 5; x++) {
    for (int y = 1; y <= x; y++) {
        System.out.print(x);
    }
    System.out.println();
}

--------------------------------------------------

* * * * *
 * * * * 
  * * *
   * *
    * 

for (int x = 1; x <= 5; x++) {//分成左右两边,左边是空格,右边是*加空格
    for (int y = 1; y < x; y++) {
        System.out.print(" ");
    }
    for (int z = x; z <= 5; z++) {
        System.out.print("* ");
    }
    System.out.println();
}

--------------------------------------------------

    *
   * *
  * * *
 * * * *
* * * * *

for (int x = 1; x <= 5; x++) {
    for (int y = x; y < 5; y++) {
        System.out.print(" ");
    }
    for (int z = 1; z <= x; z++) {
        System.out.print("* ");
    }
    System.out.println();
}

--------------------------------------------------

九九乘法表

for (int x = 1; x <= 9; x++) {
    for (int y = 1; y <= x; y++) {
        System.out.print(y + "*" + x + "=" + y * x + "	");
    }
    System.out.println();
}
整型数组

遍历数组的功能

public static void printArray(int[] arr) {
    System.out.print("[");
    for (int x = 0; x < arr.length; x++) {
        if (x != arr.length - 1) {
            System.out.print(arr[x] + ",");
        } else {
            System.out.println(arr[x] + "]");
        }
    }
}

--------------------------------------------------

获取最大值

    public static int getMax(int[] arr) {
        int maxElement = arr[0];
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] > maxElement) {
                maxElement = arr[x];
            }
        }
        return maxElement;
    }

--------------------------------------------------

获取最大值2

    public static int getMax_2(int[] arr) {
        int maxIndex = 0;
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] > arr[maxIndex]) {
                maxIndex = x;
            }
        }
        return arr[maxIndex];
    }

--------------------------------------------------

置换

    private static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

--------------------------------------------------

反转

    public static void reverseArray(int[] arr) {
        for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
            swap(arr, start, end);
        }
    }

--------------------------------------------------

冒泡排序

基本思路:相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处。依次类推

    public static void bubbleSort(int[] arr) {
        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = 0; y < arr.length - 1 - x; y++) {
                if (arr[y] > arr[y + 1]) {
                    swap(arr, y, y + 1);
                }
            }
        }
    }

--------------------------------------------------

选择排序

基本思路: 把第一个元素依次和后面的所有元素进行比较。 第一次结束后,就会有最小值出现在最面。依次类推

    public static void selectSort(int[] arr) {
        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = x + 1; y < arr.length; y++) {
                if (arr[x] > arr[y]) {
                    swap(arr, x, y);
                }
            }
        }
    }

--------------------------------------------------

选择排序2,记录索引

    public static void selectSort_2(int[] arr) {
        for (int x = 0; x < arr.length - 1; x++) {
            int num = arr[x];
            int index = x;
            for (int y = x + 1; y < arr.length; y++) {
                if (num > arr[y]) {
                    num = arr[y];
                    index = y;
                }
            }
            if (index != x) {
                swap(arr, x, index);
            }
        }
    }

--------------------------------------------------

二分查找(折半查找),数组必须有序

    public static int halfSearch(int[] arr, int key) {
        int max = arr.length - 1;
        int min = 0;
        int mid = (max + min) / 2;
        while (arr[mid] != key) {
            if (key > arr[mid]) {
                min = mid + 1;
            } else if (key < arr[mid]) {
                max = mid - 1;
            }
            if (max < min) {
                return -1;
            }
            mid = (max + min) / 2;
        }
        return mid;
    }

--------------------------------------------------

二分查找2,数组必须有序

    public static int halfSearch_2(int[] arr, int key) {
        int max, min, mid;
        min = 0;
        max = arr.length - 1;
        while (min <= max) {
            mid = (min + max) >> 1;
            if (key > arr[mid]) {
                min = mid + 1;
            } else if (key < arr[mid]) {
                max = mid - 1;
            } else {
                return mid;
            }
        }
        return -min - 1;

    }
字符串

字符串数组置换

    private static void swap(String[] arr, int a, int b) {
        String temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

给定一个字符串数组。按照字典顺序进行从小到大的排序。

    public static void sortString(String[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i].compareTo(arr[j]) > 0) {
                    swap(arr, i, j);
                }
            }
        }
    }

--------------------------------------------------

一个子串在整串中出现的次数。

//"nbaernbatynbauinbaopnba"     “nba"
/* 思路:
* 1,要找的子串是否存在,如果存在获取其出现的位置。这个可以使用indexOf完成。
* 2,如果找到了,那么就记录出现的位置并在剩余的字符串中继续查找该子串,
* 而剩余字符串的起始位是出现位置+子串的长度.
* 3,以此类推,通过循环完成查找,如果找不到就是-1,并对每次找到用计数器记录。
*/

//方法一
    public static int getKeyStringCount(String str, String key) {
        // 定义计数器
        int count = 0;
        // 定义变量记录key出现的位置
        int index = 0;
        while ((index = str.indexOf(key)) != -1) {
            str = str.substring(index + key.length());
            count++;
        }
        return count;
    }
//方法二
    public static int getKeyStringCount_2(String str, String key) {
        int count = 0;
        int index = 0;
        while ((index = str.indexOf(key, index)) != -1) {
            index = index + key.length();
            count++;
        }
        return count;
    }

--------------------------------------------------

两个字符串中最大相同的子串。

/* "qwerabcdtyuiop" "xcabcdvbn"
* 思路: 1,既然取得是最大子串,先看短的那个字符串是否在长的那个字符串中。 如果存在,短的那个字符串就是最大子串。
* 2,如果不是呢,那么就将短的那个子串进行长度递减的方式去子串,去长串中判断是否存在。 如果存在就已找到,就不用在找了。
*/
    public static String getMaxSubstring(String s1, String s2) {
        String max = null, min = null;
        max = (s1.length() > s2.length()) ? s1 : s2;
        min = max.equals(s1) ? s2 : s1;
        System.out.println("max=" + max);
        System.out.println("min=" + min);
        for (int i = 0; i < min.length(); i++) {
            for (int a = 0, b = min.length() - i; b != min.length() + 1; a++, b++) {
                String sub = min.substring(a, b);
                // System.out.println(sub);
                if (max.contains(sub))
                    return sub;
            }
        }
        return null;
    }

--------------------------------------------------

在一个字符串中,统计出现的整数的个数,连续的数字为一个整数(不考虑负数),字符串中不包含空格。

/**
* a10b20c30de40fg
* 思路:首先要遍历所有的字符,判断每个字符是不是数字,是数字的话就把它放在一个StringBuilder对象
* 里面并标记,下面一个字符要是数字就加在后面,不是数字的话,就把当前的StringBuilder里面的数字
* 塞到list里面,最后判断list长度即可
*/

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String s = scanner.next();
    scanner.close();    
    if (s != null && s.length() != 0) {
        List list = new ArrayList();
        StringBuilder sb = new StringBuilder();
        boolean isChar = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c >= "0" && c <= "9") {
                sb.append(s.charAt(i));
                if (i == s.length() - 1) {
                    list.add(Integer.parseInt(sb.toString()));
                    sb.setLength(0);
                }
                isChar = false;
            } else {
                if (sb.length() > 0 && isChar == false) {
                    list.add(Integer.parseInt(sb.toString()));
                    sb.setLength(0);
                }
                isChar = true;
            }
        }
        System.out.println(list.size());        
    }
}

如果要是换个问法也是一样的,统计一个字符串中出现整数的和,只需要在下面加入一个遍历list,把所有的数字加一起就好了。

if (list.size() > 0) {
      int sum = 0;
    for (int i = 0; i < list.size(); i++) {
        sum = sum + list.get(i);
    }
    System.out.println(sum);
}

持续更新……

微信公众号:志哥 (ID: zhige-me)
期待与你相遇,一同成长前行!

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/65191.html

相关文章

  • 跳槽季如何快速全面复习面试题

    摘要:排序算法和集合工具类排序算法和集合工具类。面试官总是问排序算法也不是在难为你,而是在考察你的编程功底。你首先要理解多线程不仅仅是和那么简单,整个并发包下面的工具都是在为多线程服务。 去年的这个时候楼主通过两个月的复习拿到了阿里巴巴的 offer,有一些运气,也有一些心得,借着跳槽季来临特此分享出来。简单梳理一下我的复习思路,同时也希望和大家一起交流讨论,一起学习,如果不对之处欢迎指正一...

    keke 评论0 收藏0
  • 算法日积月累】1-选择排序

    摘要:选择排序算法实现实现选择排序,记录最小元素的索引,最后才交换位置说明交换两个数组中的元素,在中有更简单的写法,这是的语法糖,其它语言中是没有的。和语言中比较器的实现前面我们说到了,我们为了突出排序算法的思想,将所有的例子仅限在数组排序中。 showImg(https://segmentfault.com/img/remote/1460000017909538?w=1949&h=1080...

    neuSnail 评论0 收藏0
  • 循序渐进学加密

    摘要:在古典加密算法当中,加密算法和密钥都是不能公开的,一旦泄露就有被破解的风险,我们可以用词频推算等方法获知明文。年美国公司研制的算法是人类历史上第一个公开加密算法但不公开密钥的加密方法,后来成为美国军方和政府机构的标准加密算法。 还记得上初二的那年夏天,班里来了一个新同学,他就住在我家对面的楼里,于是我们一起上学放学,很快便成了最要好的朋友。我们决定发明一套神秘的沟通方式,任何人看到都不...

    Y3G 评论0 收藏0
  • 循序渐进学加密

    摘要:在古典加密算法当中,加密算法和密钥都是不能公开的,一旦泄露就有被破解的风险,我们可以用词频推算等方法获知明文。年美国公司研制的算法是人类历史上第一个公开加密算法但不公开密钥的加密方法,后来成为美国军方和政府机构的标准加密算法。 还记得上初二的那年夏天,班里来了一个新同学,他就住在我家对面的楼里,于是我们一起上学放学,很快便成了最要好的朋友。我们决定发明一套神秘的沟通方式,任何人看到都不...

    fsmStudy 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<