剑指offer11-15

package com.zte.array;

/*
 * 剑指offer11-20
 * */
public class Main2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// System.out.println(pow(2.0, 2));
		// printOneToN(3);
//		NodeNode node1 = new NodeNode(1);
//		NodeNode node2 = new NodeNode(2);
//		NodeNode node3 = new NodeNode(3);
//		NodeNode node4 = new NodeNode(4);
//		LinkNode list = new LinkNode();
//		list.insert(node1);
//		list.insert(node2);
//		list.insert(node3);
//		list.insert(node4);
		// list.display();
		// System.out.println("-------------------");
		// list.del(node3);
		// list.display();
		// System.out.println("-------------------");
		// int[] arr = { 1, 3, 6, 7, 8, 3, 2, 4 };
		// reverseArray(arr);
		// System.out.println(reverseK(list, 2).data);
		// System.out.println(reverseK2(list, 2).data);
		// ppp(123);
		// System.out.println(pows(2));
		System.out.println(OX(12));
	}

	public static void ppp(int num) {
		String str = String.valueOf(num);
		int nummod = 0;
		int k = 0;
		for (int i = 0; i < str.length(); i++) {
			nummod = num % 10;
			System.out.println(nummod);
			num = num / 10;
			// System.out.println(num);
		}

	}

	/*
	 * 十六进制转十进制
	 * 
	 */
	public static int OX(int nums) {
		int sum = 0;
		String str = String.valueOf(nums);
		for (int i = 0; i < str.length(); i++) {
			int mod = nums % 10;
			int k = mod * pows(i);
			sum += k;
			nums = nums / 10;
		}
		return sum;

	}

	public static int pows(int n) {
		if (n == 0)
			return 1;
		else
			return pows(n - 1) * 16;

	}
	/*
	 * 
	 * 11.给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。不得使用库函数，不需要考虑大数问题
	 * 
	 * 思路：不能用==比较两个浮点数是否相等，因为有误差。考虑输入值的多种情况。
	 */

	public static double pow(double base, int exp) {
		if (exp == 0)
			return 1;
		else {
			return pow(base, exp - 1) * base;
		}
	}

	/*
	 * 12.打印1到最大的n位数
	 * 
	 */
	public static void printOneToN(int n) {
		String str = "";
		for (int i = 0; i < n; i++)
			str += 9;
		for (int j = 0; j < str.length() - 1; j++) {
			for (int i = 0; i < 10; i++) {
				for (int k = 0; k < 10; k++) {
					if (i != 0) {
						String numstr = i + str.substring(str.length() - j, str.length()) + k;
						System.out.println(numstr);
					} else {
						System.out.println(str.substring(str.length() - j, str.length()) + k);
					}

				}
			}
		}

	}

	/*
	 * 
	 * 14.输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，
	 * 偶数和偶数之间的相对位置不变
	 * 
	 * 思路：每次只和前面一个数交换位置。或者利用辅助数组
	 */

	public static void reverseArray(int[] arr) {
		int[] temparr = new int[arr.length];
		int j = 0;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] % 2 != 0)
				temparr[j++] = arr[i];
		}
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] % 2 == 0)
				temparr[j++] = arr[i];
		}
		for (int i = 0; i < temparr.length; i++) {
			System.out.print(temparr[i] + " ");

		}
	}

	/*
	 * 15.输入一个链表，输出该链表中倒数第k个结点。
	 * 
	 * 扩展题：找中间节点，使用两个指针，一个走一步，一个走两步。找到中间节点
	 * 
	 * 思路：定义一快一慢两个指针，快指针走K步，然后慢指针开始走，快指针到尾时，慢指针就找到了倒数第K个节点。
	 */

	public static NodeNode reverseK(LinkNode linklist, int k) {
		NodeNode right = linklist.root;
		NodeNode left = linklist.root;
		for (int i = 1; i < k; i++) {
			right = right.next;
		}
		while (right.next != null) {
			right = right.next;
			left = left.next;
		}
		return left;

	}

	public static NodeNode reverseK2(LinkNode linklist, int k) {
		int size = 0;
		NodeNode node = linklist.root;
		NodeNode node1 = linklist.root;
		NodeNode result = null;
		while (node != null) {
			size++;
			node = node.next;
		}
		for (int i = 0; i < size - k + 1; i++) {
			result = node1;
			node1 = node1.next;
		}
		return result;

	}

	/*
	 * 
	 * 16.输入一个链表，反转链表后，输出链表的所有元素。
	 * 
	 * 扩展题：输出反转后链表的头节点，定义三个指针反向输出。
	 * 
	 * 思路：定义两个指针，反向输出
	 */
	public NodeNode ReverseList(NodeNode head) {
		if (head == null) {
			return null;
		}
		NodeNode temp = null;
		while (head != null) {
			NodeNode p = head.next;
			head.next = temp;
			temp = head;
			head = p;
		}
		return temp;
	}

	/*
	 * 17.输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
	 * 
	 * 思路：递归与非递归求解，小数放在前面。
	 */

	/*
	 * 
	 * 进制转换
	 */
	// 十六进制转换10进制

}

/*
 * 13.O(1)时间删除链表节点
 * 
 * 思路：将要删除节点的下一个节点的值赋给要删除的节点，然后指向下下一个节点
 */

class NodeNode {
	public int data;
	public NodeNode next;

	public NodeNode(int data) {
		// TODO Auto-generated constructor stub
		this.data = data;
		this.next = null;
	}

}

class LinkNode {
	public NodeNode root;

	public LinkNode() {
		// TODO Auto-generated constructor stub
		this.root = null;
	}

	public void display() {
		NodeNode start = this.root;
		while (start != null) {
			System.out.println(start.data);
			start = start.next;
		}
	}

	public NodeNode insert(NodeNode node) {
		if (this.root == null)
			this.root = node;
		else {
			NodeNode start = this.root;
			while (start.next != null) {
				start = start.next;
			}
			start.next = node;
		}
		return node;
	}

	public NodeNode del(NodeNode node) {
		NodeNode start = this.root;
		if (node.data == this.root.data) {
			this.root = start.next;
		} else {
			NodeNode parent = start;
			while (start.data != node.data) {
				parent = start;
				start = start.next;
			}
			parent.next = start.next;
		}
		return start;
	}

}