求职系列笔记（1）---数据结构和算法

数组涉及到的算法相当多，主要分为：排序算法、查找算法等。
(a)二分查找主要有两种，一种是基于除法的，一种基于加减的（也叫：斐波那契查找法、黄金查找法）

/*二分查找的算法如下(1)：*/
    int binarySearch(int arr[],int n,int value)//查找区间为[0,n-1]
    {
        int low=0;
        int high=n-1;
        while(low<=high)//这个条件很讲究
        {
            int mid=low+(high-low)>>1;
            if(arr[mid]<value) low=mid+1;
            else if(arr[mid]>value) high=mid-1;
            else return mid;//这个很有讲究，如果放到最后，可以节省很多时间;
        }
        return -1;//说明没有查找到
    }
    /*二分查找的算法如下(2)：*/
    int binarySearch(int arr[],int n,int value)//查找区间为[0,n-1]
    {
        int low=0;
        int high=n-1;
        while(low<high)//这个条件很讲究
        {
            int mid=low+(high-low)>>1;
            if(arr[mid]<value) low=mid;
            else if(arr[mid]>value) high=mid;
            else return mid;//这个很有讲究，如果放到最后，可以节省很多时间;
        }
        return -1;//说明没有查找到
    }

/排序算法，主要掌握快排、归并排序、堆排序； 至于其他的冒泡、选择、插入、桶排序等很容易掌握;/

/*快排算法，主要基于递归和快速划分函数partition*/
    int partition(int arr[],int low,int high)//划分区间为[low,high]
    {
        int temp=arr[low];//找到一个基准点
        while(low<high)
        {
            while((low<high)&&(arr[high]>temp)) high--;
            swap(arr[low],arr[high]);
            while((low<high)&&(arr[low]<=temp)) low++;          
            swap(arr[low],arr[high]); 
        }
        return low;
    }
    void quicksort(int arr[],int low,int high)//n为数组长度
    {
        if(low>=high) return;//条件改为if(low>=high)也可以,因为指向同一个元素，可以不划分；
        int provit=partition(arr,low,high);
        quicksort(arr,low,provit-1);
        quicksort(arr,provit+1,high);
    }

//思考，快排时间复杂度为o(n*logn),最差情况下为：o(N^2)

本文继续探讨partition函数的其他应用，这是一种思想，特别重要；
基于快速排序partition思想的算法拓展
(1)输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，
所有偶数位于数组的后半部分。要求时间复杂度为O(n)。
(2)荷兰国旗问题：这个问题类似快排中partition过程，
只是需要用到三个指针：一个前指针begin，一个中指针current，一个后指针end，
current指针遍历整个数组序列，当
(a)current指针所指元素为0时，与begin指针所指的元素交换，而后current++，begin++;
(b)current指针所指元素为1时，不做任何交换（即球不动），而后current++;
(c)current指针所指元素为2时，与end指针所指的元素交换，而后，current指针不动，end–；

参考代码如下：
while( current<=end )        
{             
  if( array[current] ==0 )             
   {                 
      swap(array[current],array[begin]);                  
      current++;                  
      begin++;            
   }             
   else if( array[current] == 1 )            
   {                 
      current++;            
   }   
   else //When array[current] =2   
   {               
      swap(array[current],array[end]);                
      end--;            
   }      
}  

关于这部分，可以参考如下：
（1）奇偶调序 http://taop.marchtea.com/02.06.html
（2）荷兰国旗 http://taop.marchtea.com/02.07.html

继续学习其他排序算法，归并排序

/*二路归并排序，这个算法应用很广泛，也是稳定算法*/ 
    void mergearray(int a[],int temp[],int first,int mid,int last)//将有二个有序数列a[first...mid]和a[mid...last]合并。  
    {  
        int i=first, j=mid + 1;  
        int m=mid,n=last;  
        int k=0;  
        while(i<= m && j<= n)  
        {  
            if(a[i]<=a[j]) temp[k++]=a[i++];  
            else temp[k++]=a[j++];  
        }    
        while(i<=m) temp[k++]=a[i++];   
        while(j<=n) temp[k++]=a[j++];  
        for(i=0;i<k;i++)  
            a[first+i]=temp[i];  
    }  
    void Merge(int arr[],int copy[],int low,int high)//处理主体函数，递归实现划分、合并
    {
        if(low<high)  
        {  
            int mid=(low+high)>>1;  
            mergesort(arr,copy, low, mid);    //左边有序  
            mergesort(arr, copy,mid + 1,high); //右边有序  
            mergearray(arr,copy,low,mid,high); //再将二个有序数列合并  
        }  
    }
    void Mergesort(int arr[],,int low,int high)//调用接口函数;
    {
        int* copy=new int[];
        Merge(arr,copy,low,high);
    }

/*
思考，归并排序时间复杂度o(n*logn),稳定排序，消耗o(n)空间复杂度;
参考《剑指offer》中数组中的逆序对，也是采用归并排序的方法。
参考代码如下：

 class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size()<=1) return 0;
        int* copy=new int[data.size()];
        //初始化数组
        for(unsigned int i=0;i<data.size();i++)
            copy[i]=0;
        int count=InversePairCore(data,copy,0,data.size()-1);
        delete[] copy;
        return count;
    }
    int InversePairCore(vector<int>& data,int*& copy,int start,int end)
    {
        if(start==end)
        {
            copy[start]=data[start];
            return 0;
        }
        //将数组拆分成两部分
        int length=(end-start)/2;
        //分别计算左边部分和右边部分
        int left=InversePairCore(data,copy,start,start+length);
        int right=InversePairCore(data,copy,start+length+1,end);
        //进行逆序计算
        int i=start+length;
        int j=end;
        int index=end;
        int count=0;
        while(i>=start && j>=start+length+1)
        {
            if(data[i]>data[j])
            {
                copy[index--]=data[i--];
                //统计长度
                count+=j-start-length;
            }
            else
            {
                copy[index--]=data[j--];
            }
        }
        for(;i>=start;--i)
        {
            copy[index--]=data[i];
        }
        for(;j>=start+length+1;--j)
        {
            copy[index--]=data[j];
        }
        //排序
        for(int i=start; i<=end; i++) {
            data[i] = copy[i];
        }
        //返回最终的结果
        return (count+left+right);
    }
};

*/
数组在其他的应用，如用一个数组实现三个栈；
参考代码如下：

class stack3{
public:
    stack3(int size = 300){
        buf = new int[size*3];
        ptop[0]=ptop[1]=ptop[2]=-1;//三个栈底分别指向-1
        this->size = size;
    }
    ~stack3(){
        delete[] buf;
    }
    void push(int stackNum, int val)//stackNum为0,1,2分别代表栈
    {
        int idx = stackNum*size + ptop[stackNum] + 1;//求出栈的
        buf[idx] = val;
        ++ptop[stackNum];
    }
    void pop(int stackNum)//弹栈
    {
        --ptop[stackNum];
    }
    int top(int stackNum)//栈顶元素
    {
        int idx = stackNum*size + ptop[stackNum];
        return buf[idx];
    }
    bool empty(int stackNum)//判断栈空
    {
        return ptop[stackNum]==-1;
    }
private:
    int *buf;
    int ptop[3];
    int size;
};

数组的排序算法中，主要讲了快排、归并排序，这两个排序的思想应用广泛。至于其他排序，可以自行学习。
总结，数组是一种最常用的数据结构，在动态规划中、在回溯法中进行修枝中也起到很大重要。详见下一期内容；