算法大比拼：
众所周知，算法是程序的灵魂，那么到底有多少算法呢？这些算法又是咋样的呢？那么将由大家去发现：

【规则】写明是什么算法，并介绍算法，最后写一段代码来演示该算法。

【格式】递归算法的定义：
/                       递归算法是。。。。。。，这就是递归算法。
               java代码：
                             public static void main(String[]args){
                                         。。。。。。。。。
                              }


【奖励】一个算法奖励1~2技术分，如重复则不给分，必须是已定义的算法，比如冒泡等，不能子虚乌有哦，亲!              (为了能让更多人参加，每人限2次)

(该活动已结束。。。。。。)

            

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

冒泡排序算法
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;
                                }
                        }
                }
        }
}

结果图：

杨辉三角算法：
代码如下：
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);
        }
}

结果图：

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

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

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. }
    

复制代码

快速排序算法
        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);
        }

用递归的方式实现字符串翻转。
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);
}

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

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. }   

复制代码

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

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.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. }  

复制代码

选择排序 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.         }

复制代码

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



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;
                                }
                        }
                       
                }
        }
}

实现一个整数的倒置  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;
        }
       
}

/*
需求:使用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("用户名不存在!");
                                        }
                       
                       
               
                       
                       
        }
}

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

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

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遍的处理，它们已正确地排好序。
        这个算法可实现如下。 算法如下：

//查表法


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]);
                }
        }
}

张稳 发表于 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. }

复制代码

刘旭升 发表于 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. }
    

复制代码