黑马程序员技术交流社区

标题: 算法大比拼【送技术分】 [打印本页]

---

作者: 朱神必    时间: 2014-2-19 21:33
标题: 算法大比拼【送技术分】


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

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

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


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

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

            

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

下载附件

2014-2-19 21:17 上传

---

作者: 刘旭升    时间: 2014-2-19 21:45
加油啊。。。。。期待你来

---

作者: →★稻草人☆    时间: 2014-2-19 21:46
a*b这是乘法运算算法：
public static void main(String[] args)
{
  method(3,5);  
}
public static void method(int a,int b)
{
   System.out.println(a*b);
}

---

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

1. public static int[] removeRepeat(int[] a){//封装功能：传递一个数组，则返回一个去重的新数组！
   
2.                 int[] b = new int[a.length];//定义数组，长度为a.length
   
3.                 int index=0;boolean flag=true;//角标和标记值的声明
   
4.                 for(int i=0;i<a.length;i++){//外圈：依次取出数组a中的一个元素，参与循环比较
   
5.                         for(int j=0;j<a.length;j++){//内圈：新数组的所有元素参与比较。
   
6.                                 if(a[i]==b[j])//当且仅当新数组含有指定的a[i]时，令标记为false。
   
7.                                         flag=false;
   
8.                         }
   
9.                         if(flag){//当标记为true时，表示为非重复元素，添加进新数组。否则为重复元素，不添加。
   
10.                                 b[index]=a[i];
    
11.                                 index++;
    
12.                         }
    
13.                         flag=true;//注意：一次判断结束后需要将标记复位！
    
14.                 }
    
15.                 int[] s=new int[index];//由于b数组的长度不是我们想要的，所以重新装进一个长度刚好合适的数组里面。
    
16.                 for(int n=0;n<index;n++){
    
17.                         s[n]=b[n];
    
18.                 }
    
19.                 return s;//返回最终数组。
    
20.         }

复制代码

---

作者: 刘旭升    时间: 2014-2-19 22:01
需要100技术分，就再来一个：

1. public static String[] MyEquale(String[] arr){//以compare方法为基地，实现对String数组排序功能。
   
2.                 for(int i=0;i<5;i++){
   
3.                         for(int j=i;j<5;j++){//大圈套小圈循环比较，排号序列。这里没有考虑效率，可能会有效率低的bug。
   
4.                                 if(compare(arr[i],arr[j])){
   
5.                                         String a=null;
   
6.                                         a=arr[i];//换位功能，字符串没有使用相与方法
   
7.                                         arr[i]=arr[j];
   
8.                                         arr[j]=a;
   
9.                                 }else{}
   
10.                         }
    
11.                 }
    
12.                 return arr;
    
13.         }

复制代码

---

作者: 自笃行者    时间: 2014-2-19 22:04
哈哈哈，我来啦！！！！！！！！！！

---

作者: →★稻草人☆    时间: 2014-2-19 22:23
//折半查找。{1,5,8,9,13,16,20,25}
class ArrayDemo2
{
        public static void main(String[] args)
        {
                int[] arr={1,5,8,9,13,16,20,25};
                int mid=getIndex(arr,20);
                System.out.println(mid);
               
        }
        public static int getIndex(int[] arr,int key)
        {
                int min,max,mid;
                min=0;
                max=arr.length-1;
                mid=(min+max)/2;
                while (key!=arr[mid])
                {
                        if(key>arr[mid])//要取的值大于中间值
                                min=mid+1;//所以最小值要在中间值的位置上加1
                        else if(key<arr[mid])//要取的值小于中间值
                                max=mid-1;//所以最小值要在中间值的位置上减1

                        if(min>max)//当要找的值不存在时，最小值移的位置超过了最大值的位置
                                return -1;
                        mid=(max+min)/2;
                }
                return mid;
        }
}

---

作者: centian2005    时间: 2014-2-19 22:40
呵呵，那就现学现卖了。学习IO时，打印指定目录下全部内容，用到递归算法。
public static void print(File file){        // 递归调用
                if(file!=null){        // 判断对象是否为空
                        if(file.isDirectory()){        // 如果是目录
                                File f[] = file.listFiles() ;        // 列出全部的文件
                                if(f!=null){        // 判断此目录能否列出
                                        for(int i=0;i<f.length;i++){
                                                print(f) ;        // 因为给的路径有可能是目录，所以，继续判断
                                        }
                                }
                        }else{
                                System.out.println(file) ;        // 输出路径
                        }
                }
        }

PS:个人认为，算法最难学

---

作者: 夏新¤Amoi    时间: 2014-2-19 23:04
递归算法：这是求阶乘的。
                public static void main(String[]args){                                    
                     System.out.println(recursion(5));
                 }
                public static int recursion(int args){
                    if(args>1)
                       return args*recursion(args-1);

                   return args;
       
}

---

作者: To    时间: 2014-2-19 23:09
支持支持

---

作者: 皓栎    时间: 2014-2-19 23:10

1. /*
   
2. 求斐波那契数列第n项，n<30
   
3. 斐波那契数列前10项为: 1,1,2,3,5,8,13,21,34,55
   
4. */
   
5. public class Test1 {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                
   
9.                 long ret = getFibonacci(29);
   
10.                
    
11.                 System.out.println(ret);
    
12.                
    
13.         }
    
14.         public static long getFibonacci(int num){
    
15.                
    
16.                 switch (num) {
    
17.                         case 0:
    
18.                                 return 0;
    
19.                         case 1:
    
20.                                 return 1;
    
21.                         default:
    
22.                                 return getFibonacci(num - 1) + getFibonacci(num - 2);
    
23.                 }
    
24.         }
    
25. }

复制代码

---

作者: 丶小天    时间: 2014-2-19 23:15
递归算法就是一个函数通过不断对自己的调用而求得最终结果的一种思维巧妙但是开销很大的算法。
比如：

1. import javax.swing.JOptionPane;
   
2.         public class Fibonacci {
   
3.                 int F(int n) {
   
4.                         if(n==0)
   
5.                         return 1;
   
6.                         else if(n==1)
   
7.                         return 1;
   
8.                         else if(n>1)
   
9.                         return F(n-1)+F(n-2); /*递归*/
   
10.                         else
    
11.                         JOptionPane.showMessageDialog(null,"方程无解!");
    
12.                         return 0;
    
13.                 }
    
14. 
    
15.         public static void main(String[] args)
    
16.         {
    
17.                 int i,n,m;
    
18.                 Fibonacci f=new Fibonacci();
    
19.                 String s=JOptionPane.showInputDialog(null,"please input n:\n");
    
20.                 n=Integer.parseInt(s);
    
21.                         for(i=0;i<=n;i++) {
    
22.                                 m=f.F(i);
    
23.                                 System.out.print(m+" ");
    
24.                         }
    
25.                 }
    
26. }

复制代码

---

作者: 夏新¤Amoi    时间: 2014-2-19 23:22
冒泡：这是之前看毕老师视频写的
void bubble(int[] arr){
                for(int x = 0;x<arr.length-1;x++){
                        for(int y = 0;y<arr.length-1-x;y++){
                                if(arr[y] > arr[y+1]){
                                        int temp = arr[y];
                                        arr[y] = arr[y+1];
                                        arr[y+1] = temp;
                                }
                        }
                }
        }

---

作者: 皓栎    时间: 2014-2-19 23:35

1. import java.util.*;
   
2. /*
   
3. 数组冒泡排序(升序)
   
4. */
   
5. class  ArraySort{
   
6. 
   
7.         public static void main(String[] args){
   
8.                 int[] arr = new int[]{43,21,32,25,12};
   
9.                 System.out.println(Arrays.toString(sort(arr)));
   
10.         }
    
11. 
    
12.         public static int[] sort(int[] a){
    
13.                 for(int i=0;i<a.length-1;i++){
    
14.                         for(int j=0;j<a.length-1-i;j++){
    
15.                                 if(a[j]>a[j+1]){
    
16.                                         int temp=a[j];
    
17.                                         a[j]=a[j+1];
    
18.                                         a[j+1]=temp;
    
19.                                 }
    
20.                         }       
    
21.                 }
    
22.                 return  a;
    
23.         }
    
24. }

复制代码

---

作者: →★稻草人☆    时间: 2014-2-20 08:42
public static void show_1(int[] arr)//选择排序，从0角标开始依次同每一个角标上的值进行比较,将最小值依次   进行排序
        {
                for (int x=0;x<arr.length-1 ;x++ )
                {
                        for (int y=1+x;y<arr.length ;y++ )
                        {
                                if(arr[x]>arr[y])
                                {int temp=arr[x];
                                   arr[x]=arr[y];
                                    arr[y]=temp;
                                }
                        }
                }

---

作者: 丁香花    时间: 2014-2-20 09:47
1/*
语句嵌套形式
嵌套循环

嵌套循环 的方式求九九乘法表
同时还可按需求把结果排列成三角（倒三角）矩形等形状。
*/

class ForForDemo
{
        public static void main(String[] args)
        {
                for (int x=1;x<=9 ;x++ )
                {
                        for (int y=1;y<=x ;y++ )
                        {
                                System.out.print(y+"*"+x+"="+y*x+"\t");
                        }
                System.out.println();
                }

               
        }
}

---

作者: 丁香花    时间: 2014-2-20 09:55
/*
求一个数组最值得方法
只列出最大值得求法，同理也能求出该数组的最小值，只要变换循环内条件即可。
*/

class  ArrayTest
{
        public static void main(String[] args)
        {
                int[] arr ={5,1,6,4,2,8};//建立一个数组
               
                int max = getMax(arr);//调用函数getMax并把结果赋值给变量int max
                System.out.println("max="+max);
        }



        public static int getMax(int[] arr)//建立int数组类型函数
        {
                int max = arr[0];//建立一个变量赋值为该数组中第一个元素
                for (int x=1;x<arr.length ;x++ )
                {
                        if (arr[x]>max)
                        {
                                max = arr[x];
                        }
               
                }return max;
        }
        }

---

作者: 我叫MT    时间: 2014-2-20 12:07

1. class Demo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr={11,53,28,39,12,1,44,21};
   
6.                 int mid=Index(arr,44);
   
7.                 System.out.println(mid);  
   
8.         }
   
9.         public static int Index(int[]arr,int m)
   
10.         {
    
11.                 int min,max,mid;
    
12.                 min=0;
    
13.                 max=arr.length-1;
    
14.                 mid=(min+max)/2;
    
15.                 while (m!=arr[mid])
    
16.                 {
    
17.                         if(m>arr[mid])
    
18.                                 min=mid+1;
    
19.                         else if(m<arr[mid])
    
20.                                 max=mid-1;
    
21.                         if(min>max)
    
22.                                 return -1;
    
23.                         mid=(max+min)/2;
    
24.                 }
    
25.                 return mid;
    
26.         }
    
27. }

复制代码

折半查找法

---

作者: wowo6288    时间: 2014-2-20 21:48
贪心算法的定义：
贪心算法在对问题求解时，总是做出在当前看来是最好的选择。不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。

贪心算法的举例
有十一个快件，每个快件有送货的起始时间，要求用最少的车，运送完所有的快件。
快件1:1:00-4:00
快件2:3:00-5:00
快件3:0:00-6:00
快件4:5:00-7:00
快件5:3:00-8:00
快件6:5:00-9:00
快件7:6:00-10:00
快件8:8:00-11:00
快件9:8:00-12:00
快件10:2:00-13:00
快件11:12:00-14:00
分析:要使用最少的车运送,那么在同一辆车上的派件必须是第二个派件的开始派发时间大于第一个
派件的截至派发时间，利用贪心算法(从局部选取最优解)那么就可以解决此问题
代码
Car类
import java.util.List;
/**
* 封装的是该车可以保存的派件信息
*/
public class Car
{
        private List<Goods> goodsList;
        public List<Goods> getGoodsList()
        {
                return goodsList;
        }
        public void setGoodsList(List<Goods> goodsList)
        {
                this.goodsList = goodsList;
        }
        @Override
        public String toString()
        {
                String value="";
                for (Goods goods : goodsList)
                {
                        value+=goods.toString();
                }
                return value;
        }
}

Goods类
/**
* 封装的是派件的一些相关信息
*/
public class Goods
{
        private String name;
        private int startTime;
        private int endTime;
        public int getStartTime()
        {
                return startTime;
        }
        public void setStartTime(int startTime)
        {
                this.startTime = startTime;
        }
        public int getEndTime()
        {
                return endTime;
        }
        public void setEndTime(int endTime)
        {
                this.endTime = endTime;
        }
        public String getName()
        {
                return name;
        }
        public Goods(String name, int startTime, int endTime)
        {
                this.name = name;
                this.startTime = startTime;
                this.endTime = endTime;
        }
        @Override
        public String toString()
        {
                return name+" ";
        }
       
}
GoodsSort类
import java.util.Comparator;
/**
* 以派件的截至时间进行排序
*/
public class GoodsSort implements Comparator<Goods>
{
        @Override
        public int compare(Goods g0, Goods g1)
        {
                return g0.getEndTime()-g1.getEndTime();
        }
}

ArrangeCar类用于安排车辆
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class ArrangeCar
{
        private static List<Car> cars=new ArrayList<>();
        public static void main(String[] args)
        {
                List<Goods> goodsList = addGoods();
                System.out.println("排序前");
                printGoods(goodsList);
                //对派件进行排序以派件的endTime进行排序
                Collections.sort(goodsList, new GoodsSort());
                System.out.println('\n'+"排序后");
                printGoods(goodsList);
                System.out.println();
               
                greedySelect(goodsList);
                System.out.println("共有"+cars.size()+"种派件方案");
                for (Car car : cars)
                {
                        System.out.println(car);
                }
        }
        /**
         * 贪心算法的运用
         * @param goodsList
         */
        public static void greedySelect(List<Goods> goodsList)
        {
                Goods goods=goodsList.remove(0);//获取排好序之后的第一个派件
                int firstEndTime=goods.getEndTime();//得到派件的endTime
                Car car=new Car();//新建立一个Car对象用于装载派件对象
                List<Goods> gList=new ArrayList<>();
                gList.add(goods);
                car.setGoodsList(gList);
                cars.add(car);//cars用于记录用了多少辆车
                for(Iterator<Goods> iterator=goodsList.iterator();iterator.hasNext();)
                {
                        Goods otherGoods=iterator.next();
                        //循环取出派件队列里面的派件，获得其开始派发时间同第一个派件的截至派发时间进行比较
                        //如果后面派件的开始派发时间大于第一个的派发时间那么可以用这两个派件装在一辆车上面
                        if(firstEndTime<=otherGoods.getStartTime())
                        {
                                gList.add(otherGoods);//装在同一辆车上面
                                firstEndTime=otherGoods.getEndTime();//改变截至派发时间值
                                iterator.remove();//移除该派件
                        }
                }
                //当循环完之后还有派件那么就进行递归再次装载车辆
                if(goodsList.size()!=0)
                {
                        greedySelect(goodsList);
                }
        }
        /**
         * 添加派件
         * @return
         */
        public static List<Goods> addGoods()
        {
                List<Goods> goodsList=new ArrayList<>();
                Goods thing8 = new Goods("派件8", 8, 11);
                goodsList.add(thing8);
                Goods thing9 = new Goods("派件9", 8, 12);
                goodsList.add(thing9);
                Goods thing10 = new Goods("派件10", 2, 13);
                goodsList.add(thing10);
                Goods thing11 = new Goods("派件11", 12, 14);
                goodsList.add(thing11);
                Goods thing1 = new Goods("派件1", 1, 4);
                goodsList.add(thing1);
                Goods thing2 = new Goods("派件2", 3, 5);
                goodsList.add(thing2);
                Goods thing3 = new Goods("派件3", 0, 6);
                goodsList.add(thing3);
                Goods thing4 = new Goods("派件4", 5, 7);
                goodsList.add(thing4);
                Goods thing5 = new Goods("派件5", 3, 8);
                goodsList.add(thing5);
                Goods thing6 = new Goods("派件6", 5, 9);
                goodsList.add(thing6);
                Goods thing7 = new Goods("派件7", 6, 10);
                goodsList.add(thing7);
                return goodsList;
        }
        /**
         * 打印货物
         * @param goodsList
         */
        public static void printGoods(List<Goods> goodsList)
        {
                for (Goods goods : goodsList)
                {
                        System.out.print(goods.getName() + ":" + goods.getStartTime()
                                        + "-" + goods.getEndTime()+" ");
                }
        }
}

---

作者: 小小瓶盖❤    时间: 2014-2-21 02:20

1. package array;
   
2. 
   
3. import java.util.*;
   
4. /*
   
5. * 冒泡排序：相邻两个元素进行比较，满足条件换位。
   
6. * 选择排序：选择一元素，不停的与其他元素比较，满足条件换位。
   
7. */
   
8. public class Test4 {
   
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.                 int temp;
    
30.                 for(int i=0;i<arr.length-1;i++){      
    
31.                         for(int j=0;j<arr.length-1-i;j++){   
    
32.                                 if(arr[j]>arr[j+1]){    //总是比较相邻元素大小，并把每次比较的最大值放在比较的元素的最末尾
    
33.                         /*                temp=arr[j];
    
34.                                         arr[j]=arr[j+1];
    
35.                                         arr[j+1]=temp;     */
    
36.                                         swap(arr,j,j+1);
    
37.                                 }
    
38.                         }
    
39.                 }
    
40.                 for(int i=0;i<arr.length;i++){
    
41.                         System.out.print(arr[i]+" ");
    
42.                 }
    
43.                 System.out.println();
    
44.                        
    
45.         }
    
46.        
    
47. //        选择排序
    
48.         public static void rankAaary2(int[] arr){
    
49.                 int temp;
    
50.                 for(int i=0;i<arr.length-1;i++){   
    
51.                         for(int j=1+i;j<arr.length;j++){
    
52.                                 if(arr[i]>arr[j])  //总是拿一指定角标元素和其后元素比较
    
53.                                 {
    
54.                         /*                temp=arr[j];
    
55.                                         arr[j]=arr[i];
    
56.                                         arr[i]=temp;     */
    
57.                                         swap(arr,i,j);
    
58.                                 }
    
59.                         }
    
60.                 }
    
61.                 for(int i=0;i<arr.length;i++)
    
62.                         System.out.print(arr[i]+" ");
    
63.                 System.out.println();
    
64.         }
    
65.        
    
66. //        位置置换(形参：指定数组，指定换位的两个下标)
    
67.         public static void swap(int[] array,int a,int b){
    
68.                 int temp;
    
69.                 temp=array[a];
    
70.                 array[a]=array[b];
    
71.                 array[b]=temp;       
    
72.         }
    
73. }

复制代码

---

作者: 小小瓶盖❤    时间: 2014-2-21 02:21

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

复制代码

---

作者: 未发光的金子    时间: 2014-2-21 11:41


快速排序算法
快速排序（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. }
    

复制代码

---

作者: 未发光的金子    时间: 2014-2-21 12:40
选择排序算法
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
排序实例
初始关键字 [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. }

复制代码

---

作者: 曾振华    时间: 2014-2-21 14:39
        编程验证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');
        }
}

---

作者: 曾振华    时间: 2014-2-21 14:40
/*
演示随机抽取算法
机选双色球
*/


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

---

作者: 曾振华    时间: 2014-2-21 14:43
//打印空心菱形

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

}

---

作者: xiaofeng    时间: 2014-2-21 17:04
刚看到这,现学现用,讲十进制转成二进制.

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

复制代码

---

作者: 曾振华    时间: 2014-2-21 23:17
//斗地主发牌算法


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

---

作者: elq7xy    时间: 2014-2-21 23:27
一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如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. } }

复制代码

---

作者: 依旧00    时间: 2014-2-21 23:29
递归是程序调用自身的过程，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。

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

复制代码

---

作者: elq7xy    时间: 2014-2-21 23:35
一个整数，它加上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. } }

复制代码

---

作者: 梦里花-静    时间: 2014-2-22 00:04
求阶乘

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

复制代码

---

作者: 张稳    时间: 2014-2-22 12:29


两种算法求最大公约数

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

复制代码

---

作者: Diferay    时间: 2014-2-22 13:51

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

复制代码

---

作者: Diferay    时间: 2014-2-22 13:56

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

复制代码

---

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

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-22 18:07

刘旭升 发表于 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 18:19

张稳 发表于 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-22 20:48
//查表法


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

---

作者: dongdong5982    时间: 2014-2-22 20:53

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

---

作者: 曾振华    时间: 2014-2-22 21:34
/*
验证商品上的条形码真伪的算法。很实用的，版主求打发点。

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

---

作者: 曾振华    时间: 2014-2-22 22:10
/*
需求:使用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("用户名不存在!");
                                        }
                       
                       
               
                       
                       
        }
}

---

作者: 曾振华    时间: 2014-2-22 22:27
实现一个整数的倒置  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;
        }
       
}

---

作者: 曾振华    时间: 2014-2-22 22:34
//排序算法很多，哪一种算法性能最高？？？测试排序性能



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

---

作者: dongdong5982    时间: 2014-2-23 18:32
选择排序 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.         }

复制代码

---

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

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

复制代码

---

作者: 教皇    时间: 2014-2-26 19:04
归并排序法是将两个（或两个以上）有序表合并成一个新的有
序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并
为整体有序序列。

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

复制代码

---

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

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

复制代码

---

作者: haixian    时间: 2014-3-27 11:08
用递归的方式实现字符串翻转。
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);
}

---

作者: haixian    时间: 2014-3-27 11:55
快速排序算法
        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);
        }

---

作者: 别小乐    时间: 2014-3-30 20:08
发一个经典的快速排序算法。

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

复制代码

---

作者: 帅哥哥    时间: 2014-4-2 12:09
结束了啊，再整一次吧！！！

---

作者: 微笑=.一瞬间    时间: 2014-4-28 11:33
杨辉三角算法：
代码如下：
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, 下载次数: 16)

下载附件

2014-4-28 11:33 上传

---

作者: 微笑=.一瞬间    时间: 2014-4-28 11:47
冒泡排序算法
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, 下载次数: 2)

下载附件

2014-4-28 11:47 上传

---

作者: lovefmylgs    时间: 2014-5-3 21:52
算法有哈西算法，不易理解，很少人用

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2