算法入门-数组

在行列都排好序的矩阵中找数

package niuke.class01;

/**
 * 在行列都排好序的矩阵中找数
 * 【题目】 给定一个有N*M的整型矩阵matrix和一个整数K，matrix的每一行和每一 列都是排好序的。
 * 实现一个函数，判断K是否在matrix中。
 *	例如: 0   1   2   5 
 *  	2   3   4   7 
 *  	4	4   4   8 
 *  	5   7   7   9 
 *  如果K为7，返回true；如果K为6，返回false。
 * 【要求】 时间复杂度为O(N+M)，额外空间复杂度为O(1)。
 * @author Administrator
 *
 */
public class Code08_FindNumInSotredMatrix {
	
	public static boolean isInSortedMatrix(int[][] matrix, int num) {
		int row = 0;
		int col = matrix[0].length - 1;
		
		while(row < matrix.length && col > -1) {
			if(matrix[row][col] == num) {
				return true;
			} else if(matrix[row][col] < num) {
				row++;
			} else {
				col--;
			}
		}
		
		return false;
	}
	
	public static void main(String[] args) {
		int[][] matrix = new int[][] { { 0, 1, 2, 3, 4, 5, 6 },// 0
				{ 10, 12, 13, 15, 16, 17, 18 },// 1
				{ 23, 24, 25, 26, 27, 28, 29 },// 2
				{ 44, 45, 46, 47, 48, 49, 50 },// 3
				{ 65, 66, 67, 68, 69, 70, 71 },// 4
				{ 96, 97, 98, 99, 100, 111, 122 },// 5
				{ 166, 176, 186, 187, 190, 195, 200 },// 6
				{ 233, 243, 321, 341, 356, 370, 380 } // 7
		};
		int K = 233;
		System.out.println(isInSortedMatrix(matrix, K));
	}
}

小和问题

/**
 * 小和问题  
 * 在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组的小和。
 * 在归并排序基础上改进，化为求右边有多少个数比左边的大
 * @author Administrator
 *
 */
public class Code02_SmallSum {
	
	public static int smallSum(int[] arr){
		if(arr == null || arr.length < 2)
			return 0;
		return mergeSort(arr, 0, arr.length - 1);
	}
	
	public static int mergeSort(int[] arr, int left, int right){
		if(left == right)
			return 0;
		int mid = left + ((right - left >> 1));
		return mergeSort(arr, left, mid) + 
				mergeSort(arr, mid + 1, right) + 
				merge(arr, left, mid, right);
	}
	
	public static int merge(int[] arr, int left, int mid, int right){
		int sum = 0;
		int[] help = new int[right - left + 1];
		int i = 0;
		int p1 = left;
		int p2 = mid + 1;
		
		while(p1 <= mid && p2 <= right){
			sum += arr[p1] < arr[p2] ? arr[p1] * (right - p2 + 1) : 0;
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		
		while(p1 <= mid){
			help[i++] = arr[p1++];
		}
		
		while(p2 <= right){
			help[i++] = arr[p2++];
		}
		
		for(i = 0; i < help.length; i++){
			arr[left + i] = help[i];
		}
		
		return sum;
	}
	
	public static void main(String[] args) {
		int[] arr = {1,3,4,2,5};
		int sum = smallSum(arr);
		System.out.println(sum);
	}
	
}

运行结果：16

转圈打印矩阵

/**
 * 转圈打印矩阵
 * 【题目】 给定一个整型矩阵matrix，请按照转圈的方式打印它。
 * 例如：
 * 1   2   3   4 
 * 5   6   7   8 
 * 9  10  11  12 
 * 13 14  15  16 
 * 打印结果为：1，2，3，4，8，12，16，15，14，13，9，5，6，7，11， 10
 * 【要求】 额外空间复杂度为O(1)。
 * @author Administrator
 *
 */
public class Code04_PrintMatrix {
	
	public static void spiralOrderPrint(int[][] matrix) {
		int tR = 0;
		int tC = 0;
		int dR = matrix.length - 1;
		int dC = matrix[0].length - 1;
		while(tR <= dR && tC <= dC){
			printEdge(matrix, tR++, tC++, dR--, dC--);
		}
	}
	
	public static void printEdge(int[][] m, int tR, int tC, int dR, int dC){
		if(tR == dR) {
			for(int i = tC; i <= dC; i++) {
				System.out.print(m[tR][i] + " ");
			}
		} else if(tC == dC) {
			for(int i = tR; i <= dR; i++) {
				System.out.print(m[i][tC] + " ");
			}
		} else {
			int curR = tR;
			int curC = tC;
			while(curC != dC) {
				System.out.print(m[curR][curC] + " ");
				curC++;
			}
			while(curR != dR) {
				System.out.print(m[curR][curC] + " ");
				curR++;
			}
			while(curC != tC) {
				System.out.print(m[curR][curC] + " ");
				curC--;
			}
			while(curR != tR) {
				System.out.print(m[curR][curC] + " ");
				curR--;
			}
		}
	}
	
	public static void main(String[] args) {
		int[][] matrix = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16}};
		spiralOrderPrint(matrix);
	}
}

旋转正方形矩阵

/**
 * 旋转正方形矩阵
 * 【题目】 给定一个整型正方形矩阵matrix，请把该矩阵调整成顺时针旋转90度的样子。
 * 【要求】 额外空间复杂度为O(1)。
 * 1  2  3  4 
 * 5  6  7  8 
 * 9  10 11 12
 * 13 14 15 16 
 * 
 * 13 9  5 1 
 * 14 10 6 2 
 * 15 11 7 3 
 * 16 12 8 4 
 * @author Administrator
 *
 */
public class Code05_RotateMatrix {

	public static void rotateMatrix(int[][] matrix) {
		int tR = 0;
		int tC = 0;
		int dR = matrix.length -1 ;
		int dC = matrix[0].length - 1;
		while(tR <= dR && tC <= dC) {
			rotateEdge(matrix, tR++, tC++, dR--, dC--);
		}
	}
	
	public static void rotateEdge(int[][] m, int tR, int tC, int dR, int dC) {
		int times = dC - tC;
		int tmp = 0;
		for(int i = 0; i != times; i++) {
			tmp = m[tR][tC + i];
			m[tR][tC + i] = m[dR - i][tC];
			m[dR - i][tC] = m[dR][dC - i];
			m[dR][dC - i] = m[tR + i][dC];
			m[tR + i][dC] = tmp;
		}
	}
	
	public static void printMatrix(int[][] m) {
		for (int i = 0; i < m.length; i++) {
			for (int j = 0; j < m[0].length; j++) {
				System.out.print(m[i][j] + " ");
			}
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		int[][] matrix = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16}};
		printMatrix(matrix);
		rotateMatrix(matrix);
		printMatrix(matrix);
	}

}