精华内容
下载资源
问答
  • java实现快速排序

    2017-03-10 16:45:07
    java实现快速排序

    java实现快速排序:

    public class testQuickSort {
        public static void main(String[] args) {
            int array[] = {1,5,3,4,2};
            sort(array,0,array.length-1);
            for (int a : array){
                System.out.println(a);
            }
        }
        public static void sort(int array[],int start , int end){
            if (start < end){
                int position = quickSort(array,start,end);
                sort(array,start,position-1);
                sort(array,position+1,end);
            }
        }
        public static int quickSort(int array[],int start,int end){
            int position = array[start];//将第一位数作为中轴
            while(start < end){
                while (start<end && position<array[end]) end--;
                    array[start] = array[end];//如果该位置的数小于中轴则交换
                while (start<end && position>array[start]) start++;
                    array[end] = array[start];//如果该位置的数大于中轴则交换
            }
            array[start] = position;
            return start;
        }
    }

    运行结果:
    这里写图片描述

    展开全文
  • Java 实现快速排序

    2020-09-24 15:56:04
    Java 实现快速排序原理逻辑Java代码实现 原理逻辑 同冒泡排序一样,快速排序也属于交换排序,通过元素之间的比较和交换位置来达到排序的目的。 不同的是,冒泡排序在每一轮只把一个元素冒泡到数列的一端,而快速排序...

    Java 实现快速排序

    原理逻辑

    同冒泡排序一样,快速排序也属于交换排序,通过元素之间的比较和交换位置来达到排序的目的。

    不同的是,冒泡排序在每一轮只把一个元素冒泡到数列的一端,而快速排序在每一轮挑选一个基准元素,并让其他比它大的元素移动到数列一边,比它小的元素移动到数列的另一边,从而把数列拆解成了两个部分。

    注:快速排序属于不稳定排序。

    Java代码实现

    /**
     * <快速排序>
     *
     * @Author: chenxin
     * @Date: 2020/9/11
     */
    public class Main {
    
        public static void main(String[] args) {
            List<Integer> list = Arrays.asList(3, 2, 1, 4, 6, 9, 4, 3, 5);
    
            List<Integer> sortedList = new SortUtil().quickSort(list);
    
            System.out.println("list = " + list);
            System.out.println("sortedList = " + sortedList);
        }
    }
    
    class SortUtil {
    
        /**
         * 功能描述: 将list排序后 返回
         *
         * @Author: chenxin
         * @Param: [list]
         * @Date: 2020/9/11
         */
        public List<Integer> quickSort(List<Integer> list) {
            Integer[] nums = list.toArray(new Integer[0]);
    
            quickSortRecursive(nums, 0, list.size() - 1);
    
            return Arrays.asList(nums);
        }
    
        /**
         * 功能描述: 快速排序逻辑方法
         *
         * @Author: chenxin
         * @Param: [nums, head, bottom]
         * @Date: 2020/9/11
         */
        private void quickSortRecursive(Integer[] nums, int head, int bottom) {
            int i, j, t, tag;
            if (head > bottom)
                return; // 头大于尾 返回 
    
            tag = nums[head]; // 每次将头给一个基数 
            i = head;
            j = bottom;
            while (i != j) // 从两头向中间走 当ij相遇则停止 
            {
                // 先从右边开始 如果找到的数小于基数(一般是大于基数 如果小于则代表要换)或者 ij相遇了 则停止 
                while (nums[j] >= tag && i < j) {
                    j--;
                }
                // 然后左边 找到大于基数的数 或者相遇 停止 
                while (nums[i] <= tag && i < j) {
                    i++;
                }
                // 找到两个要换的的数 且此时ij没有相遇 则换 
                if (i < j) {
                    t = nums[i];
                    nums[i] = nums[j];
                    nums[j] = t;
                }
            }
            // 循环结束 代表ij相遇了 将第i个数当做头 原先的基数变为第i个数 
            nums[head] = nums[i];
            nums[i] = tag;
    
            quickSortRecursive(nums, head, i - 1);
            quickSortRecursive(nums, i + 1, bottom);
        }
    }
    
    
    展开全文
  • Java实现快速排序

    2020-10-21 10:31:49
    (4)Java实现快速排序 代码实现 package com.wllarl.suanfa.sort; import java.util.Arrays; public class QuickSort { public static void main(String[] args) { int []array = {23,12,43,56,78,11,211,4}; ...

    (4)Java实现快速排序

    代码实现

    package com.wllarl.suanfa.sort;
    
    import java.util.Arrays;
    
    public class QuickSort {
        public static void main(String[] args) {
                int []array = {23,12,43,56,78,11,211,4};
                QuickSort quickSor = new QuickSort();
                quickSor.quickSort(array,0,array.length-1);
                System.out.println(Arrays.toString(array));
        }
    
        public void quickSort(int[] array,int left,int right){
            int l = left;
            int r = right;
            int temp = 0;
            int point = array[(left+right)/2];
            while (l < r){
    
                while (array[l] < point){
                    l++;
                }
                while (array[r] > point){
                    r--;
                }
                if (l >= r){
                    break;
                }
                temp = array[l];
                array[l] = array[r];
                array[r] = temp;
    
                if (array[l] == point){
                    r -= 1;
                }
                if (array[r] == point){
                    l += 1;
                }
            }
    
            if (l == r){
                l++;
                r--;
            }
    
            if (left < r){
                quickSort(array,left,r);
            }
            if (right > l){
                quickSort(array,l,right);
            }
        }
    
    }
    
    

    实验截图·
    “C:\Program Files\Java\jdk-9.0.4\bin\java.exe” “-javaagent:D:\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=8111:D:\IntelliJ IDEA 2019.3.3\bin” -Dfile.encoding=UTF-8 -classpath E:\daima\suanfa\out\production\算法练习 com.wllarl.suanfa.sort.QuickSort
    [4, 11, 12, 23, 43, 56, 78, 211]
    Process finished with exit code 0

    展开全文
  • JAVA实现快速排序

    2017-05-23 21:18:49
    java实现快速排序算法
  • java 实现 快速排序

    2019-09-06 18:45:48
    原因 原来总是听别人说快速排序,但是一直没有实现过,今天就来实现一下. 原理 先说说我自己理解的快速排序的原理: 我们排序一般都是对一个数组中的数据进行排序,快速排序的原理就是把数据按照一个...要想实现快速排序...

    原因

    原来总是听别人说快速排序,但是一直没有实现过,今天就来实现一下.

    原理

    先说说我自己理解的快速排序的原理:
    我们排序一般都是对一个数组中的数据进行排序,快速排序的原理就是把数据按照一个分界值给分成两部分,每一个部分可以看做是一个数据.位于分界值左边的数组中的每个值都比分界值小,位于分界值右边的数组中的每个值都比分界值大.然后在不断的改变这个分界值.最后就可以实现快速排序了.

    要想实现快速排序,我们得注意两个问题.第一个在比较的过程中,我们肯定是需要对数组进行循环比较的,但是我们没办法确定需要比较的次数,所以需要用while来判断.第二个是,无论是位于分界值左边的数组还是位于分界值右边的数组,对于我们来说,对他进行排序的逻辑是一样.所以我们可以考虑使用递归进行处理.要使用递归,我们就得注意递归使用的条件.首先递归我们最好单独写一个方法.其次,需要确定递归退出的条件.最后,我们需要共同的特性,规律.

    知道了上面的这些内容.就开始着手实现快速排序.
    话不多说,直接撸代码:

    package com.aaleiye.Algorithm;
    
    import java.util.Arrays;
    
    /**
     * Project_name: planRouteBuildBaseData
     * Company: aleiye
     * Author: yangsen
     * Date: Created in 下午6:15 2019/9/6.
     * Description:
     * Modified By:
     */
    public class quckSortT {
        public static void main(String[] args) {
            int[] arr = {5, 1, 2, 4, 6, 7, 3, 5, 8};
            int left = 0;
            int right = arr.length - 1;
            System.out.println(Arrays.toString(arr));
            sort(arr, left, right);
            System.out.println(Arrays.toString(arr));
    
        }
    
        private static void sort(int[] arr, int left, int right) {
            if (left > right) {
                return;
            } else {
                int mideIndex = getMideIndex(arr, left, right);
                //左侧的数组
                sort(arr, left, mideIndex - 1);
                //右侧的数组
                sort(arr, mideIndex + 1, right);
            }
    
        }
    
        //获取分界值的下标.
        private static int getMideIndex(int arr[], int left, int right) {
            int key = arr[left];
            while (left < right && left < right) {
                while (key <= arr[right]) {
                    right--;
                }
                arr[left] = arr[right];
                while (key >= arr[left] && left < right) {
                    left++;
                }
                arr[right] = arr[left];
            }
            arr[left] = key;
            return left;
        }
    }
    
    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,645
精华内容 2,258
关键字:

java实现快速排序

java 订阅