A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 朱神必 金牌黑马   /  2014-2-19 21:33  /  5501 人查看  /  58 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 朱神必 于 2014-2-22 21:59 编辑

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

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

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



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

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

            










0026553965b00e94a97562.jpg (86.83 KB, 下载次数: 86)

0026553965b00e94a97562.jpg

评分

参与人数 1技术分 +1 收起 理由
To + 1

查看全部评分

58 个回复

正序浏览
算法有哈西算法,不易理解,很少人用
回复 使用道具 举报
冒泡排序算法
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;
                                }
                        }
                }
        }
}

结果图:

2.png (1.81 KB, 下载次数: 4)

2.png
回复 使用道具 举报
杨辉三角算法:
代码如下:
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.png (2.34 KB, 下载次数: 19)

1.png
回复 使用道具 举报
结束了啊,再整一次吧!!!
回复 使用道具 举报
发一个经典的快速排序算法。

  1. public class Quick {
  2.        
  3.         /**
  4.          * 获取中轴
  5.          * @param list
  6.          * @param low
  7.          * @param high
  8.          * @return
  9.          */
  10.         public static int getMiddle(Integer[] list, int low, int high) {
  11.                 int tmp = list[low]; // 数组的第一个作为中轴
  12.                 while (low < high) {
  13.                         while (low < high && list[high] > tmp) {
  14.                                 high--;
  15.                         }
  16.                         list[low] = list[high]; // 比中轴小的记录移到低端
  17.                         while (low < high && list[low] < tmp) {
  18.                                 low++;
  19.                         }
  20.                         list[high] = list[low]; // 比中轴大的记录移到高端
  21.                 }
  22.                 list[low] = tmp; // 中轴记录到尾
  23.                 return low; // 返回中轴的位置
  24.         }

  25.         /**
  26.          * 快速排序
  27.          * @param list         排序数组
  28.          * @param low        低值
  29.          * @param high        高值
  30.          */
  31.         public static void quickSort(Integer[] list, int low, int high) {
  32.                 if (low < high) {
  33.                         int middle = getMiddle(list, low, high); // 将list数组进行一分为二
  34.                         quickSort(list, low, middle - 1); // 对低值表进行递归排序
  35.                         quickSort(list, middle + 1, high); // 对高值表进行递归排序
  36.                 }
  37.         }

  38.         /**
  39.          * 快速排序
  40.          * @param str        需要被排序的数组
  41.          */
  42.         public static void quick(Integer[] str) {
  43.                 // 查看数组是否为空
  44.                 if (str.length > 0) {
  45.                         quickSort(str, 0, str.length - 1);
  46.                 }
  47.         }

  48.         /**
  49.          * @param args
  50.          */
  51.         public static void main(String[] args) {
  52.                 // TODO Auto-generated method stub
  53.                 Integer[] list = { 33, 1, 43, 4, 63,25, 24, 11 };
  54.                 quick(list);
  55.                 for (int i = 0; i < list.length; i++) {
  56.                         System.out.print(list[i] + " ");
  57.                 }
  58.                 System.out.println();
  59.         }

  60. }
复制代码
回复 使用道具 举报
快速排序算法
        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. }  
复制代码

评分

参与人数 1技术分 +1 收起 理由
朱神必 + 1

查看全部评分

回复 使用道具 举报
选择排序 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技术分 +1 收起 理由
朱神必 + 1

查看全部评分

回复 使用道具 举报

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


评分

参与人数 1技术分 +1 收起 理由
朱神必 + 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]);
                }
        }
}

评分

参与人数 1技术分 +1 收起 理由
朱神必 + 1

查看全部评分

回复 使用道具 举报
张稳 发表于 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. *第8题: 数组去重
  4. * 例如:
  5. * 原始数组是{4,2,4,6,1,2,4,7,8}
  6. * 得到结果{4,2,6,1,7,8}
  7. *
  8. * @author shine
  9. *
  10. */
  11. import java.util.Arrays;

  12. public class Test8 {
  13.         public static void main(String[] args){
  14.                 int[] ints = {2,24,24,3,2,24,32,54,6,5,3,7,7,12};//定义一个数组,并对其进行赋值
  15.                 int[] newints = removeduplication(ints);//调用removeduplication对数组进行去重
  16.                 System.out.println(Arrays.toString(newints));
  17.         }
  18.         //该方法用于对数组进行去重
  19.         public static int[] removeduplication(int[] ints){
  20.                 int l = 0;
  21.                 int[] tempints = new int[ints.length];
  22.                 out: for(int i=0; i<ints.length; i++){
  23.                         //对当前数组进行遍历,如果单签元素不与tempints中的已有元素相等则将其添加到tempints中去
  24.                         for(int n=0; n<l; n++){
  25.                                 if(tempints[n]==ints[i])
  26.                                         continue out;
  27.                         }
  28.                         tempints[l++] = ints[i];
  29.                 }
  30.                 //取tempints的“有效长度”,并赋值于新数组newints
  31.                 int[] newints = new int[l];
  32.                 for(int i=0; i<l ;i++){
  33.                         newints[i] = tempints[i];
  34.                 }
  35.                 return newints;//返回去重,并取合适长度的新数组
  36.         }
  37. }
复制代码
回复 使用道具 举报
希尔排序法是基于插入排序法改变,大大提供了插入排序的执行效率
  1. class ShellSort{

  2.    private int[] theArray;
  3.    private int nElems;
  4.    public ShellSort(int length, int[] array){
  5.     this.theArray=array;
  6.     this.nElems=length;
  7.    }

  8. public int[] shellSort(){
  9.      int inner, outer, temp;

  10.       int h=1
  11.       while(h<=nElems/3)h=h*3+1;
  12.    while(h>0){
  13.           for(outer=h; outer<nElems; outer++){
  14.          temp=theArray[outer];
  15.          inner=outer;
  16.          while(inner>h-1&&theArray[inner-h]>=temp){
  17.           theArray[inner]=theArray[inner-h];
  18.           inner-=h;
  19.            }
  20.          theArray[inner]=temp;
  21.     }
  22.     h=(h-1)/3;
  23.      }
  24.       return theArray;
  25.    }
  26. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
朱神必 + 1

查看全部评分

回复 使用道具 举报
123下一页
您需要登录后才可以回帖 登录 | 加入黑马