/*
验证商品上的条形码真伪的算法。很实用的，版主求打发点。

   编程验证EN13条码真伪
        "6921317905038"
         计算13条码前12位奇数位数字的和，sum1
         计算13条码前12位偶数位数字的和，sum2
         int sum = sum1+sum2*3
         将结果%10,int r = sum%10;
         int result = 10-r;
         return result==(code.charAt(12)-'0');
         返回值类型：boolean
         参数：String        
         */
class EN13
{
         public static void main(String[] args)
         {
                 System.out.println(checkEN("6901028000826"));
                 
                 String code =  "6901028000826";
                 System.out.println(code);
                 
                 int sum1 = 0;
                 int sum2 = 0;
                 for(int i =0;i<code.length()-1;i++)
                 {
                         int num = code.charAt(i)-'0';
                 System.out.print(num);
                 }

                 
         }

         public static boolean checkEN(String code)
         {
                 int sum1 = 0;
                 int sum2 = 0;
                 for(int i =0;i<12;i++)
                 {
                         int num = code.charAt(i)-'0';
                         if(i%2==0)
                                 sum1 = sum1+num;
                         else
                                 sum2 = sum2+num;
                 }
                 int sum = sum1+sum2*3;
                 int c = 10-sum%10;
                 return c ==(code.charAt(12)-'0');
         }
}

/*
需求:使用if模拟实现用户登录功能
帐号,密码,验证码
字符代替
*/

import java.util.*;
class Demo09
{
        public static void main(String[] args)
        {
                Scanner sc = new Scanner(System.in);
                System.out.print("请输入用户名: ");
                String userName = sc.next();
                System.out.print("请输入密码: ");
                String passWord = sc.next();
                System.out.print("请输入验证码: ");
                String checkCode = sc.next();

                if("aaa".equals(userName))
                {
                        if("aaa".equals(passWord))
                        {
                                if("abcd".equals(checkCode))
                                        {
                                        System.out.println("登录成功");
                                        }
                                else
                                {
                                        System.out.println("验证码错误!");
                                }
                        }
                                else
                                {
                                        System.out.println("密码错误!");
                                }
                        }


                                else
                                        {
                                        System.out.println("用户名不存在!");
                                        }
                       
                       
               
                       
                       
        }
}

实现一个整数的倒置  1234


import java.util.*;
class ZuoYe
{
        public static void main(String[] args)
        {
               
                Scanner sc = new Scanner(System.in);
                        System.out.print("输入一个数据: ");
                int x = sc.nextInt();
                int y = daozhi(x);
                System.out.println("倒置后的数据: "+y);
               
        }

        public static int daozhi(int num)
        {
                int newNum = 0;
                while(true)
                {
                        newNum = num%10 + newNum*10;
                        num = num/10;
                        if (num==0)
                        {
                                break;
                        }
                       
                }
                return newNum;
        }
       
}

//排序算法很多，哪一种算法性能最高？？？测试排序性能



import java.util.*;
class Demo08
{
        public static void main(String[] args)
        {
                int[] arr = {12,23,11,9,3,6,20,1};
                System.out.println("排序前："+Arrays.toString(arr));
           //selectSort(arr);
                //bubbleSort(arr);
                Arrays.sort(arr);
                System.out.println("排序后："+Arrays.toString(arr));

               

                Random r = new Random();
                int[] arr1 = new int[10000];
                for(int i=0;i<arr1.length;i++){
                        arr1[i] = r.nextInt(arr1.length);
                }

                long start = System.currentTimeMillis();
                selectSort(arr1);
                long end = System.currentTimeMillis();
                System.out.println("算法排序使用时间："+(end-start));

                start = System.currentTimeMillis();
                Arrays.sort(arr1);
                end = System.currentTimeMillis();
                System.out.println("API排序使用时间："+(end-start));

               
        }
        //定义一个方法，实现选择排序
        /*
                结果：没有，void
                参数：数组
        */
        public static void selectSort(int[] arr){
                for(int i = 0;i<arr.length-1;i++){
                        for(int j = i+1;j<arr.length;j++){//j=1,j<8,1~7//   j=2,2~6
                                if(arr[i]>arr[j]){
                                        int temp = 0;
                                        temp = arr[i];
                                        arr[i] = arr[j];
                                        arr[j] = temp;
                                }
                        }
                }
        }
        /*
                定义一个方法，实现冒泡法排序
                思路：
                结果：没有，void
                参数：数组
        */
        public static void bubbleSort(int[] arr){
                for(int i = 0;i<arr.length-1;i++){
                        for(int j = 0;j<arr.length-i-1;j++){
                                if(arr[j]>arr[j+1]){
                                        int temp = 0;
                                        temp = arr[j];
                                        arr[j] = arr[j+1];
                                        arr[j+1] = temp;
                                }
                        }
                       
                }
        }
}

选择排序 Selection Sort：选择排序的基本思想是：对待排序的记录序列进行n-1遍的处理，第1遍处理是将L[1..n]中最小者与L[1]交换位置，第2遍处理是将L[2..n]中最小者与L[2]交换位置，......，第i遍处理是将L[i..n]中最小者与L交换位置。这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。　　当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。
算法如下：

1. void doChooseSort(int[] src) {
   
2.                 int len = src.length;
   
3.                 int temp;
   
4.                 for (int i = 0; i < len; i++) {
   
5.                         temp = src[i];
   
6.                         int j;
   
7.                         int samllestLocation = i;// 最小数的下标
   
8.                         for (j = i + 1; j < len; j++) {
   
9.                                 if (src[j] < temp) {
   
10.                                         temp = src[j];// 取出最小值
    
11.                                         samllestLocation = j;// 取出最小值所在下标
    
12.                                 }
    
13.                         }
    
14.                         src[samllestLocation] = src[i];
    
15.                         src[i] = temp;
    
16.                         print(i, src);
    
17.                 }
    
18.         }

复制代码

堆排序是一种树形选择排序，是对直接选择排序的有效改进。堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。   
  

1. //堆排序
   
2. import java.util.Arrays;        
   
3. publicclass HeapSort {   
   
4.       inta[]={49,38,65,97,76,13,27,34,15,35,25,53,51};
   
5.       public  HeapSort(){   
   
6.          heapSort(a);   
   
7.       }   
   
8.      public  void heapSort(int[] a){   
   
9.          System.out.println("开始排序");   
   
10.          int arrayLength=a.length;   
    
11.          //循环建堆     
    
12.          for(int i=0;i<arrayLength-1;i++){   
    
13.              //建堆   
    
14.              buildMaxHeap(a,arrayLength-1-i);   
    
15.              //交换堆顶和最后一个元素   
    
16.              swap(a,0,arrayLength-1-i);   
    
17.              System.out.println(Arrays.toString(a));   
    
18.          }   
    
19.      }   
    
20.      private  void swap(int[] data, int i, int j) {   
    
21.          // TODO Auto-generated method stub   
    
22.          int tmp=data[i];   
    
23.          data[i]=data[j];   
    
24.          data[j]=tmp;   
    
25.      }   
    
26.    
    
27.      //对data 数组从0到lastIndex 建大顶堆   
    
28.      privatevoid buildMaxHeap(int[] data, int lastIndex) {   
    
29.          // TODO Auto-generated method stub   
    
30.          //从lastIndex 处节点（最后一个节点）的父节点开始   
    
31.    
    
32.          for(int i=(lastIndex-1)/2;i>=0;i--){   
    
33.              //k 保存正在判断的节点   
    
34.              int k=i;   
    
35.              //如果当前k节点的子节点存在   
    
36.              while(k*2+1<=lastIndex){   
    
37.                  //k 节点的左子节点的索引   
    
38.                  int biggerIndex=2*k+1;   
    
39.                  //如果biggerIndex 小于lastIndex，即biggerIndex+1 代表的k 节点的右子节点存在
    
40.                  if(biggerIndex<lastIndex){   
    
41.                      //若果右子节点的值较大   
    
42.                      if(data[biggerIndex]<data[biggerIndex+1]){   
    
43.                          //biggerIndex 总是记录较大子节点的索引   
    
44.                          biggerIndex++;   
    
45.                      }   
    
46.                  }   
    
47.    
    
48.                  //如果k节点的值小于其较大的子节点的值   
    
49.                 if(data[k]<data[biggerIndex]){   
    
50.                      //交换他们   
    
51.                      swap(data,k,biggerIndex);   
    
52.                      //将biggerIndex 赋予k，开始while 循环的下一次循环，重新保证k节点的值大于其左右子节点的值
    
53.                      k=biggerIndex;   
    
54.                  }else{   
    
55.                      break;   
    
56.                  }   
    
57.              }   
    
58.          }   
    
59.      }   
    
60. }  

复制代码

归并排序法是将两个（或两个以上）有序表合并成一个新的有
序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并
为整体有序序列。

1. //归并排序
   
2. import java.util.Arrays;        
   
3.   publicclass mergingSort {        
   
4.   int a[]={49,38,65,97,76,13,35,25,53,51};      
   
5.   publicmergingSort(){   
   
6.       sort(a,0,a.length-1);   
   
7.       for(int i=0;i<a.length;i++)   
   
8.         System.out.println(a[i]);   
   
9. }   
   
10.    
    
11. publicvoid sort(int[] data, int left, int right) {   
    
12.      // TODO Auto-generatedmethod stub   
    
13.      if(left<right){   
    
14.          //找出中间索引   
    
15.          int center=(left+right)/2;   
    
16.          //对左边数组进行递归   
    
17.          sort(data,left,center);   
    
18.          //对右边数组进行递归   
    
19.          sort(data,center+1,right);   
    
20.          //合并   
    
21.          merge(data,left,center,right);         
    
22.      }   
    
23. }      
    
24. publicvoid merge(int[] data, int left, int center, int right) {   
    
25.      // TODO Auto-generatedmethod stub   
    
26.      int [] tmpArr=newint[data.length];   
    
27.      int mid=center+1;   
    
28.      //third 记录中间数组的索引   
    
29.      int third=left;   
    
30.      int tmp=left;   
    
31.      while(left<=center&&mid<=right){   
    
32.          //从两个数组中取出最小的放入中间数组   
    
33.          if(data[left]<=data[mid]){   
    
34.              tmpArr[third++]=data[left++];   
    
35.          }else{   
    
36.              tmpArr[third++]=data[mid++];   
    
37.          }   
    
38.      }   
    
39.      //剩余部分依次放入中间数组   
    
40.      while(mid<=right){   
    
41.          tmpArr[third++]=data[mid++];   
    
42.      }   
    
43.      while(left<=center){   
    
44.          tmpArr[third++]=data[left++];   
    
45.      }   
    
46.      //将中间数组中的内容复制回原数组   
    
47.      while(tmp<=right){   
    
48.          data[tmp]=tmpArr[tmp++];   
    
49.      }   
    
50.      System.out.println(Arrays.toString(data));   
    
51. }   
    
52. }   

复制代码

基数排序：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面
补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成
以后,数列就变成一个有序序列。

1. //基数排序
   
2.   import java.util.ArrayList;   
   
3.   import java.util.List;   
   
4.      
   
5.   public class radixSort {   
   
6.       inta[]={64,5,4,62,99,98,54,101,56,17,18};   
   
7.       public radixSort(){   
   
8.          sort(a);   
   
9.          for(inti=0;i<a.length;i++){   
   
10.                 System.out.println(a[i]);   
    
11.         }   
    
12.      }         
    
13.      public  void sort(int[] array){     
    
14.         //首先确定排序的趟数;     
    
15.         int max=array[0];     
    
16.         for(inti=1;i<array.length;i++){     
    
17.              if(array[i]>max){     
    
18.                max=array[i];     
    
19.              }     
    
20.         }     
    
21.         int time=0;     
    
22.         //判断位数;     
    
23.         while(max>0){     
    
24.            max/=10;     
    
25.             time++;     
    
26.         }         
    
27.          //建立10个队列;     
    
28.         List<ArrayList> queue=newArrayList<ArrayList>();     
    
29.         for(int i=0;i<10;i++){     
    
30.                ArrayList<Integer>queue1=new ArrayList<Integer>();   
    
31.             queue.add(queue1);     
    
32.         }         
    
33.         //进行time 次分配和收集;     
    
34.         for(int i=0;i<time;i++){     
    
35.             //分配数组元素;     
    
36.            for(intj=0;j<array.length;j++){     
    
37.                 //得到数字的第time+1 位数;   
    
38.                   int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
    
39.                   ArrayList<Integer>queue2=queue.get(x);   
    
40.                   queue2.add(array[j]);   
    
41.                   queue.set(x, queue2);   
    
42.            }   
    
43.            int count=0;//元素计数器;     
    
44.            //收集队列元素;     
    
45.            for(int k=0;k<10;k++){   
    
46.                 while(queue.get(k).size()>0){   
    
47.                     ArrayList<Integer>queue3=queue.get(k);   
    
48.                     array[count]=queue3.get(0);     
    
49.                     queue3.remove(0);   
    
50.                     count++;   
    
51.                 }     
    
52.            }     
    
53.         }               
    
54.      }   
    
55. }   

复制代码

用递归的方式实现字符串翻转。
public String reverserStr(String str){
int len=str.length;
if(len<=1){
return "";
}
int idx=len/2;
String str1=str.substring(0,idx);
String str2=str.subString(idx);
return reverserStr(str2)+reverserStr(str1);
}

快速排序算法
        public  static void doSort(int[] arr,int start ,int end){
                int len=end-start;
                if(len<=1){
                        return;
                }
                if(len<=1) return;
                int pivot=arr[start];
                int low=start;int high=end;
                while(low<high){
                while(arr[low]<=pivot&&low<high)
                        low++;
                while(arr[high]>=pivot&&low<high)
                        high--;
                swap(arr,low,high);
                }
                doSort(arr,start,low);
                doSort(arr,low,end);
        }

发一个经典的快速排序算法。

1. 
   
2. public class Quick {
   
3.        
   
4.         /**
   
5.          * 获取中轴
   
6.          * @param list
   
7.          * @param low
   
8.          * @param high
   
9.          * @return
   
10.          */
    
11.         public static int getMiddle(Integer[] list, int low, int high) {
    
12.                 int tmp = list[low]; // 数组的第一个作为中轴
    
13.                 while (low < high) {
    
14.                         while (low < high && list[high] > tmp) {
    
15.                                 high--;
    
16.                         }
    
17.                         list[low] = list[high]; // 比中轴小的记录移到低端
    
18.                         while (low < high && list[low] < tmp) {
    
19.                                 low++;
    
20.                         }
    
21.                         list[high] = list[low]; // 比中轴大的记录移到高端
    
22.                 }
    
23.                 list[low] = tmp; // 中轴记录到尾
    
24.                 return low; // 返回中轴的位置
    
25.         }
    
26. 
    
27.         /**
    
28.          * 快速排序
    
29.          * @param list         排序数组
    
30.          * @param low        低值
    
31.          * @param high        高值
    
32.          */
    
33.         public static void quickSort(Integer[] list, int low, int high) {
    
34.                 if (low < high) {
    
35.                         int middle = getMiddle(list, low, high); // 将list数组进行一分为二
    
36.                         quickSort(list, low, middle - 1); // 对低值表进行递归排序
    
37.                         quickSort(list, middle + 1, high); // 对高值表进行递归排序
    
38.                 }
    
39.         }
    
40. 
    
41.         /**
    
42.          * 快速排序
    
43.          * @param str        需要被排序的数组
    
44.          */
    
45.         public static void quick(Integer[] str) {
    
46.                 // 查看数组是否为空
    
47.                 if (str.length > 0) {
    
48.                         quickSort(str, 0, str.length - 1);
    
49.                 }
    
50.         }
    
51. 
    
52.         /**
    
53.          * @param args
    
54.          */
    
55.         public static void main(String[] args) {
    
56.                 // TODO Auto-generated method stub
    
57.                 Integer[] list = { 33, 1, 43, 4, 63,25, 24, 11 };
    
58.                 quick(list);
    
59.                 for (int i = 0; i < list.length; i++) {
    
60.                         System.out.print(list[i] + " ");
    
61.                 }
    
62.                 System.out.println();
    
63.         }
    
64. 
    
65. }
    

复制代码

结束了啊，再整一次吧！！！

杨辉三角算法：
代码如下：
class YangHuiSanJiao
{
        public static void main(String[] args)
        {
                for(int i=0;i<=4;i++)//遍历幂数
                {
                        for(int m=5-i;m>0;m--)
                                System.out.print(" ");
                        for(int j=1;j<i+2;j++)//遍历列数
                                System.out.print(f(i,j)+" ");
                        System.out.println();
                }
        }
        /* 简单的杨辉三角
                        1
                   1  1
                  1  2  1
        */
        //f函数是杨辉三角的计算函数 其中x代表行 y代表列（递归实现）
        public static int f(int x,int y)
        {
                if((y==1)||(y==x+1))
                        return 1;
                return f(x-1,y-1)+f(x-1,y);
        }
}

结果图：

冒泡排序算法
class MaoPao
{
        public static void main(String[] args)
        {
                int[] arr={2,3,56,22,66,77,1};
                System.out.print("排序前"+": ");
                for(int a : arr)
                        System.out.print(a+" ");
                sort(arr);
                System.out.print("\n排序后"+": ");
                for(int a : arr)
                        System.out.print(a+" ");
        }
        //冒泡排序算法
        public static void sort(int[] arr)
        {
                for(int i=1;i<=arr.length-1;i++)//外层循环控制排序次数
                {
                        for(int j=0;j<arr.length-i;j++)//内层循环遍历数组进行比较，如果前面数大于后面数交换
                        {
                                if(arr[j]>arr[j+1])
                                {
                                        int temp=arr[j];
                                        arr[j]=arr[j+1];
                                        arr[j+1]=temp;
                                }
                        }
                }
        }
}

结果图：

算法有哈西算法，不易理解，很少人用