kesonyk的专栏

插入排序是一个简单的原址排序，对于少量的元素，这是一个有效的算法。也常用来对快排做元素较少时的优化选择。            伪代码描述：            INSERTION-SORT(A)            for j=2 to A.length                   key=A[j]                   i=j-1;

#include #include using namespace std;templateclass linkList{private: struct Node { Object data; Node *next; Node(const Object &d=Object{ },Node *n=nullptr) :data(d),next(n) { }

#include #include #include #include using namespace std;templateclass minKList{public: explicit minKList(int capacity=100) :array(capacity+1),currentSize(0) { } explicit minKList(const

利用快排的partition，在线性时间内，选择出第i大的数templateint qPartition(vector &vec,int p,int r){ uniform_int_distribution u(p,r); default_random_engine e(32676); int pos=u(e); std::swap(vec[pos],vec[r]); int key

#include #include #include #include using namespace std; template class HashTable{public: explicit HashTable(int size=101) :theSize(nextPrime(size)),array(nextPrime(size)) { makeEmpt

#include #include #include #include #include using namespace std;int levenShtein(string s1,string s2){ int cel=s1.size(); int row=s2.size(); if(cel==0) return row; if(row==0) return

#include #include #include #include #include using namespace std; vector> lcsLen(const string &s1,const string &s2){ int m=s1.size(); int n=s2.size(); vector> C(m+1,vector(n+1)); for(int

#include #include #include #include #include using namespace std;int memoryCutAux(vector &p,int n,vector &r){ int q; if(r[n]>=0) return r[n]; if(n==0) q=0; else { q=INT_MIN; fo

#include #include #include #include #include using namespace std;enum{WHITE,GRAY,BLACK};struct Vertex{ int color; int d; int pre; Vertex() :pre(-1),color(WHITE),d(INT_MAX) { }};cla

Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. Fo

描述You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return

主要是在辅助的栈中push当前最小的值，若data栈pop出的数不是当前最小的，则辅助栈不动；若data栈pop出当前最小的值，则辅助栈也pop#include #include using namespace std;templateclass minStack{public: void push(object val) { data.push_back(val);

#include struct BinaryBode{ int val; BinaryBode *left; BinaryBode *right; BinaryBode(int v=0,BinaryBode *lt=nullptr,BinaryBode *rt=nullptr) :val(v),left(lt),right(rt) { }};//创建时传递的一定是指针引用，

class Solution {public: bool isPalindrome1(int x) { if(x<0) return false; vector vec; while(x) { vec.push_back(x%10); x=x/10;

#include #include #include using namespace std; tuple maxCrossSubarray(vector &vec,int low,int mid,int high){ int leftSum=-1000000; int sum=0; int leftBoard=mid; for(int i=mid;i>=low;--i){

利用二分查找的复杂度为logN,所以查找对象为binarySearch(vec,vec[i])做一个循环即可bool findSum(const vector &vec,vector &result,int v){ vector vec2(vec); sort(vec2.begin(),vec2.end()); int idx; int i; int flag=0; fo

下标 j 指出正被插入到手中的“当前牌”，在for 循环的每次迭代的开始，包含元素1—j-1 的子数组构成了当前排序好的牌，j+1—n为仍在桌上的牌。该排序主要的思想是将排序好的每个逆序与当前要排序的进行相比，若大于则向前移一位。。。#include #include using namespace std;void insertSort(vector &vec)

#include #include #include using namespace std;void Merge(vector &vec,size_t p,size_t q,size_t r){ auto n1=q-p+1; auto n2=r-q; vector lhs(n1+1); vector rhs(n2+1); for(int i=0;i<n1;++i)

#include #include #include #include using namespace std;int n1,n2,n3;int vv1,vv2,w1,w2,w3;vector v1{0,0,0};vector v2{0,0,0};bool equal(vector &vec1,vector &vec2)

#include #include#include #include #include #include using namespace std;templateclass hashTable{public: explicit hashTable(int size = 101) :currentSize(0), tableSize(size

主要步骤是在对子序列S1,S2进行归并时，若S1[i]>S2[j],则逆序数加上 s1.length-i#include #include using namespace std;void Merge(vector &vec,size_t p,size_t q,size_t r,int &sum){ auto n1=q-p+1; auto n2=r-q; vector lh

#include #include templateclass RBTree{private: struct RBNode { RBNode *parent; RBNode *left; RBNode *right; Comparable key; int color; RBNode(RBNode *p = nullptr, RBNode *lt = n

#include #include #include using namespace std;void countSort(vector &vec,vector &vecSort,int k){ vector c(k+1); int i; //make c[i] contain the number of elements equal to i for(i=0;i<vec.

#include #include class UnderflowException { };using namespace std;templateclass stack{public: stack(int capacity=100) :array(capacity),top(-1) { } stack(vector &vec) :capacity(100),top

#include #include #include using namespace std;class UnderflowException { };templateclass queue{public: queue(int capacity=100) :array(capacity),head(0),tail(0),currSize(0) { } queue(ve

#include #include class UnderflowException { };using namespace std;templateclass minHeap{public: explicit minHeap(int capacity=100) :array(capacity+1),currentSize(0) {} explicit minHeap

归并排序算法分析及优化归并算法采用了分治法的思想：将原问题分解为几个规模较小但类似于原问题的字问题，递归地求解这些字问题，然后再合并这些字问题的解来建立原问题的解。归并排序算法完全采用分治模式，操作如下： （1）分解：分解带排序的n个元素的序列形成各具n/2个元素的两个子序列       （2）解决：使用归并排序递归地排序两个子序列       （3）合并：合并两个已排序的子序

#include #include using namespace std;class UnderflowException { };templateclass BinaryHeap{public: explicit BinaryHeap(int capacity=100) :array(capacity+1),currentSize(0) { } explicit

#include #include #include using namespace std;//当元素少的时候可以采用插入排序void insertSort(vector &vec,int left,int right){ int i; for(int j=left+1;j<=right;++j) { int key=vec[j]; for(i=j-1;i>=lef

维护堆的性质MAX-HEAPIFY是用于维护最大堆性质的重要过程。输入为待维护的数组，与待维护的节点i。时间复杂度为O(lgn)，即树的高度hMAX_HEAPIFY(A,i) l=LEFT(i) r=RIGHT(i) if l<=A.heapSize and A[l]>A[i] largest=l else largest=i if r<=A.