1. public class Test5 {
   
2.         public static void main(String args[]){
   
3.                
   
4.                 int arr[]={2,1,1,2,2,3,3,2};
   
5.                 int arr2[]={1,3,5,7,9};
   
6.                
   
7.                 int x=getIndex1(arr,2);
   
8.                 System.out.println(x);
   
9.                
   
10.                 int y=getIndex2(arr2,6);
    
11.                 System.out.println(y);
    
12.             y=getIndex2(arr2,8);
    
13.             System.out.println(y);
    
14.                
    
15.                 int valueIndex[]=getIndex3(arr,2);
    
16.                 for(int i=0;i<valueIndex.length;i++)
    
17.                         System.out.print(valueIndex[i]+" ");
    
18.         }
    
19.        
    
20. //        普通查找：遍历数组，在数组中查找第一次出现的与指定值相等的元素，获取其下标
    
21.        
    
22.         public static int getIndex1(int arr[],int value){
    
23.                 for(int i=0;i<arr.length;i++){
    
24.                         if(arr[i]==value){
    
25.                                 return i;
    
26.                         }
    
27.                 }
    
28.                 return -1;
    
29.         }
    
30.        
    
31.        
    
32. //    折半查找：
    
33.         public static int getIndex2(int[] arr,int value){
    
34.                 int min=0;
    
35.                 int max=arr.length-1;
    
36.                 int mid=(max+min)/2;
    
37. /*        //第一种方式
    
38.                 while(value!=arr[mid]){
    
39.                         if(value>arr[mid])      //当指定值大于中间值时，移动小角标
    
40.                                 min=mid+1;
    
41.                         else                    //当指定值小于中间值时，移动大角标
    
42.                                 max=mid-1;
    
43.                         mid=(min+max)/2;        //根据大小角标的值确定中间值
    
44.                        
    
45.                         if(max<min)             //当没有要找的值是返回-1
    
46.                                 return -1;
    
47.                 }
    
48.                
    
49.                 return mid;        */
    
50.                
    
51.         //第二种方式       
    
52.                 while(min<=max){
    
53.                         if(arr[mid]>value)
    
54.                                 max=mid-1;
    
55.                         else if(arr[mid]<value)
    
56.                                 min=mid+1;
    
57.                         else
    
58.                                 return mid;
    
59.                         mid=(max+min)>>1;
    
60.                 }
    
61.                 return -1;
    
62.         }
    
63. 
    
64.        
    
65. //        普通查找:遍历数组查找所有与指定值相等的元素，获取其下标
    
66.        
    
67.         public static int[] getIndex3(int[] arr,int value){
    
68.                
    
69.                 int j=0,k=0;
    
70.                 //        查找相同的数       
    
71.                 for(int i=0;i<arr.length;i++){
    
72.                         if(arr[i]==value){
    
73.                                 j++;        //用来记录有多少个元素与指定值相等
    
74.                         }
    
75.                 }
    
76.                 //根据j值建立数组
    
77.                 if(j>0){
    
78.                         int valueIndex1[]=new int[j];    //根据相等的元素个数建立数组
    
79.                         for(int i=0;i<arr.length;i++){
    
80.                                 if(arr[i]==value){
    
81.                                         valueIndex1[k]=i;
    
82.                                         k++;       
    
83.                                 }
    
84.                         }
    
85.                         return valueIndex1;
    
86.                 }
    
87.                 else{
    
88.                         int[] valueIndex2={-1};
    
89.                         return valueIndex2;
    
90.                 }
    
91.         }
    
92. 
    
93.        
    
94. 
    
95. }

复制代码

快速排序算法
快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
代码示例

1. public static void quickSort(int a[], int start, int end)
   
2. { int i,j;
   
3. i = start;
   
4. j = end;
   
5. if((a==null)||(a.length==0))
   
6. return;
   
7. while(i<j){
   
8. while(i<j&&a[i]<=a[j]){ //以数组start下标的数据为key，右侧扫描
   
9. j--;
   
10. }
    
11. if(i<j){ //右侧扫描，找出第一个比key小的，交换位置
    
12. int temp = a[i];
    
13. a[i] = a[j];
    
14. a[j] = temp;
    
15. }
    
16. while(i<j&&a[i]<a[j]){ //左侧扫描（此时a[j]中存储着key值）
    
17. i++;
    
18. }
    
19. if(i<j){ //找出第一个比key大的，交换位置
    
20. int temp = a[i];
    
21. a[i] = a[j];
    
22. a[j] = temp;
    
23. }
    
24. }
    
25. if(i-start>1){
    
26. //递归调用，把key前面的完成排序
    
27. quickSort(a,start,i-1);
    
28. }
    
29. if(end-i>1){
    
30. quickSort(a,i+1,end); //递归调用，把key后面的完成排序
    
31. }
    
32. }
    

复制代码

选择排序算法
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
排序实例
初始关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13 [38 65 97 76 49 27 49]
第二趟排序后 13 27 [65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
第四趟排序后 13 27 38 49 [76 97 65 49 ]
第五趟排序后 13 27 38 49 49 [97 65 76]
第六趟排序后 13 27 38 49 49 65 [97 76]
第七趟排序后 13 27 38 49 49 65 76 [97]
最后排序结果 13 27 38 49 49 65 76 97

1. public class sort {
   
2. 
   
3. public static void selectSort (int[] arr){ // 选择排序的具体实现
   
4. for(int x = 0; x < arr.length - 1; x++) {
   
5. for(int y = x + 1; y < arr.length; y++) {
   
6. change(arr, x, y);
   
7. printArray(arr);
   
8. }
   
9. }
   
10. }
    
11. 
    
12. public static void printArray(int[] arr) { //打印数组的方法
    
13. for(int x = 0; x < arr.length; x++) {
    
14. System.out.println(arr[x]);
    
15. }
    
16. }
    
17. 
    
18. public static void main(String args[]) {
    
19. int[] arr = new int[]{7,6,5,4,3,2,1}; //随变生成一个数组
    
20. selectSort(arr); //调用选择排序算法
    
21. 
    
22. }
    
23. 
    
24. 
    
25. public static void change(int[] arr, int x, int y) { //交换的方法
    
26. if(arr[x] > arr[y]) {
    
27. int temp = arr[x];
    
28. arr[x] = arr[y];
    
29. arr[y] = temp;
    
30. }
    
31. }
    
32. }

复制代码

        编程验证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');
        }
}

/*
演示随机抽取算法
机选双色球
*/


import java.util.*;
class  Demo07
{
        public static void main(String[] args)
        {
                String[] poor =
                        {"01","02","03","04","05","06","07","08","09","10",
                         "11","12","13","14","15","16","17","18","19","20",
                         "21","22","23","24","25","26","27","28","29","30",
                         "31","32","33"};
                String[] redBalls = ballsRandomSelect();
                Arrays.sort(redBalls);
                //随机获取蓝球号码
                Random r = new Random();
                int index = r.nextInt(16);
                String blueBall = poor[index];
                //定义一个数组存所有号码
                String[] balls = new String[7];
                //将随机获取的一组红球号码复制到balls中
                System.arraycopy(redBalls,0,balls,0,redBalls.length);
                balls[6] = blueBall;
                System.out.println(Arrays.toString(balls));
        }

        public static String[] ballsRandomSelect()
        {
                String[] poor =
                        {"01","02","03","04","05","06","07","08","09","10",
                         "11","12","13","14","15","16","17","18","19","20",
                         "21","22","23","24","25","26","27","28","29","30",
                         "31","32","33"};
                boolean[] flags = new boolean[poor.length];
                String[] balls = new String[6];
                Random r = new Random();
                int i = 0;
                for (; ; )
                {
                        int index = r.nextInt(poor.length);
                        if(!flags[index])
                        {
                                balls[i++] = poor[index];
                                flags[index] = true;
                        }
                        if(i==6)
                        {
                                break;
                        }
                }
                return balls;
        }
}

//打印空心菱形

class Demo07
{
        public static void main(String[] args)
        {
                for (int x = 1;x <= 5 ;x++ ) {
                        for (int y = x;y <= 4 ;y++ ) {
                                System.out.print(" ");
                        }
                        for (int z = 1;z <= x ;z++ ) {
                                if (z == 1 || z == x) {
                                        System.out.print("* ");
                                }else {
                                        System.out.print("  ");
                                }
                               
                        }
                        System.out.println();
                }

                for (int a = 1; a <= 4;a++ ) {
                        for (int b = 1;b <= a ;b++ ) {
                                System.out.print(" ");
                        }
                        for (int c = a;c <= 4 ;c++ ) {
                                if (c == a || c == 4) {
                                        System.out.print("* ");
                                }else {
                                        System.out.print("  ");
                                }
                               
                        }
                        System.out.println();
                }
        }

}

刚看到这,现学现用,讲十进制转成二进制.

1. /*
   
2. 十进制转二进制
   
3. */
   
4. import java.util.*;
   
5. class Demo03
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 //创建用户键盘扫描;
   
10.                 Scanner sc = new Scanner(System.in);
    
11.                 System.out.println("请输入一个整数: ");
    
12.                 //获取用户输入的数据;
    
13.                 int x = sc.nextInt();
    
14.                 toBin(x);
    
15.         }
    
16.         //定义一个十进制转二进制的方法.
    
17.         public static void toBin(int num)
    
18.         {
    
19.                 //存放数据的容器;
    
20.                 StringBuffer sb = new StringBuffer();
    
21.                 while (num>0)
    
22.                 {
    
23.                         //向容器中添加num%2的结果;
    
24.                         sb.append(num%2);
    
25.                         num/=2;
    
26.                 }
    
27.                 //倒着打印sb中的数据.
    
28.                 System.out.println(sb.reverse());
    
29.         }
    
30. }
    

复制代码

//斗地主发牌算法


import java.util.*;
class  Demo
{
public static void main(String[] args)
{
String[] card=new String[]{"A","2","3","4","5","6","7","8","9","10","J","Q","K","queen","king"};
        char mark[]=new char[]{3,4,5,6};
        String.valueOf(mark);
        String[] cardList=new String[54];
String[] redHeartCard=new String[13];
String[] squareCard=new String[13];
String[] clubCard=new String[13];
String[] spadeCard=new String[13];
for(int i=0;i<card.length-2;i++)
{
              redHeartCard[i]=mark[0]+card[i];
              squareCard[i]=mark[1]+card[i];
              clubCard[i]=mark[2]+card[i];
              spadeCard[i]=mark[3]+card[i];
}
        System.arraycopy(card,13,cardList,52,2);
System.arraycopy(redHeartCard,0,cardList,0,13);
        System.arraycopy(squareCard,0,cardList,13,13);
System.arraycopy(clubCard,0,cardList,26,13);
        System.arraycopy(spadeCard,0,cardList,39,13);
        System.out.println("洗牌前:"+Arrays.toString(cardList));
upsite(cardList);
        System.out.println("==========================================================");
        System.out.println("洗牌后:"+Arrays.toString(cardList));
         System.out.println("==========================================================");
String[] player1=new String[17];
        String[] player2=new String[17];
        String[] player3=new String[17];
String[] cosineCard=new String[3];
System.arraycopy(cardList,51,cosineCard,0,3);
int i=0;
while(i<=cardList.length){
if(i%3==0){
               for(int j=i/3;j<player1.length;j++)
{
                     player1[j]=cardList[i];
    }
}else if(i%3==1){
for(int j=i/3;j<player2.length;j++)
{
                     player2[j]=cardList[i];
    }
}else{
                for(int j=i/3;j<player3.length;j++)
{
                     player3[j]=cardList[i];
    }
}
i++;
}
System.out.println("玩家1："+Arrays.toString(player1));
                 System.out.println("玩家2："+Arrays.toString(player2));
                System.out.println("玩家3："+Arrays.toString(player3));
System.out.println("底牌:"+Arrays.toString(cosineCard));
}
//定义洗牌方法
public static void upsite(String[] array)
{
        Random r=new Random();
int index=r.nextInt(array.length);
for(int i=array.length-1;i>=0;i--)
{
for(int j=i;j<=array.length-1;j++)
{
String temp=null;
    temp=array[j];
    array[j]=array[index];
    array[index]=temp;
}
}
}
}

一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。

1. public class NinthWanshu {
   
2. public static void main(String[] args) {   
   
3.    System.out.println("1到1000的完数有： ");    for(int i=1; i<1000; i++) {     int t = 0;
   
4.     for(int j=1; j<= i/2; j++) {      if(i % j == 0) {
   
5. t = t + j;
   
6.      }     }
   
7.     if(t == i) {
   
8.      System.out.print(i + " ");     }    }
   
9. } }

复制代码

递归是程序调用自身的过程，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。

1. public class RecursionDemo {                     
   
2.     public static int getsum(int a){  
   
3.         if (a==1)   
   
4.             return 1;  
   
5.             return a+getsum(a-1);  
   
6.     }  
   
7.     public static void main(String[] args) {  
   
8.         int a=getsum(5);  
   
9.         System.out.println("a="+a);  
   
10.     }  
    
11. }  

复制代码

一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
1.程序分析：在10万以内判断，先将该数加上100后再开方，再将该数加上268后再开方， 如果开方后的结果满足如下条件，即是结果。请看具体分析：

1. public class ThirteenthTwiceSqrt {
   
2. public static void main(String[] args) {   
   
3. for(long l=1L; l<100000; l++) {
   
4.     if(Math.sqrt((long)(l+100)) % 1 == 0) {     
   
5. if(Math.sqrt((long)(l+268)) % 1 == 0) {
   
6.       System.out.println(l + "加100是一个完全平方数，再加168又是一个完全平方数");  
   
7.     }
   
8.     }  
   
9.   }
   
10. } }

复制代码

求阶乘

1. //递归算法
   
2. //求阶乘
   
3. import java.io.*;
   
4. public class DiGui
   
5. {
   
6. 　public static void main(String args[])
   
7. 　{ 　
   
8. 　　int i=0; 　
   
9. 　char ch=' '; 　
   
10. 　String s; 　
    
11. 　Child ren=new Child(); 　
    
12. 　try 　
    
13. 　{ 　
    
14. 　　System.out.println("Please intput a Number,End whit '#'"); 　　　　
    
15. 　　do
    
16. 　　{ 　　　　
    
17. BufferedReader br=new BufferedReader(new InputStreamReaderSystem.in));
    
18. 　　　
    
19. 　s =br.readLine(); 　　　　
    
20. 　i=Integer.parseInt(s); 　　　　
    
21. 　System.out.println(ren.Factorial(i)); 　　
    
22. 　　}
    
23. 　while(ch!='#'); 　
    
24. 　}catch(IOException e){}
    
25. 　}
    
26. }
    
27. class Child
    
28. {
    
29. double Factorial(int n)
    
30. 　{
    
31. 　if (n==1) 　
    
32. 　　　return 1;
    
33. 　else 　
    
34. 　　　return n*Factorial(n-1);
    
35. 　}
    
36. }

复制代码

两种算法求最大公约数

1. class greatestCommonDiv{
   
2. private int larger;
   
3. private int smaller;
   
4. public greatestCommonDiv(int larger, int smaller){
   
5.    this.larger=larger;
   
6.    this.smaller=smaller;
   
7. }
   
8. public int getGreatestComDiv(int number1,int number2){
   
9. if(number1>number2){
   
10. larger=number1;
    
11. smaller=number2;
    
12. }
    
13. else{
    
14. larger=number2;
    
15. smaller=number1;
    
16. }
    
17. //常规算法
    
18.    for(int index=2;index<=smaller;index++){
    
19.                    if((smaller&&index==0)&&(larger&&index==0))
    
20.                       return index;
    
21.      }
    
22. 
    
23.    }
    
24. public int getGreatestCom1(int number1,int number){
    
25. // 辗转相减法
    
26.     while (number1!= number2) {
    
27.         if (number1> number2)
    
28.             number1= number1- number2;
    
29.         else
    
30.             number2= number2- number1;
    
31.     }
    
32.     return number1;
    
33. 
    
34. 
    
35. 
    
36. }
    
37. 
    
38. }

复制代码

1. 
   
2. /*
   
3. * 不好意思,来晚了,19号开的课,在传智参加java基础班,为了进黑马云9期,加油!
   
4. * 以下是从毕老师视频里学到的几个基础算法:
   
5. * 冒泡排序：相邻两个元素进行比较，满足条件换位。
   
6. * 选择排序：选择一元素，不停地与其他元素比较，满足条件换位。
   
7. */
   
8. public class RankLearning {
   
9.         public static void main(String args[]){
   
10.                 int[] arr1={1,3,5,6,2,4};
    
11.                 int[] arr2={3,1,5,6,2,4};
    
12.                 int[] arr3={3,1,5,6,2,4};
    
13.                
    
14.                 rankArray1(arr1);
    
15.                
    
16.                 rankAaary2(arr2);
    
17.                
    
18.                 Arrays.sort(arr3);   //指定一数组排序
    
19.                
    
20.                 for(int i=0;i<arr3.length;i++){
    
21.                         System.out.print(arr3[i]+" ");
    
22.                         
    
23.                 }
    
24.         }
    
25. 
    
26.         
    
27. //        冒泡排序
    
28.         public static void rankArray1(int[] arr){
    
29.                 for(int i=0;i<arr.length-1;i++){      
    
30.                         for(int j=0;j<arr.length-1-i;j++){   
    
31.                                 if(arr[j]>arr[j+1]){    //总是比较相邻元素大小，并把每次比较的最大值放在比较的元素的最末尾
    
32.                                         swap(arr,j,j+1);
    
33.                                 }
    
34.                         }
    
35.                 }
    
36.                 for(int i=0;i<arr.length;i++){
    
37.                         System.out.print(arr[i]+" ");
    
38.                 }
    
39.                 System.out.println();
    
40.                         
    
41.         }
    
42.         
    
43. //        选择排序
    
44.         public static void rankArray2(int[] arr){
    
45.                 for(int i=0;i<arr.length-1;i++){   
    
46.                         for(int j=1+i;j<arr.length;j++){
    
47.                                 if(arr[i]>arr[j])  //总是拿一指定角标元素和其后元素比较
    
48.                                 {
    
49.                                         swap(arr,i,j);
    
50.                                 }
    
51.                         }
    
52.                 }
    
53.                 for(int i=0;i<arr.length;i++)
    
54.                         System.out.print(arr[i]+" ");
    
55.                 System.out.println();
    
56.         }
    
57.         
    
58. //        位置置换(形参：指定数组，指定换位的两个下标)
    
59.         public static void swap(int[] array,int a,int b){
    
60.                 int temp;
    
61.                 temp=array[a];
    
62.                 array[a]=array[b];
    
63.                 array[b]=temp;        
    
64.         }
    
65. }

复制代码

1. /*
   
2. * 不好意思,来晚了,19号开的课,在传智参加java基础班,为了进黑马云9期,加油!
   
3. * 以下是从毕老师视频里学到的几个基础算法:
   
4. */
   
5. public class LookingForElemet {
   
6.         public static void main(String args[]){
   
7.                
   
8.                 int arr[]={2,1,1,2,2,3,3,2};
   
9.                 int arr2[]={1,3,5,7,9};
   
10.                
    
11.                 int x=getIndex1(arr,2);
    
12.                 System.out.println(x);
    
13.                
    
14.                 int y=getIndex2(arr2,6);
    
15.                 System.out.println(y);
    
16.                                 y=getIndex2(arr2,8);
    
17.                                 System.out.println(y);
    
18.                
    
19.                 int valueIndex[]=getIndex3(arr,2);
    
20.                 for(int i=0;i<valueIndex.length;i++)
    
21.                 System.out.print(valueIndex[i]+" ");
    
22.         }
    
23.         
    
24. //        普通查找：遍历数组，在数组中查找第一次出现的与指定值相等的元素，获取其下标
    
25.         
    
26.         public static int getIndex1(int arr[],int value){
    
27.                 for(int i=0;i<arr.length;i++){
    
28.                         if(arr[i]==value){
    
29.                                 return i;
    
30.                         }
    
31.                 }
    
32.                 return -1;
    
33.         }
    
34.         
    
35.         
    
36. //    折半查找：
    
37.         public static int getIndex2(int[] arr,int value){
    
38.                 int min=0;
    
39.                 int max=arr.length-1;
    
40.                 int mid=(max+min)/2;
    
41. /*        //第一种方式
    
42.                 while(value!=arr[mid]){
    
43.                         if(value>arr[mid])      //当指定值大于中间值时，移动小角标
    
44.                                 min=mid+1;
    
45.                         else                    //当指定值小于中间值时，移动大角标
    
46.                                 max=mid-1;
    
47.                         mid=(min+max)/2;        //根据大小角标的值确定中间值
    
48.                         
    
49.                         if(max<min)             //当没有要找的值是返回-1
    
50.                                 return -1;
    
51.                 }
    
52.                
    
53.                 return mid;        */
    
54.                
    
55.         //第二种方式        
    
56.                 while(min<=max){
    
57.                         if(arr[mid]>value)
    
58.                                 max=mid-1;
    
59.                         else if(arr[mid]<value)
    
60.                                 min=mid+1;
    
61.                         else
    
62.                                 return mid;
    
63.                         mid=(max+min)>>1;
    
64.                 }
    
65.                 return -1;
    
66.         }
    
67. 
    
68.         
    
69. //        普通查找:遍历数组查找所有与指定值相等的元素，获取其下标
    
70.         
    
71.         public static int[] getIndex3(int[] arr,int value){
    
72.                
    
73.                 int j=0,k=0;
    
74.                 //        查找相同的数        
    
75.                 for(int i=0;i<arr.length;i++){
    
76.                         if(arr[i]==value){
    
77.                                 j++;        //用来记录有多少个元素与指定值相等
    
78.                         }
    
79.                 }
    
80.                 //根据j值建立数组
    
81.                 if(j>0){
    
82.                         int valueIndex1[]=new int[j];    //根据相等的元素个数建立数组
    
83.                         for(int i=0;i<arr.length;i++){
    
84.                                 if(arr[i]==value){
    
85.                                         valueIndex1[k]=i;
    
86.                                         k++;        
    
87.                                 }
    
88.                         }
    
89.                         return valueIndex1;
    
90.                 }
    
91.                 else{
    
92.                         int[] valueIndex2={-1};
    
93.                         return valueIndex2;
    
94.                 }
    
95.         }     
    
96. 
    
97. }

复制代码

希尔排序法是基于插入排序法改变，大大提供了插入排序的执行效率

1. class ShellSort{
   
2. 
   
3.    private int[] theArray;
   
4.    private int nElems;
   
5.    public ShellSort(int length, int[] array){
   
6.     this.theArray=array;
   
7.     this.nElems=length;
   
8.    }
   
9. 
   
10. public int[] shellSort(){
    
11.      int inner, outer, temp;
    
12. 
    
13.       int h=1
    
14.       while(h<=nElems/3)h=h*3+1;
    
15.    while(h>0){
    
16.           for(outer=h; outer<nElems; outer++){
    
17.          temp=theArray[outer];
    
18.          inner=outer;
    
19.          while(inner>h-1&&theArray[inner-h]>=temp){
    
20.           theArray[inner]=theArray[inner-h];
    
21.           inner-=h;
    
22.            }
    
23.          theArray[inner]=temp;
    
24.     }
    
25.     h=(h-1)/3;
    
26.      }
    
27.       return theArray;
    
28.    }
    
29. }
    

复制代码

刘旭升 发表于 2014-2-19 21:53
写一个我以前自己写的一个方法：我觉得写的很好。 呵呵

这不是我的基础测试题吗？
看我的代码：

1. package com.itheima;
   
2. 
   
3. /**
   
4. *第8题： 数组去重
   
5. * 例如:
   
6. * 原始数组是{4,2,4,6,1,2,4,7,8}
   
7. * 得到结果{4,2,6,1,7,8}
   
8. *
   
9. * @author shine
   
10. *
    
11. */
    
12. import java.util.Arrays;
    
13. 
    
14. public class Test8 {
    
15.         public static void main(String[] args){
    
16.                 int[] ints = {2,24,24,3,2,24,32,54,6,5,3,7,7,12};//定义一个数组，并对其进行赋值
    
17.                 int[] newints = removeduplication(ints);//调用removeduplication对数组进行去重
    
18.                 System.out.println(Arrays.toString(newints));
    
19.         }
    
20.         //该方法用于对数组进行去重
    
21.         public static int[] removeduplication(int[] ints){
    
22.                 int l = 0;
    
23.                 int[] tempints = new int[ints.length];
    
24.                 out: for(int i=0; i<ints.length; i++){
    
25.                         //对当前数组进行遍历，如果单签元素不与tempints中的已有元素相等则将其添加到tempints中去
    
26.                         for(int n=0; n<l; n++){
    
27.                                 if(tempints[n]==ints[i])
    
28.                                         continue out;
    
29.                         }
    
30.                         tempints[l++] = ints[i];
    
31.                 }
    
32.                 //取tempints的“有效长度”，并赋值于新数组newints
    
33.                 int[] newints = new int[l];
    
34.                 for(int i=0; i<l ;i++){
    
35.                         newints[i] = tempints[i];
    
36.                 }
    
37.                 return newints;//返回去重，并取合适长度的新数组
    
38.         }
    
39. }
    

复制代码

张稳 发表于 2014-2-22 15:40
希尔排序法是基于插入排序法改变，大大提供了插入排序的执行效率

话说我几天刚练过

1. /**
   
2. 我对希尔排序的粗浅理解：
   
3.         先对数组中小标间隔为一定值的数进行排序
   
4.         而后逐渐缩小这种间隔，直至间隔为1，完成排序
   
5. @author shine
   
6. */
   
7. import java.util.Arrays;
   
8. public class Shine01{
   
9.         public static void main(String[] args){
   
10.                 int[] ints = {12,34,5,54,35,2,78,62,85,35,9,6,18,24,38,42};
    
11.                 System.out.println(Arrays.toString(order(ints)));
    
12.         }
    
13.         public static int[] order(int[] ints){
    
14.                 int d = ints.length;
    
15.                 while(true){
    
16.                         d = d/2;
    
17.                         for(int i=0; i<d; i++){
    
18.                                 //下面这个嵌套for循环实际上实现了...>a[i+2d]>=a[i+d]>=a[i]的功能
    
19.                                 for(int j=i+d; j<ints.length; j+=d){
    
20.                                         int temp = ints[j];
    
21.                                         int k;
    
22.                                         for(k=j-d; k>=0&&ints[k]>temp; k-=d){
    
23.                                                 ints[k+d] = ints[k];
    
24.                                         }
    
25.                                         ints[k+d] = temp;
    
26.                                 }
    
27.                         }
    
28.                         //具体实现方法如下：
    
29.                         //首先保证所有下标间隔为d的数间的排序，如：a[8]>a[0],a[9]>a[1],a[10]>a[2]……
    
30.                         //随后缩小下标的间隔，如：a[12]>a[8]>=a[4]>=a[0],a[13]>a[9]>=a[5]>=a[1]……
    
31.                         //并进一步缩小，如：a[14]>a[12]>a[10]>a[8]>a[6]>a[4]>a[2]>a[0],……
    
32.                         //直至d=1，即：a[15]>a[14]>a[13]>a[12]>……，至此排序完成
    
33.                         if(d==1)
    
34.                                 return ints;
    
35.                 }
    
36.         }
    
37. }

复制代码

//查表法


class Demo7 {
        public static void main(String[] args) {
                toHex(0);
        }


        public static void toHex(int num) {
                if (num == 0) {
                        System.out.println('0');
                        return;
                }
                //定义一个表
                char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
                //                           0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15
                //定义一个空的字符数组
                char[] arr = new char[8];
                //定义一个指针
                int pos = arr.length - 1;
                //定义循环
                while(num != 0) {
                        int temp = num & 15;
                        arr[pos] = chs[temp];
                        pos--;
                        num = num >>> 4;
                }

                for (int x = pos + 1;x < arr.length ;x++ ) {
                        System.out.print(arr[x]);
                }
        }
}

1. /**
   
2.          * 冒泡排序
   
3.          *
   
4.          * @paramsrc待排序数组
   
5.          */
   
6.         void doBubbleSort(int[] src) {
   
7.                 int len = src.length;
   
8.                 for (int i = 0; i < len; i++) {
   
9.                         for (int j = i + 1; j < len; j++) {
   
10.                                 int temp;
    
11.                                 if (src[i] > src[j]) {
    
12.                                         temp = src[j];
    
13.                                         src[j] = src[i];
    
14.                                         src[i] = temp;
    
15.                                 }
    
16.                         }
    
17.                         printResult(i, src);
    
18.                 }
    
19.         }

复制代码

        java冒泡排序：这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮 。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对 ，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元就浮到了次高位置。在作第二遍处理时 ， 由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。
        这个算法可实现如下。 算法如下：