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

    2019-01-07 09:40:20
    java实现七种排序算法
  • Java实现排序算法

    2015-08-25 17:10:22
    冒泡排序、快速排序、归并排序、插入排序、选择排序、二分排序、希尔排序
  • Sort java实现排序算法 1、冒泡排序 2、直接插入排序 3、直接选择排序 4、希尔排序 5、归并排序 6、快速排序 7、堆排序 提交测试
  • Java实现排序算法之选择排序 Java实现排序算法之选择排序 head指针指向每次循环中的第一个位置(去掉最小值之后) rear指针在每次循环中遍历找最小值,如果有比head位置小的值,就与之交换 import java.util.Arrays;...

    Java实现排序算法之选择排序

    Java实现排序算法之选择排序

    head指针指向每次循环中的第一个位置(去掉最小值之后)
    rear指针在每次循环中遍历找最小值,如果有比head位置小的值,就与之交换

    import java.util.Arrays;
    
    public class SelectionSort {
    
        public static void sort(int[] data){
            int temp;
            int head = 0;
            int rear = head+1;
    
            while (head<data.length-1){
    
                while(rear<=data.length-1) {
    
                if (data[head]>data[rear]){
                    temp = data[head];
                    data[head] = data[rear];
                    data[rear] = temp;
                }
                
                rear++;
                }
                head++;
                rear = head+1;
            }
        }
    
        public static void main(String[] args) {
            int[] test = new int[]{9,836,72,6,5,42467,3,20,1};
            sort(test);
            System.out.println(Arrays.toString(test));
        }
    
    }
    
    
    展开全文
  • Java实现排序算法之合并排序 数组左半部分先进行分治,再对右半部分进行分治。 分:拆分成一个个元素 治:进行合并,谁小就先把谁放进temp临时数组里。 时间复杂度O(nlogn) import java.util.Arrays; public class ...

    Java实现排序算法之合并排序

    数组左半部分先进行分治,再对右半部分进行分治。
    分:拆分成一个个元素
    治:进行合并,谁小就先把谁放进temp临时数组里。
    时间复杂度O(nlogn)

    import java.util.Arrays;
    
    public class MergeSort {
        static int count = 0;
        public static void mergeSort(int[] data){
            int[] temp = new int[data.length];
            mergeSort(data,0,data.length-1,temp);
    
        }
    
        public static void mergeSort(int[] data, int start, int end, int[] temp){
            if (start<end) {
                int mid = (start + end) / 2;
    
                mergeSort(data, start, mid,temp);
    
                mergeSort(data, mid+1, end,temp);
    
                merge(data,start,mid,end,temp);
    
                System.out.println("merge: "+Arrays.toString(temp));
            }
    
        }
    
        private static void merge(int[] data, int start,int mid, int end, int[] temp){
            int i = start;
            int j = mid+1;
            int t = 0;
    
            while (i<=mid && j<=end){
                if (data[i]<=data[j]){
    
                    temp[t++] = data[i++];
    
                }else {
                    temp[t++] = data[j++];
    
                }
            }
            while (i<=mid){
                temp[t++] = data[i++];
    
            }
            while (j<=end){
                temp[t++] = data[j++];
            }
            t = 0;
            while (start<=end){
                data[start++] = temp[t++];
            }
    
    
        }
    
        public static void main(String[] args) {
            int[] test = new int[]{6,5,4,3,2,1};
            mergeSort(test);
            System.out.println(Arrays.toString(test));
        }
    }
    
    
    展开全文
  • java笔试题算法java排序算法Java 编写的排序算法。 先决条件: 码头工人(17.12.0-ce,构建 c97c6d6) docker-compose (1.19.0) 测试 docker-compose run gradle gradle clean test check # Test summary will ...
  • JAVA实现排序算法(三):希尔排序希尔排序希尔排序的介绍

    JAVA实现排序算法(三):希尔排序


    希尔排序

    希尔排序的介绍如图:


    代码如下


    package com.lx.sort;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    /**        
     * @ProjectName:  [MyAlgorithm]   
     * @Package:      [com.lx.sort]    
     * @ClassName:    [Example]     
     * @Description:  [排序]     
     * @Author:       [刘翔]     
     * @CreateDate:   [2017年11月12日 下午9:00:14]     
     * @UpdateUser:   [刘翔]     
     * @UpdateDate:   [2017年11月12日 下午9:00:14]     
     * @UpdateRemark: [说明本次修改内容]    
     * @Version:      [v1.0]   
     *      
     */
        public class Sort {
    
            /**
             * @param @param args
             * @Description: TODO(希尔排序)
             */
            public static String[] ShellSort(String[] a) {
                int N = a.length;
                int h = 1;
                while (h < N / 3) {   //设定步长1.4.13.40.。。。。
                    h = 3 * h + 1;
                }
                while (h >= 1) {  //将数组变成h有序
                    for (int i = h; i < N; i++) {
                        for (int j = i; j >= h && less(a[j], a[j - h]); j = j - h) {
                            exch(a, j, j - h);
                        }
                        h = h / 3;
                    }
                }
                return a;
    
            /**
            * @Description: TODO(判断v是否比w小)
            * @param @param args    
            */
            private static boolean less(String v,String w) {
                return v.compareTo(w) < 0;
            }
            /**
            * @Description: TODO(交换字符i和j的位置)
            * @param @param args    
            */
            private static void exch(String[] a,int i,int j) {
                String t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
            /**
            * @Description: TODO(用于打印当前序列)
            * @param @param args    
            */
            public static void show(String[] a) {
                for (int i = 0; i < a.length; i++) {
                    System.out.print(a[i] + " ");
                }
                System.out.println();
            }
            /**
            * @Description: TODO(用于测试字符序列a[]是否有序)
            * @param @param args    
            */
            public static boolean isSorted(String[] a) {
                for (int i = 1; i < a.length; i++) {
                    if (less(a[i],a[i-1])) {
                        return false;
                    }
                }
                return true;
            }
    
            /**
            * @Title: main
            * @Description: TODO(用于测试从键盘录入的一列字符是否有序)
            * @param @param args    
            */
            public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入要排序的字符序列,输入的字符序列格式为1,2,3...9");
                String str = sc.nextLine();
                String[] info = str.split(",");
                System.out.println("当前序列的顺序是:");
                show(info);
                System.out.println("对当前序列进行排序");
                //SelectSort(info);
                //InsertSort(info);
                //SelectSort(info);
                //MergeSort(info);
                MergeBUSort(info);
                System.out.println("现在序列的排序是:");
                show(info);
                if (isSorted(info)) {
                    System.out.println("序列已经成功的进行了排序");
                } else {
                    System.out.println("序列排序失败");
                }       
            }
        }
    

    运行结果如下

    展开全文
  • Java实现排序算法,目前只实现了冒泡和快速

    Java实现排序算法,目前只实现了冒泡和快速

    package sort;
    
    import java.util.Arrays;
    
    /**
     * 
     * @author QuPeng
     * 
     */
    public class SortAlgorithm {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		int[] array = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    		int[] array1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    		int[] array2 = { 6, 8, 2, 4, 9, 3, 5, 90, 3, 67, 3, 3, 78 };
    		int[] array3 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    
    		System.out.println(Arrays.toString(array));
    		quickSort(array, 0, array.length - 1);
    		System.out.println(Arrays.toString(array));
    
    		System.out.println(Arrays.toString(array3));
    		bubbleSort(array3);
    		System.out.println(Arrays.toString(array3));
    	}
    
    	public static void bubbleSort(int[] array) {
    		for (int i = 0; i < array.length; i++) {
    			for (int j = 0; j < array.length - 1 - i; j++) {
    				if (array[j + 1] < array[j]) {
    					int temp = array[j];
    					array[j] = array[j + 1];
    					array[j + 1] = temp;
    				}
    			}
    		}
    	}
    
    	public static void quickSort(int[] array, int lowIndex, int highIndex) {
    		if (lowIndex >= highIndex) {
    			return;
    		}
    
    		int i = lowIndex;
    		int j = highIndex;
    
    		int key = array[lowIndex];
    
    		while (true) {
    			while (i < j) {
    				if (array[j] < key) {
    					array[i] = array[j];
    					break;
    				}
    				j--;
    			}
    
    			while (i < j) {
    				if (array[i] > key) {
    					array[j] = array[i];
    					break;
    				}
    				i++;
    			}
    
    			if (i == j) {
    				array[j] = key;
    
    				quickSort(array, lowIndex, j - 1);
    				quickSort(array, j + 1, highIndex);
    
    				return;
    			}
    
    			System.out.println(Arrays.toString(array));
    		}
    	}
    }
    


    展开全文
  • JAVA实现排序算法(一):选择排序与插入排序选择排序的算法内容插入排序的算法内容代码package com.lx.sort;import java.util.Scanner;/** * @ProjectName: [MyAlgorithm] * @Package: [com.lx.sort] * @...
  • 包括常见的排序算法,以及折半查找,首先对要查找的数据排好序,然后用递归调用的方式实现折半查找(包括了两种实现方式)。指定一个排好序的数组和要查找的值,同时指定要查找的左边界和有边界。左右边界要位于数组...
  • 快速排序算法通过多次比较和交换实现排序,其排序流程如下: 1.首先设定一个分界值将数组分成左右两部分。 2.将大于等于分界值的数据集中在数组的右边,小于等于分界值的数据集中到数组的左边。此时左边部分各元素都...
  • 下面用Java实现一个堆排序,并用注释的方式解释了堆排序的思想和原理。 二、Java实现排序 /** * @author 王勤为 * * 1.这是实现堆排序的类,所有的方法都是静态方法,这里实现的是大顶堆 * * 堆排序包含...
  • 下面用Java实现一个快速排序,并用注释的方式解释了思想和原理。 二、Java实现排序 package com; /** * @author 王勤为 * * 这个是实现快速排序的类 * * 快速排序的基本思想是分治法:
  • Shell排序算法Shell排序算法严格来说基于插入排序的思想,其又称为希尔排序或者最小增量排序。Shell排序算法流程如下: 1.将有n个元素的数组分为你n/2个数字队列,第1个数据和第n/2+1个数据为一对,…… 2.一次循环使...
  • 插入排序算法插入排序算法通过比较和插入来实现排序,其排序算法流程如下: (1) 首先对数组的前两个数据进行从大到小排序。 (2)接着将第3个数据与排好序的两个数据比较,将第3个数据插入到合适位置。 (3)然后将第...
  • 归并排序算法一个待排序的原始数据序列进行归并排序的基本思路是,首先将含有n个节点的待排序序列看作是有n个长度为1的有序表组成,将它们两两合并,得到长度为2的有序子列若干,然后在对这些子序列两两合并,得到...
  • 冒泡排序算法的运作如下:(从后往前) 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 ...
  • 排序(Heap Sort)算法是基于选择排序思想的,其利用堆结构和二叉树的一些性质来完成数据的排序。堆排序在某些场合具有广泛的应用。堆排序过程一个完整的堆排序需要经过反复的两个步骤:构造堆结构和堆排序输出。 ...
  •  归并排序(Merge sort,台湾译作:合并排序)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。  算法描述  归并操作的过程如下: 申请空间,使其...
  • 交换排序是指通过交换元素位置来实现算法排序:最典型的就是冒泡排序和快速排序,下面分别讲解这两种算法算法思想,稳定性,时空复杂度和java实现代码
  • 解决排序问题的算法有很多,最直接了当的算法就属这里用Java实现的这两种算法了——选择排序和冒泡排序。1.选择排序 选择排序开始的时候,扫描整个列表,找到它的最小元素,然后和第一个元素交换,将最小元素放在...
  • 冒泡排序的思想:将带排序的序列两两进行比较,较大的一个“冒泡”,“冒泡”即如果下标为A 与B的数据比较,A 大则与B交换位置,否则就不交换位置,交换位置后,此时B的位置编程A,B 的下一个位置是B,两者在进行...
  • Java实现排序算法之 - 插入排序

    千次阅读 2017-03-07 23:28:49
    插入排序就是用了这种思想,先给定一个排好序的序列(通常设定为给定要排序序列的第一个值),然后陆续将后面的值与前面排好序的比较,如果是小于前面的值,就插到前面去。就这样一直比较,然后最后总会插入到合适的...
  • java实现归并排序讲解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,436
精华内容 5,774
关键字:

java实现排序算法

java 订阅