数组

1.顺时针打印数组 

　　eg： 1 2 3

　　　　  4 5 6

　　　　  7 8 9　　打印出来，结果为1 2 3 6 9 8 7 4 5

　　解： 注意 * * (只有一行) 只有一列，行列不同等情况。

package offer;

/**
 * 剑指offer p127 20题
 * @author hasee
 *
 */
public class PrintArr {
    public static void print(int[][] arr){
        if(arr == null)
            return;
        int width = arr[0].length,high = arr.length;
        int x=0,y=0;
        while (width>0 && high>0) {
            for (int i = 0; i < width; i++) 
                System.out.print(arr[x][y+i]+" ");
            for (int i = 1; i < high; i++) 
                System.out.print(arr[x+i][y+width-1]+" ");
            //错误！ for循环前必须加上if判断
            //当只有一行时，这里不该打印，因为width和行无关
            if(high>1) for (int i = width-2; i >= 0; i--) 
                System.out.print(arr[x+high-1][y+i]+" ");
            //当只有一列时，这里不该打印，因为high和列无关
            if(width>1) for (int i = high-2; i >= 1; i--) 
                System.out.print(arr[x+i][y]+" ");
            System.out.println();
            x++;
            y++;
            width-=2;
            high-=2;
        }
    }
    public static void main(String[] args) {
        int[][] arr = new int[1][1];
        for (int i = 1; i <= arr.length; i++) {
            for (int j = 1; j <= arr[0].length; j++) {
                arr[i-1][j-1] = (i-1)*arr[0].length+j;
            }
        }
        print(arr);
    }
}

 2.数轴上从左到右有n各点a[0], a[1], ……,a[n -1]，给定一根长度为L的绳子，求绳子最多能覆盖其中的几个点

package number;

/**
 * 数轴上从左到右有n各点a[0], a[1], ……,a[n -1]，给定一根长度为L的绳子，求绳子最多能覆盖其中的几个点。
 * @author hasee
 *
 */
public class MaxTimesOfL {
    public static void main(String[] args) {
        int[] arr = {-1, 0, 3, 9, 11, 13, 14, 25};//数轴上的点  
        System.out.println(mostCover(arr,5));
    }
    /**
     * 两个指针，一个front，一个rear，每次front-rear，比L小，看覆盖的点数。
     * 保存覆盖点数的最大值，然后front++；比L大，rear++，每个数最多遍历2遍，复杂度O(N)。
     * 对于这个算法，他给了一个形象的比喻：
     * 就好像一条长度为L的蛇。头伸不过去的话，就把尾巴缩过来最多只需要走一次，就知道能覆盖几个点
     * 参考自：http://blog.csdn.net/thebestdavid/article/details/12236687
     * @param arr
     * @param n
     * @return
     */
    public static int mostCover(int[] arr,int n){
        if (arr == null) 
            return -1;
        //两个指针，指向头节点和尾节点，动态判断是否超过n来计算包含的点个数
        //有点类似快速排序的双指针向前走
        int head=0,rear=0; 
        int max=0;
        while (rear<arr.length) {
            if (arr[rear]-arr[head] > n) {
                //此处错误，先前是rear-head+1，因为已经大于n了 所以不应该加一
                max = max<rear-head ? rear-head : max;
                head++;
            }else
                rear++;
        }
        return max;
    } 
    
}

 3.给定一个有序数组a，长度为len，和一个数X，判断A数组里面是否存在两个数，他们的和为X，bool judge(int *a, int len, int x)，存在返回true，不存在返回false

package nothing;

/**
 * 给定一个有序数组a，长度为len，和一个数X，判断A数组里面是否存在两个数，
 * 他们的和为X，bool judge(int *a, int len, int x)，存在返回true，不存在返回false
 * @author hasee
 *
 */
public class Manacher {
    public static void main(String[] args) {
        int[] arr = {1,4,6,7,9,11,15};
        System.out.println(isHaveSum(arr,6));
    }

    private static boolean isHaveSum(int[] arr, int sum) {
        if(arr == null)
            return false;
        int head=0,tail=arr.length-1; //喜闻乐见的双指针，头尾，有点像二分查找
        while(head<tail){
            if(arr[head]+arr[tail]<sum)
                head++;
            else if(arr[head]+arr[tail]>sum)
                tail--;
            else
                return true;
        }
        return false;
    }
    
}

 4.发帖水王变体

　　随着Tango的发展，管理员发现，“超级水王”没有了。统计结果表明，有3个发帖很多的ID，他们的发帖数目都超过了帖子总数目N的1/4。你能从发帖ID列表中快速找出他们的ID吗？

参见：http://blog.csdn.net/whz_zb/article/details/7436045

　　分析：在这个题目中，有一个计算机科学中很普遍的思想，就是如何把一个问题转化为规模较小的若干个问题。分治、递推和贪心等都有这样的思想。在转化过程中，如果能保证小的问题跟原问题的解是一致的就成功了。这样，我们可以通过寻找这样的方式将小问题转化为更小的问题。如何将大问题拆成小问题，或者如何大规模的数据降成小规模，而不影响解呢？

　　题思路：其实想想，不同于三个数的剩下的数只占总数的1/4不到。。所以直接用3个数记录，不同于这3个数就集体都减一，最后留下的肯定是这3个数。