精华内容
下载资源
问答
  • 2020-11-29:手写代码排序。.pdf
  • 代码 - 手写堆

    2013-03-05 09:45:03
    #include #include #define onlinejudge const int maxn = 1000010; const int INF = 0x3F3F3F3F; char ch; int casenum, kNum, cnt, num, heap[maxn]; void shiftdown(int fa, int n) ... int son, key=h
    #include 
      
       
    #include 
       
        
    
    #define onlinejudge
    
    const int maxn = 1000010;
    const int INF  = 0x3F3F3F3F;
    
    char ch;
    int  casenum, kNum, cnt, num, heap[maxn];
    
    void shiftdown(int fa, int n)
    {
        int	son, key=heap[fa];
        for (; fa<=n>>1; fa=son)
        {
            son = fa<<1;    /* Left_child */
            if (son!=n && heap[son+1]
        
          heap[son])
                heap[fa] = heap[son];
            else
                break;
        }/* End of For */
        heap[fa] = key;
    }/* shiftdown */
    
    void InsertHeap(int t)
    {
        heap[++cnt] = t;
        
        int p = cnt;
        while (p!=1 && heap[p>>1]>t)
        {
            heap[p] = heap[p>>1];
            p >>= 1;
        }/* End of While */
        heap[p] = t;
    }/* InsertHeap */
    
    void PopHeadTop(int t)
    {
        heap[1] = t;
        shiftdown(1, cnt);
    }/* PopHeadTop */
    
    int main()
    {
    #ifdef onlinejudge
        freopen("E:\\hdoj4006.txt", "r", stdin);
        freopen("E:\\hdoj4006_ans.txt", "w", stdout);
    #endif
    
        while (~scanf("%d %d", &casenum, &kNum))
        {
            memset(heap, INF, sizeof(heap));
            
            cnt = 0;
            for (int i=1; i<=casenum; ++i)
            {
                getchar();
                scanf("%c", &ch);
                if (ch == 'I')
                {
                    scanf("%d", &num);
                    if (cnt < kNum)
                    {
                        InsertHeap(num);
                    }
                    else if (num > heap[1])
                    {
                        PopHeadTop(num);
                    }
                }
                else
                {
                    printf("%d\n", heap[1]);
                }
            }/* End of For */
        }/* End of While */
        
        return 0;
    }
    
        
       
      
    展开全文
  • 福哥答案2020-11-29: 1,先让整个数组都变成大根结构,建立的过程: 1)从上到下的方法,...golang代码如下: package class04 import ( "fmt" "testing" ) /* 排序 1,先让整个数组都变成大根结构,建立

    福哥答案2020-11-29:
    1,先让整个数组都变成大根堆结构,建立堆的过程:
    1)从上到下的方法,时间复杂度为O(NlogN)。
    2)从下到上的方法,时间复杂度为O(N)。
    2,把堆的最大值和堆末尾的值交换,然后减少堆的大小之后,再去调整堆,一直周而复始,时间复杂度为O(N
    logN)。
    3,堆的大小减小成0之后,排序完成。

    golang代码如下:

    package class04
    
    import (
        "fmt"
        "testing"
    )
    
    /*
    堆排序
    1,先让整个数组都变成大根堆结构,建立堆的过程:
        1)从上到下的方法,时间复杂度为O(N*logN)
        2)从下到上的方法,时间复杂度为O(N)
    2,把堆的最大值和堆末尾的值交换,然后减少堆的大小之后,再去调整堆,一直周而复始,时间复杂度为O(N*logN)
    3,堆的大小减小成0之后,排序完成
    
    与堆有关的题目
    已知一个几乎有序的数组。几乎有序是指,如果把数组排好顺序的话,每个元素移动的距离一定不超过k,并且k相对于数组长度来说是比较小的。
    请选择一个合适的排序策略,对这个数组进行排序。
    
    */
    //go test -v -test.run TestHeapSort
    func TestHeapSort(t *testing.T) {
        fmt.Println("----------------------")
        if true {
            arr := []int{1, 5, 3, 9, 7, 2, 1, 2, 2, 8}
            fmt.Println("原数组 = ", arr)
            heapSort(arr)
            fmt.Println("排序后 = ", arr)
            fmt.Println("\r\n----------------------")
        }
    
    }
    
    // 堆排序额外空间复杂度O(1)
    func heapSort(arr []int) {
        if len(arr) < 2 {
            return
        }
        // O(N*logN)
        //      for (int i = 0; i < arr.length; i++) { // O(N)
        //          heapInsert(arr, i); // O(logN)
        //      }
        for i := len(arr) - 1; i >= 0; i-- {
            heapify(arr, i, len(arr))
        }
        heapSize := len(arr)
        heapSize--
        swap(arr, 0, heapSize)
        // O(N*logN)
        for heapSize > 0 { // O(N)
            heapify(arr, 0, heapSize) // O(logN)
            heapSize--
            swap(arr, 0, heapSize) // O(1)
        }
    }
    
    // arr[index]刚来的数,往上
    func heapInsert(arr []int, index int) {
        for arr[index] > arr[(index-1)/2] {
            swap(arr, index, (index-1)/2)
            index = (index - 1) / 2
        }
    }
    
    // arr[index]位置的数,能否往下移动
    func heapify(arr []int, index int, heapSize int) {
        left := index*2 + 1   // 左孩子的下标
        for left < heapSize { // 下方还有孩子的时候
            // 两个孩子中,谁的值大,把下标给largest
            // 1)只有左孩子,left -> largest
            // 2) 同时有左孩子和右孩子,右孩子的值<= 左孩子的值,left -> largest
            // 3) 同时有左孩子和右孩子并且右孩子的值> 左孩子的值, right -> largest
            largest := 0
            if left+1 < heapSize && arr[left+1] > arr[left] {
                largest = left + 1
            } else {
                largest = left
            }
            // 父和较大的孩子之间,谁的值大,把下标给largest
            if arr[largest] > arr[index] {
    
            } else {
                largest = index
            }
            if largest == index {
                break
            }
            swap(arr, largest, index)
            index = largest
            left = index*2 + 1
        }
    }
    
    func swap(arr []int, i int, j int) {
        tmp := arr[i]
        arr[i] = arr[j]
        arr[j] = tmp
    }
    

    敲命令 go test -v -test.run TestHeapSort 执行结果如下:
    在这里插入图片描述

    展开全文
  • 当初面试官让我现场手写内存溢出案例代码,我就以Java代码的方式列举了几典型的内存溢出案例。今天分享给大家,希望大家在日常工作中,尽量避免写这些low水平的代码

    大家好,我是冰河~~

    作为程序员,多多少少都会遇到一些内存溢出的场景,如果你还没遇到,说明你工作的年限可能比较短,或者你根本就是个假程序员!哈哈,开个玩笑。

    当初面试官让我现场手写内存溢出案例代码,我就以Java代码的方式列举了几个典型的内存溢出案例。今天分享给大家,希望大家在日常工作中,尽量避免写这些low水平的代码。

    小伙伴们点赞,收藏,评论,走起呀

    我们先来看看今天要介绍哪些内存溢出案例,冰河这里总结了一张图,如下所示。

    说干就干,咱们开始吧!!

    定义主类结构

    首先,我们创建一个名称为BlowUpJVM的类,之后所有的案例实验都是基于这个类进行。如下所示。

    public class BlowUpJVM {  
    } 
    

    栈深度溢出

    public static void  testStackOverFlow(){ 
          BlowUpJVM.testStackOverFlow(); 
    } 
    

    栈不断递归,而且没有处理,所以虚拟机栈就不断深入不断深入,栈深度就这样溢出了。

    永久代内存溢出

    public static void testPergemOutOfMemory1(){ 
       //方法一失败 
       List<String> list = new ArrayList<String>(); 
       while(true){ 
          list.add(UUID.randomUUID().toString().intern()); 
       } 
    } 
    

    打算把String常量池堆满,没想到失败了,JDK1.7后常量池放到了堆里,也能进行垃圾回收了。

    然后换种方式,使用cglib,用Class把老年代取堆满

    public static void testPergemOutOfMemory2(){ 
       try { 
          while (true) { 
             Enhancer enhancer = new Enhancer(); 
             enhancer.setSuperclass(OOM.class); 
             enhancer.setUseCache(false); 
             enhancer.setCallback(new MethodInterceptor() { 
                @Override 
                public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
                   return proxy.invokeSuper(obj, args); 
                } 
             }); 
             enhancer.create(); 
          } 
       } 
       catch (Exception e){ 
          e.printStackTrace(); 
       } 
    } 
    

    虚拟机成功内存溢出了,那JDK动态代理产生的类能不能溢出呢?

    public static void testPergemOutOfMemory3(){ 
       while(true){ 
       final OOM oom = new OOM(); 
       Proxy.newProxyInstance(oom.getClass().getClassLoader(), oom.getClass().getInterfaces(), new InvocationHandler() { 
             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                Object result = method.invoke(oom, args); 
                return result; 
             } 
          }); 
       } 
    } 
    

    事实表明,JDK动态代理差生的类不会造成内存溢出,原因是:JDK动态代理产生的类信息,不会放到永久代中,而是放在堆中。

    本地方法栈溢出

    public static void testNativeMethodOutOfMemory(){ 
       int j = 0; 
       while(true){ 
          Printer.println(j++); 
          ExecutorService executors = Executors.newFixedThreadPool(50); 
          int i=0; 
          while(i++<10){ 
             executors.submit(new Runnable() { 
                public void run() { 
                } 
             }); 
          } 
       } 
    } 
    

    这个的原理就是不断创建线程池,而每个线程池都创建10个线程,这些线程池都是在本地方法区的,久而久之,本地方法区就溢出了。

    JVM栈内存溢出

    public static void testStackOutOfMemory(){ 
        while (true) {   
                Thread thread = new Thread(new Runnable() {   
                       public void run() { 
                              while(true){ 
                          } 
                       }   
                });   
                thread.start();   
         }   
    } 
    

    线程的创建会直接在JVM栈中创建,但是本例子中,没看到内存溢出,主机先挂了,不是JVM挂了,真的是主机挂了,无论在mac还是在windows,都挂了。

    温馨提示,这个真的会死机的。

    堆溢出

    public static void testOutOfHeapMemory(){ 
       List<StringBuffer> list = new ArrayList<StringBuffer>(); 
       while(true){ 
          StringBuffer B = new StringBuffer(); 
          for(int i = 0 ; i < 10000 ; i++){ 
             B.append(i); 
          } 
          list.add(B); 
       } 
    } 
    

    不断往堆中塞新增的StringBuffer对象,堆满了就直接溢出了。

    测试案例完整代码

    public class BlowUpJVM {
        //栈深度溢出
        public static void  testStackOverFlow(){ 
          	BlowUpJVM.testStackOverFlow(); 
    	} 
        
        //不能引起永久代溢出
        public static void testPergemOutOfMemory1(){ 
           //方法一失败 
            List<String> list = new ArrayList<String>(); 
           while(true){ 
              list.add(UUID.randomUUID().toString().intern()); 
           } 
        } 
        
        //永久代溢出
        public static void testPergemOutOfMemory2(){ 
           try { 
              while (true) { 
                 Enhancer enhancer = new Enhancer(); 
                 enhancer.setSuperclass(OOM.class); 
                 enhancer.setUseCache(false); 
                 enhancer.setCallback(new MethodInterceptor() { 
                    @Override 
                    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
                       return proxy.invokeSuper(obj, args); 
                    } 
                 }); 
                 enhancer.create(); 
              } 
           } 
           catch (Exception e){ 
              e.printStackTrace(); 
           } 
        } 
        
        //不会引起永久代溢出
        public static void testPergemOutOfMemory3(){ 
           while(true){ 
           final OOM oom = new OOM(); 
           Proxy.newProxyInstance(oom.getClass().getClassLoader(), oom.getClass().getInterfaces(), new InvocationHandler() { 
                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                    Object result = method.invoke(oom, args); 
                    return result; 
                 } 
              }); 
           } 
        } 
        
        //本地方法栈溢出
        public static void testNativeMethodOutOfMemory(){ 
           int j = 0; 
           while(true){ 
              Printer.println(j++); 
              ExecutorService executors = Executors.newFixedThreadPool(50); 
              int i=0; 
              while(i++<10){ 
                 executors.submit(new Runnable() { 
                    public void run() { 
                    } 
                 }); 
              } 
           } 
        } 
        
        //JVM内存溢出
        public static void testStackOutOfMemory(){ 
            while (true) {   
                    Thread thread = new Thread(new Runnable() {   
                           public void run() { 
                                  while(true){ 
                              } 
                           }   
                    });   
                    thread.start();   
             }   
        } 
        
        //堆溢出
        public static void testOutOfHeapMemory(){ 
           List<StringBuffer> list = new ArrayList<StringBuffer>(); 
           while(true){ 
              StringBuffer B = new StringBuffer(); 
              for(int i = 0 ; i < 10000 ; i++){ 
                 B.append(i); 
              } 
              list.add(B); 
           } 
        } 
    } 
    

    写在最后

    如果你想进大厂,想升职加薪,或者对自己现有的工作比较迷茫,都可以私信我交流,希望我的一些经历能够帮助到大家~~

    推荐阅读:

    最后,附上并发编程需要掌握的核心技能知识图,祝大家在学习并发编程时,少走弯路。

    在这里插入图片描述

    好了,今天就到这儿吧,小伙伴们点赞、收藏、评论,一键三连走起呀,我是冰河,我们下期见~~

    展开全文
  • 大根与小根的理解,如何手写一个堆,以及什么时候用自己手写,什么时候用语言提供的api,(二者的区别) 定义 Heap是一种数据结构具有以下的特点: 1)完全二叉树; 2)heap中存储的值是偏序; Min-heap: ...

    大根堆与小根堆的理解,如何手写一个堆,以及什么时候用自己手写的堆,什么时候用语言提供堆的api,(二者的区别)

    定义

    Heap是一种数据结构具有以下的特点:
    1)完全二叉树;
    2)heap中存储的值是偏序;

    Min-heap: 父节点的值小于或等于子节点的值;
    Max-heap: 父节点的值大于或等于子节点的值;
    用通俗语言来说,大根堆就是每个最大的数字在每个子树的最上方,及大根堆pop值为最大值,小根堆反之
    在这里插入图片描述

    堆的存储

    堆的存储一般由数组表示,由于堆的实质就是完全二叉树,所以对于每个i来说(从0开始),左右孩子分别为2i+1,2i+2,父节点为(i-1)/2,
    在这里插入图片描述

    堆的核心操作(手写与语言api均有)

    heapinsert与heapify
    1.heapinsert:加入一个节点,通过上升的方式,依次进行比较,(上升操作),时间复杂度为o(logN)因为树的深度为logN
    在这里插入图片描述
    swap为交换操作

    private void heapInsert(int[] arr, int index) {
    			while (arr[index] > arr[(index - 1) / 2]) {
    				swap(arr, index, (index - 1) / 2);
    				index = (index - 1) / 2;
    			}
    		}
    

    2.heapify:弹出根结点之后的,将剩余变成堆的操作(下沉操作),因为弹出根结点后,会将数组最后面的数字顶替为根结点,所以只需将该结点进行下沉操作即可,时间复杂度为o(logN)树的深度为logN
    在这里插入图片描述
    swap为交换操作

    /**
    		 * 
    		 * @param arr 数组
    		 * @param index 索引
    		 * @param heapSize 堆大小
    		 */
    		private void heapify(int[] arr, int index, int heapSize) {
    			int left = index * 2 + 1;
    			while (left < heapSize) {
    				int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
    				largest = arr[largest] > arr[index] ? largest : index;
    				if (largest == index) {
    					break;
    				}
    				swap(arr, largest, index);
    				index = largest;
    				left = index * 2 + 1;
    			}
    		}
    

    堆排序

    首先堆排序分为2部分
    1.将一个无序数组变成堆
    2.将堆进行排序核心操作(heapfiy,因为如果是大根堆的话,最大值在上方一直,heapfiy即可+swap(交换)即可)

    首先分析第一个部分
    通常有2中方法
    1.最常用的一种是将数组依次遍历,最后一次加入堆中,便可将数组变成堆,但是此种方法的因为将数组中所以数进行遍历 (N),将每个数进行heapinsert(logN),所以时间复杂度为O(N*logN)

    // O(N*logN)
    		for (int i = 0; i < arr.length; i++) { // O(N)
    			heapInsert(arr, i); // O(logN)
    		}
    

    2.对此有一种优化方法,从数组尾部开始遍历,然后进行下沉,由于是从尾部,那边可以得到下沉数字一定为有限常数

    可以尝试这么理解,刚开始从尾部遍历,那么底部只有一层嘛,这时候heapify就为下沉0,倒数第二层时候,heapify为下沉1层,倒数第三层,heapify为下沉2层,有限个数时间复杂度为o(1)
    那么总体便为o(N*1)=O(N)

    for (int i = arr.length - 1; i >= 0; i--) {
    			heapify(arr, i, arr.length);
    		}
    

    然后分析第二个部分
    变成堆之后,例如大根堆,最大是数字是根结点,那么将最大的数字为尾部交换,然后将–heapsize,然后循环依次swap,heapify就ok了
    这个方法的时间复杂度为o(n*logN)从顶部开始下沉,heapify是logN哈

    详细代码如下

    // 堆排序额外空间复杂度O(1)
    	public static void heapSort(int[] arr) {
    		if (arr == null || arr.length < 2) {
    			return;
    		}
    		// O(N*logN)
    //		for (int i = 0; i < arr.length; i++) { // O(N)
    //			heapInsert(arr, i); // O(logN)
    //		}
    		//O(N)
    		for (int i = arr.length - 1; i >= 0; i--) {
    			heapify(arr, i, arr.length);
    		}
    		int heapSize = arr.length;
    		swap(arr, 0, --heapSize);
    		// O(N*logN)
    		while (heapSize > 0) { // O(N)
    			heapify(arr, 0, heapSize); // O(logN)
    			swap(arr, 0, --heapSize); // O(1)
    		}
    	}
    

    什么时候使用语言自带api,什么时候使用自己的手写api

    首先我们需要明确一点,我们需要重写编写一个类代替原有api,肯定当前api无法满足我们的情况,我们来重写api达到我们的效果

    我们现在来看一种效果,我们现在不是int类型,是一个引用类型例如Teacher(假设包含id,name),我们通过比较器(后续博客会有一篇详细结束比较器的,会更新的,嘿嘿)
    对其进行id比较,变成堆之后,(切记是以及变成堆之后)我们对其中某一个Teacher进行操作,将他的id变化,那么这个时候整个堆会发生巨大变化(变成不是堆结构),而这不是用户本意,用户只是想修改某一个teacher的信息,然后依然希望这个list是堆,换句话说,修改之后依然希望类自己进行维护,修改之后的结构自己进行复原变成堆

    所以这个时候,语言自带的api无法完成这个操作(java,python没有,就算某些语言有,也是进行整体heapinsert,时间复杂度太高不适应)这个时候我们便需要自己首先一个api,来完成此操作

    手写解决上述问题优化的堆

    核心思想便是使用HashMap<T, Integer> indexMap;对修改位置的索引进行记录,在push的时候将指针(地址)与索引进行记录在pop的时候进行删除,

    核心在于regsion
    通过值可以得到索引,然后对索引依次进行heapify与heapinsert巧妙在于因为堆的特性要么上升要么下沉,时间复杂度与o(logN)

    public static class MyHeap<T> {
    		private ArrayList<T> heap;
    		private HashMap<T, Integer> indexMap;
    		private int heapSize;
    		private Comparator<? super T> comparator;
    
    		public MyHeap(Comparator<? super T> com) {
    			heap = new ArrayList<>();
    			indexMap = new HashMap<>();
    			heapSize = 0;
    			comparator = com;
    		}
    		public boolean isEmpty() {
    			return heapSize == 0;
    		}
    		public int size() {
    			return heapSize;
    		}
    		public boolean contains(T key) {
    			return indexMap.containsKey(key);
    		}
    
    		public void push(T value) {
    			heap.add(value);
    			indexMap.put(value, heapSize);
    			heapInsert(heapSize++);
    		}
    
    		public T pop() {
    			T ans = heap.get(0);
    			int end = heapSize - 1;
    			swap(0, end);
    			heap.remove(end);
    			indexMap.remove(ans);
    			heapify(0, --heapSize);
    			return ans;
    		}
    		public void resign(T value) {
    			int valueIndex = indexMap.get(value);
    			heapInsert(valueIndex);
    			heapify(valueIndex, heapSize);
    		}
    		private void heapInsert(int index) {
    			while (comparator.compare(heap.get(index), heap.get((index - 1) / 2)) < 0) {
    				swap(index, (index - 1) / 2);
    				index = (index - 1) / 2;
    			}
    		}
    		private void heapify(int index, int heapSize) {
    			int left = index * 2 + 1;
    			while (left < heapSize) {
    				int largest = left + 1 < heapSize && (comparator.compare(heap.get(left + 1), heap.get(left)) < 0)
    						? left + 1
    						: left;
    				largest = comparator.compare(heap.get(largest), heap.get(index)) < 0 ? largest : index;
    				if (largest == index) {
    					break;
    				}
    				swap(largest, index);
    				index = largest;
    				left = index * 2 + 1;
    			}
    		}
    		private void swap(int i, int j) {
    			T o1 = heap.get(i);
    			T o2 = heap.get(j);
    			heap.set(i, o2);
    			heap.set(j, o1);
    			indexMap.put(o1, j);
    			indexMap.put(o2, i);
    		}
    	}
    

    结语

    第一次写博客,搞了一晚上,肯定写的不好,希望大家不吝赐教,也希望能帮助到大家,也为自己总结使用,如果有不对的地方,欢迎大家指正

    展开全文
  • 1. 手写一个单例模式 2. 手写一个工厂模式 2. 手写一个生产者消费者模式 3. 手写一个LRU算法的实现; 4. 手写快排 5. 手写堆排 6. 手写树的遍历(先序、中序、后序、层序) 7. 手写一个二分查找 ...
  • 面试常考手写代码学习技巧总结

    千次阅读 2020-02-06 20:39:00
    有些小伙伴面试之前准备了,但是在编写的时候还是会忘掉,本文总结了一个如何应对手写代码的大纲,前面是一些基础内容,但是也希望能帮助到你,都会就当复习一遍,嘿嘿。 1. 起名字与具体功能考虑 起名字 手写...
  • HeapSort /** ... * @description: 手写堆排序 * @author: yanghaoran * @create: 2019-05-27 20:35 **/ public class HeapSort { static int num = 0; public static void main(String[]...
  • 面试手写代码题目

    千次阅读 2016-09-21 13:13:11
    排序 private static void swap ( int a[], int x, int y) { int tmp = a[x]; a[x] = a[y]; a[y] = tmp; } private static void sift ( int a[], int root, int hight) { ...
  • Top K问题是面试时手写代码的常考题,某些场景下的解法与排和快排的关系紧密,所以把它放在排后面讲。关于Top K问题最全的分类总结是在这里(包括海量数据的处理),个人将这些题分成了两类:类是容易写代码...
  • 手写代码 (总结)

    千次阅读 2013-10-25 10:36:29
    首先总结问题,我把敬礼过多的放到编写代码的规范上了。舍本逐末,忘记了正确性。 后面编写代码,首先看功能,随后找测试样例,随后找边界条件。随后编写完毕代码之后可以测试一下再提交的。 所有我所说的东西,...
  • 硬核!手写一个优先队列

    千次阅读 2020-10-22 09:25:59
    前言 事情还要从一个故事讲起: 对于上面那只可爱的小狗狗不会,本篇即为该教程,首先,...通常是一个可以被看做一棵树(完全)的数组对象。且总是满足以下规则: 总是一棵完全二叉树 每个节点总是大于(或小于)
  • 手写代码模块(Java实现)——排序 代码呈现为函数封装形式, 接口统一为数组int [] array 1.冒泡排序 public static void BubbleSort(int [] a){ int i, j; int n = a.length; for(i=0; i&...
  • 只要看过小根,这个代码并不难,但有细节需要处理 我是手写堆,但用priority_queue更简单 #include<bits/stdc++.h> using namespace std; const int maxn=1000; int f[maxn][maxn]; int vis[maxn]; int d...
  • 手写堆(heap)

    千次阅读 2018-07-20 15:48:03
    手写堆(优先队列)
  • full gc并且相关内存能回收并且一个参数disable gc。 unsafe完全自行管理   gc影响代码执行多久(普通gc影响不大,full gc1秒以上) 重构从哪些方面(根据简历,复用和代码减半,无效代码。重复代码-...
  • 最近在用extjs做项目,习惯了强大vs那种拖拽控件的界面...下载了Ext desgner研究了一天,最后发现还不如手写代码,真是一个鸡肋工具。一个简单的表单中最基本的组成控件在extjs中都那么难搞,代码要写一大看的眼都快
  • 实现了优先队列的添加与删除方法 ...代码实现 package basicKnowledge.集合框架.priorQueue; import basicKnowledge.集合框架.queue.MyListQueue; import com.sun.xml.internal.bind.v2.schemagen.x...
  • 手写一个Pcap捕包工具及性能优化

    千次阅读 2017-05-28 08:07:49
    因为项目的缘故,需要实现pcap捕包的功能,在使用后发现libpcap自身API使用比较复杂,就手写一个API并尝试进行性能优化。部分代码在githuab上。pcapDumperpcap文件格式一个pcap文件的结构如下: (图片来自博客)...
  • 手写最大(Java实现)

    千次阅读 2017-10-09 21:23:51
    最大:根结点的键值是所有结点键值中最大者,且每结点的值都比其孩子的值大。 最小:根结点的键值是所有结点键值中最小者,且每结点的值都比其孩子的值小。最大的父元素与子元素的索引有如下关系在最...
  • 【排序算法】— 手写堆排序

    千次阅读 2020-10-12 11:04:15
    在个人的专栏中,其他排序陆陆续续都已经写了,而排序迟迟没有写,趁着国庆假期的尾声,把排序也写写。 插入类排序—(折半)插入排序、希尔排序 交换类排序—冒泡排序、快速排序手撕图解 归并类排序—归并排序...
  • 在我早期的篇博文Java反射机制的原理和用途中,文末我写到过:"如果你不做框架的话,基本上是用不到反射机制的,我们大多时候是使用框架的一方,而反射机制都已经在底层实现过了,因此,我们不必担心,我们会写...
  • 1、将整数逆序后放入数组中(要求递归实现) void convert(int *result, int n) { if(n>=10) convert(result+1, n/10); *result = n%10; } int m
  • 手把手,74行代码实现手写数字识别

    万次阅读 2016-01-04 14:05:47
    手把手,74行代码实现手写...“机 器学习”是一个很实践的过程。就像刚开始学游泳,你在只在岸上比划一规定动作还不如先跳到水里熟悉水性学习来得快。以我们学习“机器学习”的经验来看, 很多高大上的概念刚开始不懂
  • 作者: 龙心尘&&寒小阳 时间:2015年12月。...1、 引言:不要站在岸上学游泳“机器学习”是一个很实践的过程。就像刚开始学游泳,你在只在岸上比划一规定动作还不如先跳到水里熟悉水性学习来得快。以我们学习“机
  • C++手写堆的实现(LuoguP3378模板)

    千次阅读 2017-07-19 18:36:34
    大根有两性质: 1.根节点点权为所有节点点权中的最大值; 2.任意节点的点权都大于它的子节点. 同样地,小根也具有两性质,并且与大根相反: 1.根节点点权为所有点权中的最小值; 2.任意节点的点权都...
  • 【面试题】--手写堆排序

    千次阅读 2020-06-25 09:38:20
    毕竟面试这么一个水题写半个小时也不太好吧。 实现中遇到的困难: 数组下标必须要从0开始 0 对应左右节点:(1,2) 如果从1 开始 对应:(3,4), 2对应(5,6)那么1 2 节点之间就没有联系了,不太好。数组下标必须...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,533
精华内容 9,413
关键字:

手写代码一个堆