算法---排序

又接触算法恍如隔世...不知道为什么想不开的选择了java去做算法....想起来我还有一本贼厚的C ++ pri ... plus

想用快速排序鼓捣半个小时发现bug真多本以为写的不错了测试也不出错拿5 7 0 3 6 2 3测了一下emmm果真是特殊数组

我的错误代码如下：

import java.util.Scanner;
/ **
 *排序分为：
 *冒泡排序
 *选择排序
 *合并排序（递归与非递归）
 *快速排序
 * * /
public class shuliepaixu {
    public static void main（String [] args）{// 3 0 1 2
        扫描仪sc =新扫描仪（System.in）;
        int n = sc.nextInt（）;
        int [] num = new int [n];
        for（int i = 0; 我<n; i ++）{
            num [i] = sc.nextInt（）;
        }
        Qsort（num，0，num.length-1）;
        for（int i = 0; 我<n; i ++）{
            System.out.print（num [i] +“”）;
        }
    }
    公共静态无效的的qsort（INT [] NUM，诠释开始，INT最后）{
        System.out.println（“begin”+ begin +“，”+ last +“！”）; // 5 7 0 3 6 2 3
        if（begin> = last）{return;}
        int mid = num [（begin + last）/ 2];
        的System.out.println（“中：”+中旬）;
        int i = begin，j = last;
        while（i <j）{
            while（num [i] <mid）{i ++;}
            while（num [j]> mid）{j--;}
            int t = num [i];
            NUM [I] = NUM​​ [J];
            NUM [J] =吨;
// j--;
// i ++;
            的System.out.println（“：”+ I +“”+ J）;
            for（int ii = 0; ii <num.length; ii ++）{
                System.out.print（num [ii] +“”）;
            }
            系统。
// System.out.println（“midoc：”+ loc）;
            的System.out.println（I +“”+ J）;
        }
        int loc = -1;
        for（int t = 0; t <num.length; t ++）{
            if（mid == num [t]）{
                loc = t;
                打破;
            }
        }
        的的System.out.println（“左：” +开始+“” +（LOC-1））;
        的的qsort（NUM，开始，LOC-1）;
        的的System.out.println（“右” +（ LOC + 1）+“”+最后）;
        的qsort（NUM，LOC + 1，最后的）;
    }
}
然后百思不知其解的我去百度了

正确代码如下：

package com.xjtu.cruise;
 
public class Sort {
 
    / **
     *冒泡排序
     * 
     * @param data
     *目标数组
     * /
public static void bubbleSort（int [] data）{
 
        for（int i = 0; 我<data.length - 1; i ++）{//控制趟数
            （int j = 0; j <data.length - i - 1; j ++）{
 
                if（data [j]> data [j + 1]）{
                    int tmp = data [j];
                    data [j] = data [j + 1];
                    data [j + 1] = tmp;
                }
            }
        }
 
    }
 
    / **
     *选择排序
     * 
     * @参数数据
     *目标数组
     * /
    public static void selectSort（int [] data）{
        if（data == null || data.length == 0）{
            return;
        }
 
        对（INT I = 0; 我<data.length - 1; i ++）{
            int min = i; //将当前下标定为最小值下标
            for（int j = i + 1; j <data.length; j ++）{
                if（data [j] <data [min]）{
                    min = j;
                }
            }
 
            如果（ⅰ=分钟！）{
                INT TMP =数据[I];
                data [i] = data [min];
                data [min] = tmp;
            }
        }
    }
 
    / **
     *选择排序此算法效率不如上面的高
     * 
     * @param sort
     * /
    public static void selectSort2（int [] data）{
 
        for（int i = 0; 我<data.length - 1; i ++）{
            for（int j = i + 1; j <data.length; j ++）{
                if（data [j] <data [i]）{
                    int temp = data [j];
                    data [j] = data [i];
                    data [i] = temp;
                }
            }
        }
    }
 
    / **
     *快速排序算法
     * 
     * @参数数据
     *目标数组
     * @参数启动
     *起始位
     * @参数端
     *结束位
     * /
    public static void quickSort（int [] data，int start，int end）{
        //设置关键数据key为要排序
        数组的第一个元素，//即第一趟排序后，key右边的数全部比键大，键左边的数全部比键小
        INT键=数据[开始];
        //设置数组左边的索引，往右移动比键大的数
        int i = start;
        //设置数组右边的索引，往左移动比键小的数字
        j = end;
        //如果左边索引比右边索引小，则还有数据没有排序
        while（i <j）{
            while（data [j]> key && j> i）{
                j--;
            }
            data [i] = data [j];
 
            while（data [i] <key && i <j）{
                i ++;
            }
            data [j] = data [i];
        }
        //此时i == j
        data [i] = key;
 
        //递归调用
        if（i - 1> start）{
            //递归调用，把键
            前面的完成排序quickSort（data，start，i - 1）;
        }
        if（i + 1 <end）{
            //递归调用，把键后面的完成排序
            quickSort（data，i + 1，end）;
        }
    }
 
    / **
     * @参数ARGS
     * /
    公共静态无效的主要（字串[] args）{
        INT [] P = {34,21,54,18,23,76,38,98,45,33， 27,51,11,20,79,30,89,41
                };
 
        long start = System.currentTimeMillis（）;
 
// Sort.bubbleSort（p）; //冒泡排序
// Sort.selectSort（p）; //选择排序
// Sort.selectSort2（p）; //选择排序2
        Sort.quickSort（p，0，p.length - 1）; //快速排序
 
        System.out.println（“所用时间：”+（System.currentTimeMillis（） - start））;
        for（int i = 0; 我<p.length; i ++）{
            System.out.print（p [i] +“”）;
        }
    }
 
}
牛逼看来要好好回顾一下课本了 

五分钟之后恕我直言这个代码对于1 2 0 2不行啊.....

扒代码一流的我 发现这个可以：

public class shuliepaixu {
    public static void quickSort(int[] arr){
        qsort(arr, 0, arr.length-1);
    }
    private static void qsort(int[] arr, int low, int high){
        if (low < high){
            int pivot=partition(arr, low, high);        //将数组分为两部分
            qsort(arr, low, pivot-1);                   //递归排序左子数组
            qsort(arr, pivot+1, high);                  //递归排序右子数组
        }
    }
    private static int partition(int[] arr, int low, int high){
        int pivot = arr[low];     //枢轴记录
        while (low<high){
            while (low<high && arr[high]>=pivot) --high;
            arr[low]=arr[high];             //交换比枢轴小的记录到左端
            while (low<high && arr[low]<=pivot) ++low;
            arr[high] = arr[low];           //交换比枢轴小的记录到右端
        }
        //扫描完成，枢轴到位
        arr[low] = pivot;
        //返回的是枢轴的位置
        return low;
    }
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] p = { 1,2,0,2};
        for(int t=0;t<p.length;t++){
            System.out.print(p[t]+" ");
        }
        System.out.println();
        System.out.println();
        long start = System.currentTimeMillis();
 
//        Sort.bubbleSort(p);// 冒泡排序
//        Sort.selectSort(p);// 选择排序
//        Sort.selectSort2(p);// 选择排序2
        quickSort(p);// 快速排序
 
        System.out.println("所用时间：" + (System.currentTimeMillis() - start));
        for (int i = 0; i < p.length; i++) {
            System.out.print(p[i] + " ");
        }
    }
 
}
结束！思路差不多 就是细节方面  加油哟