黑马程序员技术交流社区

标题: 求帮忙看下，弄了一个小时了，总是溢出 [打印本页]

---

作者: 天山    时间: 2014-4-17 18:08
标题: 求帮忙看下，弄了一个小时了，总是溢出
package com.itheima;import java.io.*;import java.util.*;public class quick_sort {//我是打算做排序，从键盘输入一10个数字，然后用快速排序，最后输出，        //我的 快速排序总是报错说溢出，除了用Scaner 还有什么方法能从键盘读int 数据                        public static void main(String []args)throws IOException        {                System.out.println("请输入你要排序的10个数字，按回车结束");                        int array[]=new int[10];                                        //DataInputStream dis = new DataInputStream(System.in);   //打算用 字符流从控制台输入 数字                //BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));                                                                                                                                /*for(int i=0;i<array.length;i++)                        {                                array[i]=dis.readInt();                        }*/                                                                        Scanner in=new Scanner(System.in);                        for(int i=0;i<10;i++)                        {                                array[i]=in.nextInt();                        }                                                                                //int array[]={99,56,45,5,89,14,25,69,10,45};                        show_(array);                        //sort_(array,0,array.length-1);   //快速排序                        bubble_sort(array);  //冒泡排序                        System.out.println("  ");                        show_(array);                                                }                                                /*for(int i:array)                {                        array[i]=(int)bufr.readLine();                }        }*/        public static void swap(int a[], int i, int j)         {                if (i == j)                        return;
                int temp = a[i];                        a[i] = a[j];                        a[j] = temp;
        }                /*public static int temp_(int arr[],int low,int high)        {                                int temp=low;                int p=arr[temp];                                for(int i=low+1;i<=high;i++)                {                        if(arr[i]<p)                        {                                temp++;                                swap(arr,temp,i);                        }                                        }                                swap(arr,low,temp);                                return temp;        }        */                                        //快速排序        public static int temp_(int arr[],int low,int high)        {                int key=arr[low];                while(low<high)                {                        while(low<high&&arr[high]>=key)                                high--;                                arr[low]=arr[high];                        while(low<high&&arr[low]<=key)                                low++;                                arr[high]=arr[low];                                }                        arr[low]=key;                        return low;        }                                //冒泡排序        public static void bubble_sort(int arr[])        {                for(int i=0;i<arr.length-1;i++){                        for(int j=0;j<arr.length-1;j++){                                if(arr[j]>arr[j+1]){                                        int t=arr[j];                                        arr [j]=arr[j+1];                                        arr[j+1]=t;                                        }                                }                        }        }                                        //递归        public static void sort_(int arr[],int low,int high)        {                if(low<high)                {                        int p=temp_(arr,low,high);                        temp_(arr,low,p-1);                        temp_(arr,p+1,high);                                        }        }                public static void show_(int arr[])        {                for(int i=0;i<arr.length;i++)                {                        System.out.print(arr[i]+"  ");                }        }/*        public static void sort_(int arr[],int low,int high)        {                if(low<high){                 int a=temp_(arr,low,high);                 temp_(arr,low,a-1);                 temp_(arr,a+1,high);                                }                        }*/        }

---

作者: 天山    时间: 2014-4-17 18:10
package com.itheima;
import java.io.*;
import java.util.*;
public class quick_sort {
       
               
        public static void main(String []args)throws IOException
        {
                System.out.println("请输入你要排序的10个数字，按回车结束");
                        int array[]=new int[10];
               
                        //DataInputStream dis = new DataInputStream(System.in);   //打算用 字符流从控制台输入 数字
                //BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
                               
                                                                               
                /*for(int i=0;i<array.length;i++)
                        {
                                array[i]=dis.readInt();
                        }*/
                       
                       
                        Scanner in=new Scanner(System.in);
                        for(int i=0;i<10;i++)
                        {
                                array[i]=in.nextInt();
                        }
                       
               
                                        //int array[]={99,56,45,5,89,14,25,69,10,45};
                        show_(array);
                        //sort_(array,0,array.length-1);   //快速排序
                        bubble_sort(array);  //冒泡排序
                        System.out.println("  ");
                        show_(array);
                       
       
                }
               
               
                /*for(int i:array)
                {
                        array[i]=(int)bufr.readLine();
                }
        }*/
        public static void swap(int a[], int i, int j)
        {
                if (i == j)
                        return;

                int temp = a[i];
                        a[i] = a[j];
                        a[j] = temp;

        }
       
        /*public static int temp_(int arr[],int low,int high)
        {               
                int temp=low;
                int p=arr[temp];
               
                for(int i=low+1;i<=high;i++)
                {
                        if(arr[i]<p)
                        {
                                temp++;
                                swap(arr,temp,i);
                        }
                       
                }
                                swap(arr,low,temp);
               
                return temp;
        }
        */                                        //快速排序
        public static int temp_(int arr[],int low,int high)
        {
                int key=arr[low];
                while(low<high)
                {
                        while(low<high&&arr[high]>=key)
                                high--;
                                arr[low]=arr[high];
                        while(low<high&&arr[low]<=key)
                                low++;
                                arr[high]=arr[low];
                                }
                        arr[low]=key;
                        return low;
        }
                                //冒泡排序
        public static void bubble_sort(int arr[])
        {
                for(int i=0;i<arr.length-1;i++){
                        for(int j=0;j<arr.length-1;j++){
                                if(arr[j]>arr[j+1]){
                                        int t=arr[j];
                                        arr [j]=arr[j+1];
                                        arr[j+1]=t;
                                        }
                                }
                        }
        }
                                        //递归
        public static void sort_(int arr[],int low,int high)
        {
                if(low<high)
                {
                        int p=temp_(arr,low,high);
                        temp_(arr,low,p-1);
                        temp_(arr,p+1,high);
                       
                }
        }
       
        public static void show_(int arr[])
        {
                for(int i=0;i<arr.length;i++)
                {
                        System.out.print(arr[i]+"  ");
                }
        }
/*        public static void sort_(int arr[],int low,int high)
        {
                if(low<high){
                 int a=temp_(arr,low,high);
                 temp_(arr,low,a-1);
                 temp_(arr,a+1,high);
                       
        }
       
               
}*/
        }

---

作者: 天山    时间: 2014-4-17 18:11
//我是打算做排序，从键盘输入一10个数字，然后用快速排序，最后输出

---

作者: Kelvinhu    时间: 2014-4-17 18:13
没问题啊。。在哪溢出了？

---

作者: 天山    时间: 2014-4-17 18:14

Kelvinhu 发表于 2014-4-17 18:13
没问题啊。。在哪溢出了？

show_(array);
                        //sort_(array,0,array.length-1);   //快速排序
                        bubble_sort(array);  //冒泡排序
                        System.out.println("  ");
                        show_(array);
你把快速排序 注释  删除了，把 冒泡排序的注释掉就看得到了

---

作者: Kelvinhu    时间: 2014-4-17 18:18

天山 发表于 2014-4-17 18:14
show_(array);
                        //sort_(array,0,array.length-1);   //快速排序
                        bubble_sort(array);  //冒泡排序

1. package Testpackage;
   
2. 
   
3. import java.io.*;
   
4. import java.util.*;
   
5. 
   
6. public class quick_sort {
   
7. 
   
8.         public static void main(String[] args) throws IOException {
   
9.                 System.out.println("请输入你要排序的10个数字，按回车结束");
   
10.                 int array[] = new int[10];
    
11. 
    
12.                 // DataInputStream dis = new DataInputStream(System.in); //打算用 字符流从控制台输入
    
13.                 // 数字
    
14.                 // BufferedReader bufr=new BufferedReader(new
    
15.                 // InputStreamReader(System.in));
    
16. 
    
17.                 /*
    
18.                  * for(int i=0;i<array.length;i++) { array[i]=dis.readInt(); }
    
19.                  */
    
20. 
    
21.                 Scanner in = new Scanner(System.in);
    
22.                 for (int i = 0; i < 10; i++) {
    
23.                         array[i] = in.nextInt();
    
24.                 }
    
25. 
    
26.                 // int array[]={99,56,45,5,89,14,25,69,10,45};
    
27.                 show_(array);
    
28.                 sort_(array, 0, array.length - 1); // 快速排序
    
29.                 // bubble_sort(array); //冒泡排序
    
30.                 System.out.println("  ");
    
31.                 show_(array);
    
32. 
    
33.         }
    
34. 
    
35.         /*
    
36.          * for(int i:array) { array[i]=(int)bufr.readLine(); } }
    
37.          */
    
38.         public static void swap(int a[], int i, int j) {
    
39.                 if (i == j)
    
40.                         return;
    
41. 
    
42.                 int temp = a[i];
    
43.                 a[i] = a[j];
    
44.                 a[j] = temp;
    
45. 
    
46.         }
    
47. 
    
48.         /*
    
49.          * public static int temp_(int arr[],int low,int high) { int temp=low; int
    
50.          * p=arr[temp];
    
51.          *
    
52.          * for(int i=low+1;i<=high;i++) { if(arr[i]<p) { temp++; swap(arr,temp,i); }
    
53.          *
    
54.          * } swap(arr,low,temp);
    
55.          *
    
56.          * return temp; }
    
57.          */// 快速排序
    
58.         public static int temp_(int arr[], int low, int high) {
    
59.                 int key = arr[low];
    
60.                 while (low < high) {
    
61.                         while (low < high && arr[high] >= key)
    
62.                                 high--;
    
63.                         arr[low] = arr[high];
    
64.                         while (low < high && arr[low] <= key)
    
65.                                 low++;
    
66.                         arr[high] = arr[low];
    
67.                 }
    
68.                 arr[low] = key;
    
69.                 return low;
    
70.         }
    
71. 
    
72.         // 冒泡排序
    
73.         public static void bubble_sort(int arr[]) {
    
74.                 for (int i = 0; i < arr.length - 1; i++) {
    
75.                         for (int j = 0; j < arr.length - 1; j++) {
    
76.                                 if (arr[j] > arr[j + 1]) {
    
77.                                         int t = arr[j];
    
78.                                         arr[j] = arr[j + 1];
    
79.                                         arr[j + 1] = t;
    
80.                                 }
    
81.                         }
    
82.                 }
    

复制代码

这样？没问题啊。

---

作者: 天山    时间: 2014-4-17 18:24

Kelvinhu 发表于 2014-4-17 18:18
这样？没问题啊。

奇怪....明明测试好几遍了，我快速排序方法都写了两遍了

---

作者: Kelvinhu    时间: 2014-4-17 18:25

天山 发表于 2014-4-17 18:24
奇怪....明明测试好几遍了，我快速排序方法都写了两遍了

贴你报错的溢出的Exception看看？

---

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

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