程序博客网 > 淘宝店打折怎么设置

java基础算法、递归调用、字符串(含中文)切割

来源：互联网 发布：淘宝店打折怎么设置 编辑：程序博客网 时间：2024/06/06 03:54

一、算法

1、桶排序

Java代码  收藏代码
  1. /* 桶排序  */  
  2. public static void booleanSort(){  
  3.     int[] sortlist = new int[]{1,14,9,33,11,45,32};  
  4.     boolean[] sortboolean = new boolean[46];  
  5.     for(int index : sortlist){  
  6.         sortboolean[index] = true;  
  7.     }  
  8.     for(int i=sortboolean.length-1;i>=0;i--){  
  9.         if(sortboolean[i]) System.out.print(i+"--");  
  10.     }  
  11. }  

 不过它有局限性：

1、你必须知道数组的最大值；

2、数组中一定不能有重复值，否则只会显示一个；

3、数组中不能为负数【但是如果你知道负数的最小值，这个也是允许的，你可以先把数组中的元素进行操作，把它们都变为正数，然后在最后输出的时候反向操作一次就行了】

  2、冒泡排序

Java代码  收藏代码
  1. /* 冒泡排序1(从右向左冒泡)  */  
  2. public static void bubbleSortFromRight(){  
  3.     int[] sortlist = new int[]{1,14,9,33,11,45,32};  
  4.     int tmp = 0;  
  5.     for(int i=0;i<sortlist.length;i++){  
  6.         for(int j=0;j<sortlist.length-i-1;j++){  
  7.             if(sortlist[j] > sortlist[j+1]){  
  8.                 tmp = sortlist[j+1];  
  9.                 sortlist[j+1] = sortlist[j];  
  10.                 sortlist[j] = tmp;  
  11.             }  
  12.         }  
  13.     }  
  14.     for(int sortednum : sortlist){  
  15.         System.out.println(sortednum);  
  16.     }  
  17. }  

    

Java代码  收藏代码
  1. /* 冒泡排序2(从左向右冒泡)  */  
  2. public static void bubbleSortFromLeft(){  
  3.     int[] sortlist = new int[]{1,14,9,33,11,45,32};  
  4.     int tmp = 0;  
  5.     for(int i=0;i<sortlist.length;i++){  
  6.         for(int j=sortlist.length-1;j>i;j--){  
  7.             if(sortlist[j-1] > sortlist[j]){  
  8.                 tmp = sortlist[j-1];  
  9.                 sortlist[j-1] = sortlist[j];  
  10.                 sortlist[j] = tmp;  
  11.             }  
  12.         }  
  13.     }  
  14.     for(int sortednum : sortlist){  
  15.         System.out.println(sortednum);  
  16.     }  
  17. }  

   3、快速排序算法

   

Java代码  收藏代码
  1. public class QuickSort {  
  2.      public static void main(String[] args) {    
  3.          // int[] iArgs = new int[]{72,6,57,88,60,42,83,73,48,85};    
  4.           int iLength = 10;    
  5.           int[] iArgs = new int[iLength];    
  6.           for(int i = 0; i < iLength; i++){    
  7.               Random objRandom = new Random();    
  8.               iArgs[i] = objRandom.nextInt(100);    
  9.           }    
  10.           QuickSort quickSort = new QuickSort();    
  11.           //快速排序    
  12.           quickSort.recursive(iArgs,0,iArgs.length - 1);    
  13.               
  14.           for(int i = 0; i < iArgs.length; i++) {    
  15.             System.out.print(iArgs[i] + " ");    
  16.           }    
  17.       }    
  18.           
  19.       /**  
  20.        * 递归循环数据  
  21.        *   
  22.        * @param args 数组  
  23.        * @param left 数组左下标 （第一次调用的时候，为0） 
  24.        * @param right 数组右下标 （第一次调用的时候，为数组长度-1） 
  25.        * @return  
  26.        */    
  27.       private void recursive(int[] args,int left,int right) {    
  28.          if( left < right) {    
  29.              //数据从left到right坐标的数据进行排序 ，排序后以基准值为目标，左边都是小于它的值，右边都是大于它的值  
  30.              int iIndex = qucikSort(args,left,right); //iIndex 是基数放在数据位置    
  31.         
  32.               //递归算法，对于基数左边排序    
  33.               recursive(args,left,iIndex-1);  
  34.               //递归算法，对于基数右边排序    
  35.               recursive(args,iIndex+1,right);  
  36.          }    
  37.       }    
  38.           
  39.       /**  
  40.        * 确定基数左边的数都比它小，右边的数都比它大  
  41.        *  
  42.        *  
  43.        * 实例说明：假如比较int[] args = {20,4,9,5,49}; 
  44.        * 1、首次调用该方法时获取基准值iBase=args[0]=20; 
  45.        * 2、从右向左找比基准数小的数，从左向右找比基准数大的数；接下来模拟while循环(r:right,l:left)： 
  46.        *  20(l) 4    9    5    49(r)  -- 循环前的状态 
  47.        *  ------------------------------------------------- 
  48.        *  20(l) 4    9    5(r) 49     -- 首先开始第2步循环。比较49(args[r])和20(iBase),因为args[r] > iBase,所以right--; 
  49.        *  ------------------------------------------------- 
  50.        *   5(l) 4    9    5(r) 49     -- 比较5(args[r])和20(iBase),因为args[r] < iBase,所以args[l] = 5(args[r]); 
  51.        *  ------------------------------------------------- 
  52.        *   5    4(l) 9    5(r) 49     -- 此时开始第3步循环。比较5(args[l])和20(iBase),因为args[l] < iBase,所以left++; 
  53.        *  ------------------------------------------------- 
  54.        *   5    4    9(l) 5(r) 49     -- 比较4(args[l])和20(iBase),因为args[l] < iBase,所以left++; 
  55.        *  ------------------------------------------------- 
  56.        *   5    4    9    5(lr) 49    -- 比较9(args[l])和20(iBase),因为args[l] < iBase,所以left++; 
  57.        *  ------------------------------------------------- 
  58.        *   5    4    9    5(lr) 49    -- 此时第3步循环的while条件left<right不成立，args[r] = 5(args[l]); 
  59.        *  ------------------------------------------------- 
  60.        *   5    4    9    20(lr) 49   -- 最外面的while(left < right)不成立，进行第4步args[left]= 20(iBase); 
  61.        *  ------------------------------------------------ 
  62.        *   5    4    9    [20]   49   -- 至此为止，完成了qucikSort(),确定了基数左右的数,并且返回left值，即基数值的索引。然后以基数索引为中心，分别对其左边和右边的数组进行同样规则的递归排序。   
  63.        * @param args  数组  
  64.        * @param left  数组左下标  
  65.        * @param right 数组右下标  
  66.        * @return  
  67.        */    
  68.       private int qucikSort(int[] args,int left,int right) {    
  69.           //第1步.获取基准数  
  70.           int iBase = args[left]; //基准数  
  71.           while (left < right) {    
  72.              //第2步.从右向左找出第一个比基准数小的数（查找原理：从右向左，把每个数跟iBase比较，<iBase时，把索引为left的值(args[left])替换为索引为right的值(args[right])；然后开始第3步）  
  73.               while( left < right && args[right] >= iBase) {    
  74.                   right--;    
  75.               }    
  76.               args[left] = args[right];    
  77.                   
  78.               //第3步.从左向右找出第一个比基准数小的数 （查找原理跟第2步相仿）  
  79.               while( left < right && args[left] <= iBase) {    
  80.                   left++;    
  81.               }    
  82.               args[right] = args[left];    
  83.           }  
  84.           //第4步.因为第2步和第3步已经把iBase给替换掉了，所以重新复制到arg[left]。  
  85.           args[left]= iBase;    
  86.           return left;    
  87.       }  
  88. }  

    4、插入排序算法

    说明：插入排序理解原理后很简单，参考：http://zhdkn.iteye.com/blog/1136253

 

Java代码  收藏代码
  1. /** 
  2.  * 插入排序算法 
  3.  * @param args 
  4.  */  
  5. public void insertSort(int args[]){  
  6.    for(int i=1;i<args.length;i++){  
  7.     int iBase = args[i];  
  8.     int j = i-1;  
  9.     while(j >= 0 && args[j] > iBase){  
  10.         args[j+1] = args[j];  
  11.         j--;  
  12.     }  
  13.     args[j+1] = iBase;  
  14.    }  
  15.    System.out.println(Arrays.toString(args));  
  16. }  
  17. public static void main(String[] args) {    
  18.     int iLength = 10;    
  19.     int[] iArgs = new int[iLength];    
  20.     for(int i = 0; i < iLength; i++){    
  21.         Random objRandom = new Random();    
  22.         iArgs[i] = objRandom.nextInt(100);    
  23.     }  
  24.       
  25.     QuickSort quickSort = new QuickSort();    
  26.     quickSort.insertSort(iArgs);  
  27. }  

    5、其他排序算法

      引用CSDN上某位网友的博客，写的很不错(c语言写的，原理描述的很清楚)。

      1、选择排序算法(较简单，但不稳定)

      2、归并排序算法(自底向上) 和  归并排序算法(自顶向下)

    

   6、二分查找算法

   

Java代码  收藏代码
  1. /** 
  2.      * 二分查找算法 
  3.      *  
  4.      * 前提：数组是已排好序的。 
  5.      * 原理：假设要找到的值为X，首先找到数组中间的值M。 
  6.          *       若X<M，则只需在数组右边的数值中查找； 
  7.      *       若X>M，只需在数组左边的数值中查找； 
  8.      *       若X=M，返回下标索引。 
  9.      * 实例：int[] sortList = {1,2,3,4,5,6,7,8,9,10}; 假定查询数值 7： 
  10.      * (1).首先找到中间的值是5（索引值为4：start=0,end=9,middle=(start+end)/2=4）; 
  11.      * (2).拿5和要查询的数值7比较，7>5(对应X>M),只需在数组左边数值中查询,即只要在{6,7,8,9,10}中查询; 
  12.      * (3).查询的数组不变，需要设置start=middle+1,end不变，然后获取到的中间值即为8(索引值为7：start=5,end=9,middle=(5+9)/2=7); 
  13.      * (4).循环1,2,3步即可。 
  14.      * @param sortedList   排序好的数组 
  15.      * @param start        开始位置 
  16.      * @param end          结束位置 
  17.      * @param findvalue    需要找到的数值  
  18.      * @return             返回该值所在数组中的索引(从0开始，查询不到返回-1) 
  19.      */  
  20.     public static int binarySearch(int[] sortedList,int start,int end,int findValue){  
  21.         int middle = (start + end) / 2;  
  22.         if(start > end){  
  23.             return -1;  
  24.         }else if(start+1 == end){  
  25.             if(sortedList[start] == findValue){  
  26.                 return start;  
  27.             }else{  
  28.                 return end;  
  29.             }  
  30.         }else if(sortedList[middle] == findValue){  
  31.             return middle;  
  32.         }else if(sortedList[middle] > findValue){  
  33.             return binarySearch(sortedList,start,middle-1,findValue);  
  34.         }else if(sortedList[middle] < findValue){  
  35.             return binarySearch(sortedList,middle+1,end,findValue);  
  36.         }  
  37.         return -1;  
  38.     }  

 

   最后附上一个排序的时间复杂度表格，仅供参考、


     
 

二、递归算法

Java代码  收藏代码
  1. /* 递归算法(1+2+3+...+n=?) */  
  2.     public static int circle(int param){  
  3.         if(param==1){  
  4.             return 1;  
  5.         }  
  6.         return param+circle(param-1);  
  7.     }  

    

Java代码  收藏代码
  1. /* 将一整数逆序后放入一数组中（要求递归实现） 例如 : 1234 变为 {4,3,2,1} */  
  2. public static int inverse(int[] result,int number,int i){  //4321  
  3.     if(i<result.length){  
  4.         int value = number%10;  
  5.         result[i] = value;  
  6.         number = (number-number%10)/10;  
  7.         return inverse(result,number,i+1);  
  8.     }else{  
  9.         return 0;  
  10.     }  
  11. }  

   

Java代码  收藏代码
  1. /* 递归实现回文判断（如：abcdedbca就是回文字符串）  */  
  2. public static boolean loopword(String str,int i){  
  3.     if(str.charAt(i) == str.charAt(str.length()-i-1)){  
  4.         if(i==(str.length()-1)/2) return true;  
  5.         return loopword(str,i+1);  
  6.     }else{  
  7.         return false;  
  8.     }  
  9. }  

 

Java代码  收藏代码
  1. /* 反转字符串(如：abcdef反转后为fedcba)  */  
  2. public static String reverseString(String str){  
  3.     if(str.length()==0) return str;  
  4.     return reverseString(str.substring(1)) + str.charAt(0) ;  
  5. }  

二、字符串（包含中文）切割

 截取字符串时候，里面有中文和字母相结合时候(如：abc我d是中df国人)，怎么合理进行切割使得不会切割出来半个汉字。只需要记住两点：

1、汉字的字节数<0；

2、汉字在gbk编码中，占用2个字节；在utf-8编码中，占用3个字节。

Java代码  收藏代码
  1. public static String splitStr(String str,int len) throws Exception{    
  2.        byte[] bt = str.getBytes("gbk");    
  3.        int wordIndex = 0,chineseIndex = 0,count = 0;    
  4.        if(bt.length > len){    
  5.            for(int index = 0;index < len; index++){  
  6.                if(bt[index] < 0){  //汉字的byte<0   
  7.                //在gbk编码，汉字占用2个字节；utf-8编码，汉字占3个字节;若字符集编码为utf-8，count%3。    
  8.                    if(++count > 0 && count%2 == 0){  
  9.                        chineseIndex++;    
  10.                    }    
  11.                }else{   //英文byte>0    
  12.                    wordIndex++;    
  13.                }    
  14.            }    
  15.            return str.substring(0, wordIndex + chineseIndex);    
  16.        }else{    
  17.            return "字符截取数太大。";    
  18.        }    
  19.    }  

 转载至：http://aokunsang.iteye.com/blog/690084

阅读全文
0 0
淘宝店打折怎么设置 淘宝店打折怎么设置
原创粉丝点击
热门IT博客
形式与政策 网络强国形式与政策 网络强国
淘宝手机上架淘宝手机上架
nginx php 403
python编辑器 linux
原生js实现数据绑定
怎么提高编程打字速度
淘宝sku怎么设置
云计算现状
账户数据库设计
崩坏3矩阵怎么回血
魔蝎数据科技
怎样在官网下载java
淘宝创建子帐号
pp盘古越狱 mac版
便携水杯推荐知乎
原语在c语言
初学者吉他知乎
java 1 true false
易语言彩票表格源码
java接口协议有哪些
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 红河去野多少钱一盒 去脸色暗黄 硅胶手机壳去黄小妙招 重庆抑郁a去黄泥磅 黄花溪几月份去合适 射逬去黄阿姨会怀孕 衣服黄渍小妙招 衣服去黄渍小妙招 衣服去黄小妙招小苏打 小白鞋去黄小妙招 臭小子快拔去黄阿姨 哪种牙膏去黄效果好 去黄 怎么去掉牙黄 皮肤太黄怎么办 皮肤很黄怎么办 皮肤如何去黄 怎么去黄美白 怎么去黄 美白去黄 去黄气 去黄美白 怎样去黄美白皮肤 美白去黄的护肤产品哪些好 去黄面膜 脸上去黄用什么好 怎样去牙黄 如何去黄 如何去脸黄 去黄美白提亮肤色 脸色去黄 去黄美白产品哪个好 美白去黄护肤品排行 补水去黄面膜哪种好 什么牙膏去黄效果好 去黄产品 黄雀斑怎么去除 皮肤怎么去黄 脸去黄 去黄的护肤品哪个好 花酿去黄面膜怎么样

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里