精华内容
下载资源
问答
  • java冒泡排序算法代码

    千次阅读 2020-05-11 22:11:55
    java 冒泡排序 算法 代码

    java最简洁冒泡排序算法

    package com.wgf.algorithm;
    
    import java.util.Arrays;
    
    public class Main {
        public static void main(String[] args) {
            int [] a={6,4,15,12,1,8,33,21,10};
            System.out.println("排序前顺序为:");
            for(int m:a){
                System.out.print(m+",");
            }
            System.out.println();
            int temp=0;int flag;
            for(int i =0;i<=a.length;i++){
                for(int j=1;j<a.length;j++){
                    if(a[j-1]>a[j]){
                        temp=a[j-1];
                        a[j-1]=a[j];
                        a[j]=temp;
                    }
                }
            }
            System.out.println("排序后顺序为:");
            for(int v:a){
                System.out.print(v+",");
            }
        }
    }
    

    输出结果:
    排序后顺序为:
    6 4 15 12 1 8 33 21 10
    排序后顺序为:
    1 4 6 8 10 12 15 21 33

    展开全文
  • java基数排序算法代码下载

    千次阅读 2014-07-21 09:50:56
    java基数排序算法代码下载 代码下载地址:http://www.zuidaima.com/share/1550463272684544.htm

    原文:java基数排序算法代码下载 代码下载地址:http://www.zuidaima.com/share/1550463272684544.htm

    基数排序:基数排序可以说是扩展了的桶式排序, * 比如当待排序列在一个很大的范围内,比如0到999999内,那么用桶式排序是很浪费空间的。 * 而基数排序把每个排序码拆成由d个排序码,比如任何一个6位数(不满六位前面补0)拆成6个排序码, * 分别是个位的,十位的,百位的。。。。 * 排序时,分6次完成,每次按第i个排序码来排。 * 一般有两种方式: * 1) 高位优先(MSD): 从高位到低位依次对序列排序 * 2) 低位优先(LSD): 从低位到高位依次对序列排序 * 计算机一般采用低位优先法(人类一般使用高位优先),但是采用低位优先时要确保排序算法的稳定性。 * 基数排序借助桶式排序,每次按第N位排序时,采用桶式排序。 * 对于如何安排每次落入同一个桶中的数据有两种安排方法: * 1)顺序存储:每次使用桶式排序,放入r个桶中,相同时增加计数。 * 2)链式存储:每个桶通过一个静态队列来跟踪。

     

    package com.zuidaima.javasort.radixsorter;  
      
    import java.util.Arrays; 
    /**
    *@author www.zuidaima.com
    **/
      
    public class RadixSorter {  
    public static boolean USE_LINK=true;  
          
        public void sort(int[] keys,int from ,int len,int radix, int d)  
        {  
            if(USE_LINK)  
            {  
                link_radix_sort(keys,from,len,radix,d);  
            }  
            else  
            {  
                array_radix_sort(keys,from,len,radix,d);  
            }  
              
        }  
          
          
        private final void array_radix_sort(int[] keys, int from, int len, int radix,  
                int d)   
        {  
            int[] temporary=new int[len];  
            int[] count=new int[radix];  
            int R=1;  
              
            for(int i=0;i<d;i++)  
            {  
                System.arraycopy(keys, from, temporary, 0, len);  
                Arrays.fill(count, 0);  
                for(int k=0;k<len;k++)  
                {  
                    int subkey=(temporary[k]/R)%radix;  
                    count[subkey]++;  
                }  
                for(int j=1;j<radix;j++)  
                {  
                    count[j]=count[j]+count[j-1];  
                }  
                for(int m=len-1;m>=0;m--)  
                {  
                    int subkey=(temporary[m]/R)%radix;  
                    --count[subkey];  
                    keys[from+count[subkey]]=temporary[m];  
                }  
                R*=radix;  
            }  
                 
        }  
      
      
        private static class LinkQueue  
        {  
            int head=-1;  
            int tail=-1;  
        }  
        private final void link_radix_sort(int[] keys, int from, int len, int radix, int d) {  
              
            int[] nexts=new int[len];  
              
            LinkQueue[] queues=new LinkQueue[radix];  
            for(int i=0;i<radix;i++)  
            {  
                queues[i]=new LinkQueue();  
            }  
            for(int i=0;i<len-1;i++)  
            {  
                nexts[i]=i+1;  
            }  
            nexts[len-1]=-1;  
              
            int first=0;  
            for(int i=0;i<d;i++)  
            {  
                link_radix_sort_distribute(keys,from,len,radix,i,nexts,queues,first);  
                first=link_radix_sort_collect(keys,from,len,radix,i,nexts,queues);  
            }  
            int[] tmps=new int[len];  
            int k=0;  
            while(first!=-1)  
            {  
              
                tmps[k++]=keys[from+first];  
                first=nexts[first];  
            }  
            System.arraycopy(tmps, 0, keys, from, len);  
              
              
        }  
        private final void link_radix_sort_distribute(int[] keys, int from, int len,  
                int radix, int d, int[] nexts, LinkQueue[] queues,int first) {  
              
            for(int i=0;i<radix;i++)queues[i].head=queues[i].tail=-1;  
            while(first!=-1)  
            {  
                int val=keys[from+first];  
                for(int j=0;j<d;j++)val/=radix;  
                val=val%radix;  
                if(queues[val].head==-1)  
                {  
                    queues[val].head=first;  
                }  
                else   
                {  
                    nexts[queues[val].tail]=first;  
                      
                }  
                queues[val].tail=first;  
                first=nexts[first];  
            }  
              
        }  
        private int link_radix_sort_collect(int[] keys, int from, int len,  
                int radix, int d, int[] nexts, LinkQueue[] queues) {  
            int first=0;  
            int last=0;  
            int fromQueue=0;  
            for(;(fromQueue<radix-1)&&(queues[fromQueue].head==-1);fromQueue++);  
            first=queues[fromQueue].head;  
            last=queues[fromQueue].tail;  
              
            while(fromQueue<radix-1&&queues[fromQueue].head!=-1)  
            {  
                fromQueue+=1;  
                for(;(fromQueue<radix-1)&&(queues[fromQueue].head==-1);fromQueue++);  
                  
                nexts[last]=queues[fromQueue].head;  
                last=queues[fromQueue].tail;  
                  
            }  
            if(last!=-1)nexts[last]=-1;  
            return first;  
        }  
          
        public static void main(String[] args) {  
            int[] a={1,4,8,3,2,9,5,0,7,6,9,10,9,135,14,15,11,33,999999999,222222222,1111111111,12,17,45,16};  
            USE_LINK=true;  
            RadixSorter sorter=new RadixSorter();  
            sorter.sort(a,0,a.length,10,10);  
            for(int i=0;i<a.length;i++)  
            {  
                System.out.print(a[i]+",");  
            }  
      
      
        }  
    

     标签: 算法 排序 基数 java话题: 语言基础

    展开全文
  • java桶式排序算法代码下载

    千次阅读 2014-07-20 09:49:10
    java桶式排序算法代码下载 代码下载地址:http://www.zuidaima.com/share/1550463272176640.htm

    原文:java桶式排序算法代码下载

    代码下载地址:http://www.zuidaima.com/share/1550463272176640.htm

    桶式排序: * 桶式排序不再是基于比较的了,它和基数排序同属于分配类的排序, * 这类排序的特点是事先要知道待排 序列的一些特征。 * 桶式排序事先要知道待排 序列在一个范围内,而且这个范围应该不是很大的。 * 比如知道待排序列在[0,M)内,那么可以分配M个桶,第I个桶记录I的出现情况, * 最后根据每个桶收到的位置信息把数据输出成有序的形式。 * 这里我们用两个临时性数组,一个用于记录位置信息,一个用于方便输出数据成有序方式, * 另外我们假设数据落在0到MAX,如果所给数据不是从0开始,你可以把每个数减去最小的数。

     

    package com.zuidaima.bucketsorter;
    /**
    *@autho www.zuidaima.com
    **/
      
    public class BucketSorter {  
         public void sort(int[] keys,int from,int len,int max)  
            {  
                int[] temp=new int[len];  
                int[] count=new int[max];  
                  
                  
                for(int i=0;i<len;i++)  
                {  
                    count[keys[from+i]]++;  
                }  
                //calculate position info  
                for(int i=1;i<max;i++)  
                {  
                    count[i]=count[i]+count[i-1];//这意味着有多少数目小于或等于i,因此它也是position+ 1  
                }  
                  
                System.arraycopy(keys, from, temp, 0, len);  
                for(int k=len-1;k>=0;k--)//从最末到开头保持稳定性  
                {  
                    keys[--count[temp[k]]]=temp[k];// position +1 =count  
                }  
            }  
            /** 
             * @param args 
             */  
            public static void main(String[] args) {  
      
                int[] a={1,4,8,3,2,9,5,0,7,6,9,10,9,13,14,15,11,12,17,16};  
                BucketSorter bucketSorter=new BucketSorter();  
                bucketSorter.sort(a,0,a.length,20);//actually is 18, but 20 will also work  
                  
                  
                for(int i=0;i<a.length;i++)  
                {  
                    System.out.print(a[i]+",");  
                }  
      
            }  
      
      
    }  
    	    			

    标签: 算法 桶式 排序 java sort话题: 语言基础


    展开全文
  • Java各种排序算法代码分析

    千次阅读 2019-03-15 00:50:16
    Java 冒泡排序、堆排序、插入排序、归并操作、快速排序、希尔排序、选择排序。 package prms.utils.sort; import java.util.Arrays;... 排序算法 工具类 &lt;/p&gt; * @author edga...

    Java 冒泡排序、堆排序、插入排序、归并操作、快速排序、希尔排序、选择排序。


    package prms.utils.sort;
     
    import java.util.Arrays;
     
    /**
     * @ClassName:     SortUtils
     * @Description:  <p> 排序算法 工具类 </p>
     * @author         edgar
     * @email          【edgar_dr@163.com】
     * @version        V 1.0  
     * @date           2017-3-28 15:35:12
     */
    public class SortUtils {
         
        /**
         * @Title:        SortUtils
         * @Description:    私有化构造 :类不能实例化
         */
        private SortUtils(){}
         
        public static void main(String[] args) {
            int[] arr = { 2, 5, 3, 1, 4 };
            System.out.println("排序前:" + Arrays.toString(arr));
             
             bubbleSort(arr);
             heapSort(arr);
            insertSort(arr);
            mergeSort(arr);
            quickSort(arr);
            selectionSort(arr);
            shellSort(arr);
            System.out.println("排序后:" + Arrays.toString(arr));
        }
         
         
        /**
         * @Title: bubbleSort
         * @Description: 冒泡排序
         *              依次比较相邻的两个数,将小数放在前面,大数放在后面。
         *              即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。
         *              然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,
         *              直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,
         *              将最大的数放到了最后。在第二趟:仍从第一对数开始比较
         *              (因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),
         *              将小数放前,大数放后,一直比较到倒数第二个数(倒数第一的位置上已经是最大的),
         *              第二趟结束,在倒数第二的位置上得到一个新的最大数
         *              (其实在整个数列中是第二大的数)。如此下去,重复以上过程,直至最终完成排序。 
         * @param data   
         * @return void 
         */
        public static void bubbleSort(int[] data){
            for (int i = 0; i < data.length - 1; i++) {
                for (int j = 0; j < data.length - 1 - i; j++) {
                    if (data[j] > data[j + 1]) {
                        swap(data, j, j + 1);
                    }
                }
            }
        }
         
        /**
         * @Title: heapSort
         * @Description: 堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征, 使得在当前无序区中选取最大(或最小)关键字的记录变得简单。  
         *         (1)用大根堆排序的基本思想    
         *          ① 先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区    
         *          ②再将关键字最大的记录R[1](即堆顶)和无序区的最后一个 记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],
         *         且满足R[1..n-1].keys≤R[n].key    ③由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。
         *         然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换,
         *         由此得到新的无序区R[1..n-2]和有序区R[n-1..n],
         *         且仍满足关系R[1..n-2].keys≤R[n-1..n].keys,同样要将R[1..n-2]调整为堆。   直到无序区只有一个元素为止。   
         *         (2)大根堆排序算法的基本操作:   
         *          ① 初始化操作:将R[1..n]构造为初始堆;    
         *          ②每一趟排序的基本操作:将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换, 然后将新的无序区调整为堆(亦称重建堆)。
         *          
         * @param data   
         * @return void 
         */
        public static void heapSort(int[] data) {
            MaxHeap h = new MaxHeap();
            h.init(data);
            for (int i = 0; i < data.length; i++)
                h.remove();
            System.arraycopy(h.queue, 1, data, 0, data.length);
        }
     
        private static class MaxHeap {
            private int size = 0;
            private int[] queue;
             
            void init(int[] data) {
                this.queue = new int[data.length + 1];
                for (int i = 0; i < data.length; i++) {
                    queue[++size] = data[i];
                    fixUp(size);
                }
            }
             
            @SuppressWarnings("unused")
            public int get() {
                return queue[1];
            }
            public void remove() {
                swap(queue, 1, size--);
                fixDown(1);
            }
            // fixdown
            private void fixDown(int k) {
                int j;
                while ((j = k << 1) <= size) {
                    if (j < size && queue[j] < queue[j + 1])
                        j++;
                    if (queue[k] > queue[j]) // 不用交换
     
                        break;
                    swap(queue, j, k);
                    k = j;
                }
            }
            private void fixUp(int k) {
                while (k > 1) {
                    int j = k >> 1;
                    if (queue[j] > queue[k])
                        break;
                    swap(queue, j, k);
     
                    k = j;
                }
            }
     
        }
         
        /**
         * @Title: insertSort
         * @Description: 插入排序基本思想
         *             将n个元素的数列分为已有序和无序两个部分,如插入排序过程示例下所示:   
         *             {{a1},{a2,a3,a4,…,an}}   
         *             {{a1⑴,a2⑴},{a3⑴,a4⑴ …,an⑴}}  
         *             {{a1(n-1),a2(n-1) ,…},{an(n-1)}}   
         *             每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较,
         *             找出插入位置,将该元素插入到有序数列的合适位置中。
         * @param data   
         * @return void 
         */
        public static void insertSort(int[] data) {
            for (int i = 1; i < data.length; i++) {
                for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
                    swap(data, j, j - 1);
                }
            }
     
        }
         
        /**
         * @Title: mergeSort
         * @Description: 归并操作(merge),也叫归并算法,指的是将两个已经排序的序列合并成一个序列的操作。 
         *             如设有数列{6,202,100,301,38,8,1}   
         *             初始状态: [6] [202] [100] [301] [38] [8] [1] 比较次数   
         *             i=1 [6 202 ] [ 100 301] [ 8 38] [ 1 ] 3   
         *             i=2 [ 6 100 202 301 ] [ 1 8 38 ] 4   
         *             i=3 [ 1 6 8 38 100 202 301 ] 4 
         * @param data   
         * @return void 
         */
        public static void mergeSort(int[] data) {
            int[] temp = new int[data.length];
            mergeSort(data, temp, 0, data.length - 1);
        }
        private static void mergeSort(int[] data, int[] temp, int l, int r) {
            int mid = (l + r) / 2;
            if (l == r){
                return;
            }
             
            mergeSort(data, temp, l, mid);
            mergeSort(data, temp, mid + 1, r);
     
            for (int i = l; i <= r; i++) {
                temp[i] = data[i];
            }
            int i1 = l;
            int i2 = mid + 1;
            for (int cur = l; cur <= r; cur++) {
                if (i1 == mid + 1){
                    data[cur] = temp[i2++];
                }else if (i2 > r){
                    data[cur] = temp[i1++];
                }else if (temp[i1] < temp[i2]){
                    data[cur] = temp[i1++];
                }else{
                    data[cur] = temp[i2++];
                }
            }
        }
     
        /**
         * @Title: quickSort
         * @Description:快速排序
         *             一趟快速排序的算法是:   
         *             1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;  
         *             2)以第一个数组元素作为关键数据,赋值给key,即 key=A[0];   
         *             3)从j开始向前搜索,即由后开始向前搜索(j=j-1即j--),找到第一个小于key的值A[j],A[i]与A[j]交换;   
         *             4)从i开始向后搜索,即由前开始向后搜索(i=i+1即i++),找到第一个大于key的A[i],A[i]与A[j]交换;   
         *             5)重复第3、4、5步,直到 I=J; (3,4步是在程序中没找到时候j=j-1,i=i+1,直至找到为止。
         *             找到并交换的时候i, j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。) 
         * @param data   
         * @return void 
         */
        public static void quickSort(int[] data) {
            quickSort(data, 0, data.length - 1);
        }
        private static void quickSort(int[] data, int i, int j) {
            int pivotIndex = (i + j) / 2;
            // swap
            swap(data, pivotIndex, j);
             
            int k = partition(data, i - 1, j, data[j]);
            swap(data, k, j);
            if ((k - i) > 1){
                quickSort(data, i, k - 1);
            }
            if ((j - k) > 1){
                quickSort(data, k + 1, j);
            }
        }
     
        /**
         * @param data
         * @param i
         * @param j
         * @return
         */
        private static int partition(int[] data, int l, int r, int pivot) {
            do {
                while (data[++l] < pivot);
                while ((r != 0) && data[--r] > pivot);
                swap(data, l, r);
            } while (l < r);
            swap(data, l, r);
            return l;
        }
     
        /**
         * @Title: shellSort
         * @Description: 希尔排序:
         *       先取一个小于n的整数d1作为第一个增量,把文件的全部记录分成(n除以d1)个组。所有距离为d1的倍数的记录放在同一个组中。
         *      先在各组内进行直接插入排序;然后,取第二个增量d2<d1重复上述的分组和排序,直至所取的增量dt=1(dt<dt-l<…<d2<d1),
         *      即所有记录放在同一组中进行直接插入排序为止。 
         * 
         * 
         *      属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序    
         *      排序过程:先取一个正整数d1<n,把所有序号相隔d1的数组元素放一组,
         *      组内进行直接插入排序;然后取d2<d1,重复上述分组和排序操作;直至di=1, 即所有记录放进一个组中排序为止    
         *      初始:d=5   49 38 65 97 76 13 27 49 55 04    
         *      49 13   |-------------------|    
         *      38 27     |-------------------|    
         *      65 49   |-------------------|    
         *      97 55     |-------------------|    
         *      76 04   |-------------------|    
         *      一趟结果   13 27 49 55 04 49 38 65 97 76    
         *      d=3    13 27 49  55 04 49 38 65 97 76    
         *      13 55 38 76 |------------|------------|------------|    
         *      27 04 65 |------------|------------|    
         *      49 49 97 |------------|------------|   
         *      二趟结果  13 04 49* 38 27 49 55 65 97 76    
         *      d=1   13 04 49 38 27 49 55 65 97 76
         *         |----|----|----|----|----|----|----|----|----|    三趟结果   
         *      04 13 27 38 49 49 55 65 76 97
         * @param data   
         * @return void 
         */
        public static void shellSort(int[] data) {
            for (int i = data.length / 2; i > 2; i /= 2) {
                for (int j = 0; j < i; j++) {
                    insertSort(data, j, i);
                }
            }
            insertSort(data, 0, 1);
        }
     
        /**
         * @param data
         * @param j
         * @param i
         */
        private static void insertSort(int[] data, int start, int inc) {
            for (int i = start + inc; i < data.length; i += inc) {
                for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
                    swap(data, j, j - inc);
                }
            }
        }
         
        /**
         * @Title: selectionSort
         * @Description: 选择排序基本思路:
         *              把第一个元素依次和后面的所有元素进行比较。第一次结束后,就会有最小值出现在最前面。依次类推
         * @param data   
         * @return void 
         */
        public static void selectionSort(int[] data) {
            for (int x = 0; x < data.length - 1; x++) {
                for (int y = x + 1; y < data.length; y++) {
                    if (data[y] < data[x]) {
                        swap(data, x, y);
                    }
                }
            }
        }
         
        /**
         * @Title: swap
         * @Description: 交换数组中的两个元素
         * @param data
         * @param i
         * @param j   
         * @return void 
         */
        public static void swap(int[] data, int i, int j) {
            int temp = data[i];
            data[i] = data[j];
            data[j] = temp;
        }
         
    }

     

    展开全文
  • 排序算法猴子排序java算法代码实现

    千次阅读 2019-01-10 16:29:54
    猴子排序</h1> 原理:现有一组未排序数据和相同数量的方格,然后依次随机地取出数据随机地放入方格中,直到把方格放满即止。 之所以又被称为猴子排序,我的猜测是因为。将这种随机的特性利用猴子来形容,...
  • java排序算法汇总

    千次阅读 2017-02-07 12:18:59
    java排序算法 直接插入排序、 希尔排序、 简单选择排序、 java实现堆排序 堆排序java实现 冒泡排序 快速排序 归并排序 技术排序
  • JAVA排序算法实现代码-二叉树排序

    千次阅读 2008-11-19 15:46:00
    JAVA排序算法实现代码-二叉树排序 /** * JAVA排序算法实现代码-二叉树排序。 * * @author 老紫竹 JAVA世纪网(java2000.net) * */ public class Test { public static int[] a = { 0, 10, 32,...
  • JAVA排序算法实现代码-插入排序

    千次阅读 2008-11-19 15:48:00
    JAVA排序算法实现代码-插入排序 /** * JAVA排序算法实现代码-插入排序。 * * @author 老紫竹 JAVA世纪网(java2000.net) * */ public class Test { public static int[] a = { 10, 32, 1, 9,...
  • Java排序算法

    千次阅读 2017-11-23 12:28:55
    Java排序算法正在Java学习之排序算法,思路来源:http://blog.csdn.net/chao360559040/article/details/5973716一、直接插入排序 每次执行,把后面的数插入到前面已经排序好的数组中,直到最后一个完成。public ...
  • 经典十大排序算法Java版完整代码】写在前面的话十大排序算法对比冒泡排序快速排序直接选择排序堆排序归并排序插入排序希尔排序计数排序桶排序基数排序 写在前面的话        ...
  • 常见几种java排序算法

    万次阅读 多人点赞 2019-02-18 18:08:16
    1.插入排序 public class InsertSort { public static void sort(int[] arr) { if (arr.length &amp;amp;amp;gt;= 2) { for (int i = 1; i &amp;amp;amp;lt; arr.length; i++) { //挖出一个要用来插入...
  • java数组冒泡排序算法代码详解

    千次阅读 2019-10-17 15:45:38
    冒泡排序由两层嵌套循环实现排序,外层循环数据对比轮数,内层循环控制每轮对比次数,每一轮依次减少一次对比次数,最终实现排序 */ //乱序数组 int[] arr = {9,3,2,10,4,6}; //外层控制对比轮...
  • java排序算法总结

    千次阅读 2014-08-15 15:14:55
    java排序算法,直接排序,插入排序,交换排序,归并排序
  • Java 排序算法-冒泡排序及其优化

    千次阅读 2020-03-15 01:11:06
    Java 排序算法-冒泡排序及其优化 Java 排序算法-冒泡排序及其优化什么是冒泡排序基本写法优化后写法终极版本源码及测试 什么是冒泡排序 这里引用一下百度百科上的定义: 冒泡排序(Bubble Sort),是一种计算机科学...
  • 冒泡排序算法代码

    万次阅读 2017-08-16 16:03:11
    冒泡排序算法代码
  • 0、排序算法说明 0.1 排序的定义 对一序列对象根据某个关键字进行排序。 0.2 术语说明 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面; 不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b...
  • JAVA排序算法之希尔排序

    千次阅读 2019-10-17 09:25:14
    希尔排序是希尔(Donald Shell)于 1959 年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序。 希尔排序法基本思想 希尔排序是把记录按下标的一定...
  • java冒泡排序Bubble Sort算法代码

    千次阅读 2014-07-18 09:54:40
    java冒泡排序Bubble Sort算法代码 下载代码地址:http://www.zuidaima.com/share/1550463269096448.htm
  • java排序算法

    千次阅读 2007-03-22 15:16:00
    排序是CODE经常会用到的,在此做一个用JAVA实现的排序算法以供以后忘了的时候有备参考! 首先,在排序过程中,经常会对数组中两个元素进行交换,以下是交换算法: public static void swap(int[] array, int i, ...
  • java排序算法,排序都有哪几种算法? 排序的算法有分别有: 1、插入排序 (直接插入排序、希尔排序) 2、交换排序(冒泡排序、快速排序) 3、选择排序(直接选择排序、堆排序) 4、归并排序 5、分配排序(箱...
  • Java排序算法实现方式(算法思路 过程动图)

    千次阅读 多人点赞 2019-10-15 16:33:07
    排序算法 待排序的元素需要实现 Java 的 Comparable 接口,该接口有 compareTo() 方法,可以用它来判断两个元素的大小关系。 使用辅助函数 less() 和 swap() 来进行比较和交换的操作,使得代码的可读性和可移植性...
  • Java排序算法总结(四):希尔排序

    千次阅读 2013-11-16 21:47:35
    Java排序算法总结(四):希尔排序  前言:希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序,  因DL.Shell于1959年提出而得名。本文主要介绍希尔排序用Java是...
  • Java排序算法之快速排序

    万次阅读 热门讨论 2018-12-17 17:46:35
    快速排序,顾名思义,速度快;其时间复杂度为(NlogN),那么它是如何运作来实现高速排序的呢?先讲一下它的基本原理:  (1)寻找到一个枢纽元,也就是在一组元素中找一个元素(怎么找是有讲究的);  (2)然后在这组...
  • Java排序算法总结(三):冒泡排序

    千次阅读 2013-11-16 21:41:53
    Java排序算法总结(三):冒泡排序 前言:冒泡排序(BubbleSort)就是依次比较相邻的两个数,将小数放在前面,大数放在后面。  下面让我们一起 来看冒泡排序在Java中的算法实现。    冒泡排序是计算机...
  • Java排序算法总结(五):归并排序

    千次阅读 2013-11-16 21:52:22
    Java排序算法总结(五):归并排序  归并操作(merge),也叫归并算法,指的是将两个已经排序的序列合并成一个序列的操作。和快速排序类似,让我们一起来看,归并在Java中的实现。  归并排序...
  • java希尔排序算法

    千次阅读 2014-07-27 12:51:49
    java希尔排序算法 代码下载地址:http://www.zuidaima.com/share/1550463279090688.htm
  • Java排序算法(九):归并排序

    万次阅读 多人点赞 2011-07-08 00:25:41
    Java排序算法(九):归并排序 归并排序(Merge)是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。归并排序是...
  • 目录 ...希尔排序(如果将希尔排序的初始增量设置为1,则就是简单的插入排序) /** * 希尔排序 * @param intArray 目标数组 * @return 结果数组 */ public int[] hillSort(int[] intArray){ ...
  • Java排序算法(十一):基数排序

    万次阅读 2011-07-10 16:19:38
    Java排序算法(十一):基数排序基数排序已经不再是一种常规的排序方式,它更多地像一种排序方法的应用,基数排序必须依赖于另外的排序方法。基数排序的总体思路就是将待排序数据拆分成多个关键字进行排序,也就是说...
  • java算法插入排序优化代码

    千次阅读 2014-07-28 09:35:56
    java算法插入排序优化代码 代码下载地址:http://www.zuidaima.com/share/1550463280630784.htm

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 178,010
精华内容 71,204
关键字:

java排序算法代码

java 订阅