编程珠玑第11章--应用之排序

最新推荐文章于 2025-10-15 12:38:09 发布
原创 最新推荐文章于 2025-10-15 12:38:09 发布 · 721 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
编程珠玑

当前文章被收录于：

编程珠玑
15 篇文章 0 人学习
订阅专栏 查看详情
本文详细介绍了几种常见的排序算法，包括插入排序、快速排序等，并通过代码示例展示了不同方法的实现细节及效率对比。
1.插入排序

思想：假定x[0…0]是有序的，然后加入x[1],x[2],….,x[n];只要保证每次将待加入x[i]放入正确的位置即可。
方法一：从x[i]开始往前，两两比较，若是前者比后者大，则交换，否则终止
方法二：将x[i]暂存到temp里，两两比较，若是前者比后者大，则用前者覆盖后者，否则跳出循环，然后将temp赋给当前位置
插入排序总结，时间复杂度为O(n^2),如果数组本身就是接近有序的，会快很多

package chapter11;

import java.util.Arrays;


public class InsertionSort {
    public static int[] swap(int a,int b){
        int temp=a;
        a=b;
        b=temp;
        return new int[]{a,b};//由于Java里不支持指针，所以此处才写的如此麻烦。。。
    }
    public static void  insertionSort0(int arr[]){
        for(int i=1;i<arr.length;i++){//比较若前面的比当前的大，两个交换
            for(int j=i;j>0&&arr[j]<arr[j-1];j--){
                int re[]=swap(arr[j], arr[j-1]);
                arr[j]=re[0];
                arr[j-1]=re[1];
            }
        }
    }
    public static void insertionSort1(int arr[]){
        for(int i=1;i<arr.length;i++){
            for(int j=i;j>0&&arr[j]<arr[j-1];j--){
                int temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
            }
        }
    }
    public static void insertionSort2(int arr[]){
        //比较，若是前面的比当前的大，则用它覆盖后一个数；全部后移后，然后将值直接覆盖指定位置
        for(int i=1;i<arr.length;i++){
            int temp=arr[i];
            int j=i;
            for( ;j>0&&temp<arr[j-1];j--){
                arr[j]=arr[j-1];
            }
            arr[j]=temp;
        }
    }
    public static void main(String args[]){
        long current=System.currentTimeMillis();
        boolean firstIn=true;
//      for(int i=0;i<1000000000;i++){
//          int arr[]=new int[]{8,7,6,5,4,3,2,1};
//          insertionSort0(arr);
//          if(firstIn){
//              System.out.println(Arrays.toString(arr));
//              firstIn=false;
//          }
//      }
//      System.out.println((System.currentTimeMillis()-current)/1000);
//      current=System.currentTimeMillis();
//      firstIn=true;
        for(int i=0;i<1000000000;i++){
            int arr[]=new int[]{8,7,6,5,4,3,2,1};
            insertionSort1(arr);
            if(firstIn){
                System.out.println(Arrays.toString(arr));
                firstIn=false;
            }
        }
        System.out.println((System.currentTimeMillis()-current)/1000);
        current=System.currentTimeMillis();
        firstIn=true;
        for(int i=0;i<1000000000;i++){
            int arr[]=new int[]{8,7,6,5,4,3,2,1};
            insertionSort2(arr);
            if(firstIn){
                System.out.println(Arrays.toString(arr));
                firstIn=false;
            }
        }
        System.out.println((System.currentTimeMillis()-current)/1000);
    }
}

在我的机器上运行的结果

[1, 2, 3, 4, 5, 6, 7, 8]


84
[1, 2, 3, 4, 5, 6, 7, 8]
66

可见还是有区别的，思路二更有效率，思路一中交换需要三步，而思路而只需要一步，因而更快。

2.快速排序

思路：将大的数组划分成两个小的部分，然后对他们进行递归排序。主题都是使用分治法，主要是划分方法的不同，围绕第一个元素进行划分，将所有小于等于它的数移到左边，所有大于它的数移到右边。
方法一：单向划分，从左向右。
分界值boundaryValue选为最左边的元素，分解下标splitIndex初始化为left，然后进行一个循环，数组下标arrIndex从left+1到right，如果出现数组下标值小于分界值boundaryValue，将分界下标splitIndex加一，然后交换splitIndex和arrIndex对应的值；循环结束后交换splitIndex和left的值。
单向排序
方法二：单向划分，从右向左。
思想与第一个差不多，将划分元素arr【left】也包括在内了
单向排序2
方法三：双向划分
目的：为了避免所有元素相同情况下，上述的单向划分退化成为O(n^2)
思路：主循环中有两个内循环，内循环一 lIndex从数组的左边寻找大于等于arr[left]的，找到则停止加一操作；内循环二rIndex从数组的右端寻找小于等于arr【left】的，找到则停止减一操作；然后在主循环中判断lIndex与rIndex是否交叉并决定退出主循环还是交换值。最终交换arr[left]与arr[rIndex]
双向排序
方法四：双向划分加插入排序
因为当循环进行到一定程度时，待排序的部分很小，就没有必要花费很长时间进行双向排序了，直接返回就好。最后的时候对整个数组进行一下插入排序就解决了。

以下是四种方法的源程序
package chapter11;

import java.util.Arrays;
import java.util.Random;

public class QuickSort {
    //单向划分，从左向右
    public static void quickSort1(int arr[],int left,int right){
        if(left>=right)
            return;
        int boundaryValue=arr[left] ;//分界值
        int splitIndex=left;//记录分界下标的变化，《=splitIndex的都是小于分界值boundaryValue ,>splitsplitIndex的元素都是大于等于分界值boundaryValue
        int temp=0;
        for(int i=left+1;i<=right;i++){
            //循环不变式 arr[left+1...splitIndex]<boundaryValue arr[splitIndex+1....right]>=boundaryValue
            if(arr[i]<boundaryValue ){
                splitIndex++;
                temp=arr[splitIndex];
                arr[splitIndex]=arr[i];
                arr[i]=temp;
            }
        }
        arr[left]=arr[splitIndex];//将分界元素放到对象的分界下标上，交换即可
        arr[splitIndex]=boundaryValue ;
        quickSort1(arr, left, splitIndex-1);
        quickSort1(arr, splitIndex+1, right);
    }
    //单向划分，从右向左,其实就省了最后的交换划分元素过程
    public static void quickSort2(int arr[],int left,int right){
        if(left>=right)
            return;
        int splitIndex=right+1;
        for(int arrIndex=right;arrIndex>=left;arrIndex--){
            if(arr[arrIndex]>=arr[left]){
                splitIndex--;
                int temp=arr[splitIndex];
                arr[splitIndex]=arr[arrIndex];
                arr[arrIndex]=temp;
            }
        }
        quickSort2(arr, left, splitIndex-1);
        quickSort2(arr, splitIndex+1, right);
    }
    //双向划分，lIndex++,直到从左边找到大于等于分界值得元素或者rIndex大于rIndex；
    //rIndex--,直到从右边找到的元素小于等于分界值；
    //然后判断lIndex,rIndex的大小，若是
    public static void quickSort3(int arr[],int left,int right){
        //      System.out.println("boundaryValue="+arr[left]+ " left="+left+" right="+right);
        if(left>=right){
            return;
        }
        int temp=0;
        int boundaryValue =arr[left];
        int lIndex=left;
        int rIndex=right+1;
        while(true){
            do lIndex++ ; while(lIndex<=rIndex&&arr[lIndex]<boundaryValue);
            do rIndex-- ; while(arr[rIndex]>boundaryValue);
            if(lIndex>rIndex){
                break;
            }
            temp=arr[lIndex];
            arr[lIndex]=arr[rIndex];
            arr[rIndex]=temp;
        }
        arr[left] =arr[rIndex];
        arr[rIndex]=boundaryValue ;
        //      System.out.println("=>"+Arrays .toString(arr));
        quickSort3(arr, left, rIndex-1);
        quickSort3(arr, rIndex+1, right);
    }

    public static int generateRandom(int left,int right){
        Random random=new Random();
        return random.nextInt(right-left+1)+left;
    }
    public static void insertionSort2(int arr[]){
        //比较，若是前面的比当前的大，则用它覆盖后一个数；全部后移后，然后将值直接覆盖指定位置
        for(int i=1;i<arr.length;i++){
            int temp=arr[i];
            int j=i;
            for( ;j>0&&temp<arr[j-1];j--){
                arr[j]=arr[j-1];
            }
            arr[j]=temp;
        }
    }
    //双向划分加插入排序
    public static void quickSort4(int arr[],int left,int right,int cutOff){
//              System.out.println("boundaryValue="+arr[left]+ " left="+left+" right="+right);
        if(right-left<cutOff){
            return;
        }
        int temp=0;

        int result=generateRandom(left, right);//交换到最左端
//      System.out.println("reslut="+result);
        temp=arr[left];
        arr[left]=arr[result];
        arr[result]=temp;

        int boundaryValue =arr[left];
        int lIndex=left;
        int rIndex=right+1;
        while(true){
            do lIndex++ ; while(lIndex<=rIndex&&arr[lIndex]<boundaryValue);
            do rIndex-- ; while(arr[rIndex]>boundaryValue);
            if(lIndex>rIndex){
                break;
            }
            temp=arr[lIndex];
            arr[lIndex]=arr[rIndex];
            arr[rIndex]=temp;
        }
        arr[left] =arr[rIndex];
        arr[rIndex]=boundaryValue ;
//      System.out.println("=>"+Arrays .toString(arr));
        quickSort4(arr, left, rIndex-1,cutOff);
        quickSort4(arr, rIndex+1,right,cutOff);
    }
    public static void quickSort4( int arr[], int cutOff){
        quickSort4(arr, 0,arr.length-1, cutOff);
        insertionSort2(arr);
    }
    public static void main(String args[]){
        int arr[]=new int[]{10,13,1,11, 12,8,14,3,4, 15,4,5,12};

        //      int arr[]={2,2,2,2,2, 2,2,2,2,2};
//              quickSort1(arr, 0 ,arr.length-1);
//      quickSort3(arr, 0 ,arr.length-1);
        quickSort4(arr, 3);
//      quickSort2(arr, 0 ,arr.length-1);
        System.out.println(Arrays.toString(arr));

    }
}

课后习题
2.在上面的方法二已经写了
3.取不同的cutOff值对一个较大的数组进行排序，选择运行时间少的
4.看了后面答案的，但是感觉它的想x[i].bit[depth]会产生数组下标越界，所以在原来的基础上稍微改了一下。思路就是先看字符串长度是否满足本次深度的要求，若是不满足则跳过不予考虑：若是满足了，将当前深度为0的放到前面，为1的放到后面。

package chapter11;

import java.util.Arrays;

public class BitStringSort {
    public static void bitStringSort(String arr[],int left,int right,int depth){
        if(left>=right){
            return;
        }
        int splitIndex1=left;
        for(int arrIndex=left;arrIndex<=right;arrIndex++){
            if(arr[arrIndex].length()<depth){//根据bitString长度划分
                String temp=arr[arrIndex];
                arr[arrIndex]=arr[splitIndex1];
                arr[splitIndex1]=temp;
                splitIndex1++;
            }
        }
        int splitIndex2=splitIndex1;
        for(int arrIndex=splitIndex2;arrIndex<=right&&splitIndex2<=right;arrIndex++){
            try {
                if(arr[arrIndex].charAt(depth)=='0'){
                    String temp=arr[arrIndex];
                    arr[arrIndex]=arr[splitIndex2];
                    arr[splitIndex2]=temp;
                    splitIndex2++;
                }

            } catch (Exception e) {
                String temp=arr[arrIndex];
                arr[arrIndex]=arr[splitIndex2];
                arr[splitIndex2]=temp;
                splitIndex2++;
            }
        }
        bitStringSort(arr, splitIndex1, splitIndex2-1, depth+1);
        bitStringSort(arr, splitIndex2, right, depth+1);
    }
    public static void main(String args[]){
        String arr[]=new String[10];
        String temp="";
        for(int i=arr.length-1;i>=1;i-=2 ){
            arr[i]=temp+"0";
            arr[i-1]=temp+"1";
            temp+="1";
        }
        System.out.println(Arrays.toString(arr));
        bitStringSort(arr, 0, arr.length-1, 0);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果

[11111, 11110, 1111, 1110, 111, 110, 11, 10, 1, 0]
[0, 1, 10, 11, 110, 111, 1110, 1111, 11110, 11111]

6.选择排序
选择排序将数组中所有最小的放在想x[0],然后从1…n中剩下的选择最小的放在x[1],以此类推

public static void chooseSort(int arr[]){
        int minIndex;
        for(int outerIndex=0;outerIndex<arr.length-1;outerIndex++){
            minIndex=outerIndex;
            for(int innerIndex=outerIndex+1;innerIndex<arr.length;innerIndex++){
                if(arr[innerIndex]<arr[minIndex]){
                    minIndex=innerIndex;
                }
            }
            int temp=arr[outerIndex];
            arr[outerIndex]=arr[minIndex];
            arr[minIndex]=temp;
        }
    }

希尔排序(递减增量排序)请见
http://blog.csdn.net/morewindows/article/details/6668714
9.如何在O(n)时间内找到数组中第k个最小元素的问题。
思路：利用双向划分+插入排序的快速排序，也就是上面的方法四。在此基础上进行改写，只划分我们需要的部分，即arr[k]所在的部分；里面的generateRandom函数与上面的相同

public static void quickSort5(int arr[],int left,int right,int cutOff,int k){
        //      System.out.println("boundaryValue="+arr[left]+ " left="+left+" right="+right);
        if(right-left<cutOff){
            return;
        }
        int temp=0;

        int result=generateRandom(left, right);//交换到最左端
        //System.out.println("reslut="+result);
        temp=arr[left];
        arr[left]=arr[result];
        arr[result]=temp;

        int boundaryValue =arr[left];
        int lIndex=left;
        int rIndex=right+1;
        while(true){
            do lIndex++ ; while(lIndex<=rIndex&&arr[lIndex]<boundaryValue);
            do rIndex-- ; while(arr[rIndex]>boundaryValue);
            if(lIndex>rIndex){
                break;
            }
            temp=arr[lIndex];
            arr[lIndex]=arr[rIndex];
            arr[rIndex]=temp;
        }
        arr[left] =arr[rIndex];
        arr[rIndex]=boundaryValue ;
        //System.out.println("=>"+Arrays .toString(arr));
        if(k>rIndex) //只继续划分k所在的部分

            quickSort5(arr, rIndex+1,right,cutOff,k);
        if(k<rIndex){
            quickSort5(arr, left, rIndex-1,cutOff,k);
        }
    }

    public static void quickSort5( int arr[], int cutOff,int k){
        quickSort5(arr, 0,arr.length-1, cutOff,k);
        insertionSort2(arr);
    }
    public static void main(String args[]){

        int arr[]=new int[1000];
        for(int i=0;i<arr.length;i++ ){
            arr[i]=1000-i;
        }
        quickSort5(arr, 40, 51);

        System.out.println(Arrays.toString(arr)+"\n=>arr[51]="+arr[51]);
    }

11.

在单向划分的基础上更改，令t=arr[left]，用splitLeft记录<t的最后一个下标，用splitRight记录==t的最后一个下标。
情况二：当未划分部分arr[arrIndex]<t时

小于t时
情况二：当未划分部分arr[arrIndex]==t时
等于t时
循环结束后最后交换一下arr[left]与arr[splitLeft]的值
final
下面是程序

package chapter11;

import java.util.Arrays;

public class t11 {
    //单向划分的改写
    public static void quickSort_equalInCenter(int arr[],int left,int right){
        if(left>=right){
            return;
        }
        int splitLeft=left;
        int splitRight=left;
        for(int arrIndex=left+1;arrIndex<=right;arrIndex++){
            if(arr[arrIndex]<arr[left]){
                int temp=arr[splitRight+1];
                for(int i=splitLeft+1;i<=splitRight;i++){
                    arr[i+1]=arr[i];
                }
                splitLeft++;
                splitRight++;
                arr[splitLeft]=arr[arrIndex];
                arr[arrIndex]=temp;
            }

            if(arr[arrIndex]==arr[left]){
                int temp=arr[splitRight+1];
                splitRight++;
                arr[splitRight]=arr[arrIndex];
                arr[arrIndex]=temp;
            }
        }
        if(splitLeft>left){
            int temp=arr[splitLeft];
            arr[splitLeft]=arr[left];
            arr[left]=temp;

        }
        System.out.println(Arrays.toString(arr));
        System.out.println("splitLeft="+splitLeft+"  splitRight="+splitRight);
        quickSort_equalInCenter(arr, left, splitLeft-1);
        quickSort_equalInCenter(arr, splitRight+1, right);

    }
    public static void main(String args[]){
        int arr[]={2,1,4,2,5 ,2,4,3,5,3, 2,1};
        quickSort_equalInCenter(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果

[1, 1, 2, 2, 2, 2, 4, 3, 5, 3, 5, 4]
splitLeft=2  splitRight=5
[1, 1, 2, 2, 2, 2, 4, 3, 5, 3, 5, 4]
splitLeft=0  splitRight=1
[1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5]
splitLeft=8  splitRight=9
[1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5]
splitLeft=6  splitRight=7
[1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5]
splitLeft=10  splitRight=11
[1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5]

总结
1.对于算法的描述，画图有时比描述更易懂。
2.理解算法之后，要尽量用几个关键字将算法的主要思路说出来
3.排序算法真的很重要，所以还是多看几遍吧（微笑）

标签
#编程珠玑第11章
【读薄《编程珠玑》】贰 啊哈！算法
远航 | FIBOS.io
12-11 4426
这篇文章是[《读薄<编程珠玑>》系列博客][1]的第 贰 篇，在这篇文章中，作者提出了三个问题，并且给出了相应的解决方案，本文阐述了这三个问题以及解决方案，并且对课后习题进行了分析。 问题集合 0x00: 给定一个最多包含40亿个随机排列的32位整数的顺序文件，找出一个不在文件中的32位整数（在文件中至少缺失一个这样的数）。在具有足够内存的情况下，如何解决该问题？如果有几个外部的『临时』文件可用，但
编程珠玑第十一章----排序
weixin_30838921的博客
07-27 179
1、快速排序 原理：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。 void quickSort(int *a,int s,int t) //数组首地址a，数组起始位置s（初始值为0），结束位置t（初始值为n-1） { int i=s,j=t+1,temp,x=a[s]; do ...
编程珠玑（2）第十一章学习笔记
dzyhenry的专栏
05-11 847
本章主要介绍了插入排序和快排。          关于排序，在平时写程序过程中，我们往往直接使用库函数qsort或者是sort，但有时候对接口使用函数调用会不那么高效，我们可能会需要自己来写排序算法。          分析了插入排序和快排的时间复杂度，以及一些改进方案。关于插入排序和快排，其实是老生常谈了，但通过作者的娓娓道来，原来就是一个很简单的排序算法，如果不断改进，也总有余地。下面我把
编程珠玑：第11章 排序 11.1 插入排序
qingyuanluofeng的专栏
01-25 407
#include #include #include using namespace std; /* 问题:插入排序。 分析 ：插入排序的本质是：对于当前元素，从当前元素前面已经排好序的序列寻找出一个元素大于当前元素。然后将这两个元素交换 最容易混淆的两个排序： 选择排序，前面序列A[1..i-1]有序，当前第i个元素是后面序列A[i....n]中挑选的最小的元素组成，然后与A[i]元素交
编程珠玑---读书笔记---第11章排序
R_xiaozhu_Q的专栏
06-24 1188
插入排序： 对于小型的排序任务速度很快，它是稳定的，只需要O(1)的额外空间，基于比较和交换的次数为O(n^2)。 #include #include #include #include #include #include #include #include #include #include using namespace std; int x[8]={55,41,59,
编程珠玑十一章课后题答案
坚持
11-12 1155
1  通过排序来查找数组的最大值和最小值通常属于过度使用。
［编程珠玑］可变长位字符串的排序问题
Yoyo的专栏
01-20 497
这个问题是在编程珠玑的11章习题5. 我看了该题的答案，按照答案实现的程序硬是跑不出来，我给的测试位字符串数组为：     bitchars test[7];     test[0].len =2;     test[0].chars ="01";     test[1].len =5;     test[1].chars ="11010";     test[2].len =1
编程珠玑——快速排序总结
等价交换
11-07 1910
快速排序快速排序是二十世纪最伟大的10大算法之一。如何写好一个快速排序通常不是一件容易的事，同时面试中或者实际应用中也经常要用到快速排序。编程珠玑第11章专门介绍了快速排序，涉及到了基本的算法思想实现和一些优化，这里进行简单的总结以便以后快速的回忆。基本思想快速排序用到了分治，它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此
11、编程珠玑笔记十一排序
热门推荐
badman250的专栏
09-13 3万+
11、编程珠玑笔记十一排序          本篇名言：“当你感到悲哀痛苦时，最好是去学些什么东西。学习会使你永远立于不败之地。” 欢迎转载，转载请标明出处：          关于排序，之前在数据结构笔记中蛤蟆有写相关内容，大家可以再博客中查找相关内容。          作者介绍了插入排序，啊哈，终于用到我们之前学习的数据结构，想想有点激动的。          不同之处在于对插入排
部分排序(《编程珠玑(续)》第15章)
u010585135的专栏
11-15 643
部分排序算法：要排序数组中第k1
排序(《编程珠玑》第11章)
u010585135的专栏
10-20 715
下面分别介绍插入排序，快速排序，选择排序和希尔排序，堆排序在
编程珠玑11章——快速排序的改进
坚持
11-10 839
#include using namespace std; void swap(int*a,int*b) { int temp=*a; *a=*b; *b=temp; } void quicksort(int* a,int start,int end) { if(start>=end) return; int temp=a[start]; int i=start;
《编程珠玑》高清pdf版
weixin_30918633的博客
05-27 3595
下载地址：网盘下载 作者简介 编辑 Jon Bentley是位于新泽西州Murray Hill的朗讯贝尔实验室计算机科学研究中心的技术委员会委员，Jon自1998年就成为Dr. Dobb's Joumal杂志的特约编辑，他的“编程珠玑”专栏多年来一直是顶级学术杂志Communications of the ACM最风行的特色专栏之一，而本书正是...
书籍-Jon Bentley《编程珠玑》
最新发布
d3y1`5 81_09
10-15 663
《编程珠玑》通过一系列精心设计的编程问题，展示了如何运用巧妙的思维和简单的技术来解决复杂的编程挑战。全书分为四个主要部分：基础篇涵盖问题分析、算法思维、数据结构选择和程序正确性；性能篇深入探讨程序性能分析、估算技巧、算法设计技术和代码优化；产品篇介绍空间优化、排序算法、随机取样和搜索技术；附录部分提供算法分类、调优法则和编程陷阱等实用参考。每个章节都围绕具体的编程问题展开，通过问题分析、解决方案设计和实现细节的完整过程，培养读者的编程直觉和问题解决能力。
“《编程珠玑》（第2版）第1章”：整数排序
03-16 141
　　作者在文中阐述了从该章实例引出来的一般原理： 　　正确的问题。明确问题，这场战役就成功了90%。 　　位图数据结构。该数据结构描述了一个有限定义域内的稠密集合，其中的每一个元素最多出现一次并且没有其他任何数据与该元素相关联。即使这些条件没有完全满足（例如，存在重复元素或额外的数据），也可以用有限定义域内的键作为一个表项更复杂的表格的索引。 　　多趟算法。这些算法多趟读入其输入数...
《编程珠玑》第11章排序算法的简单C语言实现
qu1993的博客
09-04 213
int arr[10] = { 31, -41, 59, 26, -53, 58, 97, -93, -23, 84 }; void swap(int a, int b) { int tmp = arr[a]; arr[a] = arr[b]; arr[b] = tmp; } //插入排序1 void isort1(int n) { for (int i = 1; i < n; ...
编程珠玑 第10/11/12章
dkjkls的博客
12-19 527
读书笔记 摘自：《编程珠玑-第2版》第10章 节省空间使程序变得更加简单，网络传送数据时所需要的时间通常直接与数据的规模呈正比关键在于简单 简单性可以衍生出功能性、健壮性以及速度和空间数据空间技术 不存储，重新计算。牺牲更多的运行时间来换取更小的空间。对于许多跨网络运行的程序来说，在数据规模方面我们最关心的是传输数据需要花费的时间。有时我们会采纳“保存、不进行重新传输”的建议，通过本地缓存的方式
编程珠玑 11章 排序
eric43的专栏
05-15 436
/* sort.c */ /* 编程珠玑 */ /* 11 排序 */ /* 直接插入排序 1 */ void insert_sort(int array[], int n) { int i , j; int tmp; for (i = 1; i < n; i++) { for (j = i; j > 0 && array[j - 1] > array[j]; j--) {
编程珠玑第11章
ju136的专栏
10-03 1081
正文 插入排序与快速排序 习题 1、 最大值，最小值不用排序O(n)时间可以找到 中值也可以不排序O(n)可以找到 均值O(n)，不过对于浮点数来说，一般求均值，先排一下序，精度会提高。 众数一般用散列效果很好。 2、3、4、修改程序，最坏
编程珠玑摘录
OPEN_GIS
10-10 856
第1章 开篇 1）问题提出：为什么使用磁盘排序，怎样进行磁盘排序，去研究算法 2）仔细分析问题，可使得代码长度、编程时间和运行时间减少一个数量级。 3）恰当的问题描述占成功的90% 4）法国作家和航空器设计师Antoinede saint-Exupery 说：“设计师的至高境界不是他不能再往作品中添加什么东西，而是他不能再从中取走什么东西”。 第2章 算法 1）研究算法对正在工作的程序
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值