11、求一个数的整数次方
public class Test{
public double power(double base,int exponent) throws Exception {
double result = 0.0;
if ((base == 0.0)&& (exponent<0)){
throw new Exception("0的负数次幂没有意义");
}
if (exponent<0){
result = 1.0/powerWithExponent(base,-exponent);
}else {
result = powerWithExponent(base,exponent);
}
return result;
}
private double powerWithExponent(double base, int exponent) {
if (exponent==0)
return 1;
if (exponent==1)
return base;
double result = 1.0;
for (int i=1;i<=exponent;i++){
result = result*base;
}
return result;
}
public static void main(String[] args) throws Exception {
Test test = new Test();
System.out.println(test.power(2.0,5));
}
}
12、打印1到最大的n位数
public class Test{
public void printToMaxOfNDigits(int n){
StringBuffer sb = new StringBuffer();
for (int i=0;i<n;i++){
sb.append(9);
}
String s = new String(sb);
int num = Integer.valueOf(s).intValue();
for (int j=1;j<=num;j++){
System.out.print(j+" ");
}
}
public static void main(String[] args) {
Test test = new Test();
test.printToMaxOfNDigits(3);
}
}
13、在O(1)时间内删除链表结点
- 给定单向链表的头指针和一个节点指针,定义一个函数在O(1)时间内删除该节点
class ListNode{
int data;
ListNode nextNode;
}
public class Test{
public void deleteNode(ListNode head,ListNode deListNode){
if (deListNode==null || head==null)
return;
if (head==deListNode){
head = null;
}else {
if(deListNode.nextNode==null){
ListNode pointListNode = head;
while (pointListNode.nextNode.nextNode != null){
pointListNode = pointListNode.nextNode;
}
pointListNode.nextNode=null;
}else {
deListNode.data = deListNode.nextNode.data;
deListNode.nextNode = deListNode.nextNode.nextNode;
}
}
}
public static void main(String[] args) {
ListNode head = new ListNode();
ListNode second = new ListNode();
ListNode third = new ListNode();
head.nextNode=second;
second.nextNode=third;
head.data=1;
second.data=2;
third.data=3;
Test test = new Test();
test.deleteNode(head,second);
System.out.println(head.nextNode.data);
}
}
14、调整数组
public class Test{
public void order(int[] arr){
if (arr==null || arr.length==0)
return;
int start = 0;
int end = arr.length-1;
while (start<end){
while (!isEven(arr[start]))
start++;
while (isEven(arr[end]))
end--;
if (start<end){
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
}
private boolean isEven(int i) {
return i%2==0;
}
public static void main(String[] args) {
Test test = new Test();
int[] arr = {2,3,1,4,8,5,6,0};
test.order(arr);
System.out.println(Arrays.toString(arr));
}
}
15、求链表中的倒数第K个节点
class ListNode{
int data;
ListNode nextNode;
}
public class Test{
public ListNode findKToTail(ListNode head,int k){
if (head==null || k==0)
return null;
ListNode resultNode = null;
ListNode headListNode = head;
for (int i = 0; i < k; i++) {
if (headListNode.nextNode!=null)
headListNode = headListNode.nextNode;
else
return null;
}
resultNode = head;
while (headListNode!=null){
resultNode = resultNode.nextNode;
headListNode = headListNode.nextNode;
}
return resultNode;
}
public static void main(String[] args) {
ListNode head = new ListNode();
ListNode second = new ListNode();
ListNode third = new ListNode();
ListNode forth = new ListNode();
head.nextNode = second;
second.nextNode = third;
third.nextNode = forth;
head.data=1;
second.data=2;
third.data=3;
forth.data=4;
Test test = new Test();
System.out.println(test.findKToTail(head,3).data);
}
}
16、求一个链表的反转(链表逆置)
class ListNode{
int data;
ListNode nextNode;
}
public class Test{
public ListNode reverseList(ListNode head){
if (head==null)
return null;
if (head.nextNode==null)
return head;
ListNode pre = null;
ListNode now = head;
ListNode reversedHead = null;
while (now.nextNode!=null){
ListNode next = now.nextNode;
if (next==null)
reversedHead = next;
now.nextNode=pre;
pre=now;
now=next;
}
return now;
}
public static void main(String[] args) {
ListNode head = new ListNode();
ListNode second = new ListNode();
ListNode third = new ListNode();
ListNode forth = new ListNode();
head.nextNode = second;
second.nextNode = third;
third.nextNode = forth;
head.data=1;
second.data=2;
third.data=3;
forth.data=4;
Test test = new Test();
System.out.println(test.reverseList(head).data);
}
}
17、合并两个已经排好序的增序链表,要求合并好仍为增序
class ListNode{
int data;
ListNode nextNode;
}
public class Test{
public ListNode mergeList(ListNode head1,ListNode head2){
if (head1==null)
return head2;
else if (head2==null)
return head1;
ListNode mergeHead = null;
if(head1.data < head2.data){
mergeHead = head1;
mergeHead.nextNode = mergeList(head1.nextNode,head2);
}else {
mergeHead = head2;
mergeHead.nextNode = mergeList(head1,head2.nextNode);
}
return mergeHead;
}
public static void main(String[] args) {
ListNode head1 = new ListNode();
ListNode head2 = new ListNode();
ListNode second1 = new ListNode();
ListNode second2 = new ListNode();
ListNode third1 = new ListNode();
head1.nextNode = second1;
second1.nextNode = third1;
head2.nextNode = second2;
head1.data=1;
second1.data=3;
head2.data=2;
second2.data=4;
third1.data=5;
Test test = new Test();
System.out.println(test.mergeList(head1,head2).nextNode.nextNode.nextNode.nextNode.data);
}
}
18、树的子结构
class BinaryTreeNode{
int value;
BinaryTreeNode leftNode;
BinaryTreeNode rightNode;
}
public class Test{
public boolean hasSubTree(BinaryTreeNode root1,BinaryTreeNode root2){
boolean result = false;
if(root1!=null && root2!=null){
if (root1.value == root2.value){
result = doesTree1HaveTree2(root1,root2);
if (!result)
result = hasSubTree(root1.leftNode,root2);
if (!result)
result = hasSubTree(root1.rightNode,root2);
}
}
return result;
}
private boolean doesTree1HaveTree2(BinaryTreeNode root1, BinaryTreeNode root2) {
if (root2==null)
return true;
else if (root1==null)
return false;
if (root1.value==root2.value)
return false;
return doesTree1HaveTree2(root1.leftNode,root2.leftNode) &&
doesTree1HaveTree2(root1.rightNode,root2.rightNode);
}
public static void main(String[] args) {
BinaryTreeNode root1 = new BinaryTreeNode();
BinaryTreeNode node1 = new BinaryTreeNode();
BinaryTreeNode node2 = new BinaryTreeNode();
BinaryTreeNode node3 = new BinaryTreeNode();
BinaryTreeNode node4 = new BinaryTreeNode();
BinaryTreeNode node5 = new BinaryTreeNode();
BinaryTreeNode node6 = new BinaryTreeNode();
BinaryTreeNode root2 = new BinaryTreeNode();
BinaryTreeNode a = new BinaryTreeNode();
BinaryTreeNode b = new BinaryTreeNode();
root1.leftNode=node1;
root1.rightNode=node2;
node1.leftNode=node3;
node1.rightNode=node4;
node4.leftNode=node5;
node4.rightNode=node6;
root1.value=8;
node1.value=8;
node2.value=7;
node3.value=9;
node4.value=2;
node5.value=4;
node6.value=7;
root2.leftNode=a;
root2.rightNode=b;
root2.value=8;
a.value=9;
b.value=2;
Test test = new Test();
System.out.println(test.hasSubTree(root1,root2));
}
}
19、镜像二叉树
class BinaryTreeNode{
BinaryTreeNode leftNode;
BinaryTreeNode rightNode;
int value;
}
public class Test{
public BinaryTreeNode mirrorBinaryTree(BinaryTreeNode root){
if (root==null)
return null;
if (root.leftNode==null && root.rightNode==null)
return null;
Stack<BinaryTreeNode> stack = new Stack<>();
while (root!=null || !stack.isEmpty()){
BinaryTreeNode temp = root.leftNode;
root.leftNode = root.rightNode;
root.rightNode = temp;
stack.push(root);
root = root.leftNode;
}
root = stack.pop();
root = root.rightNode;
return root;
}
public static void main(String[] args) {
BinaryTreeNode root = new BinaryTreeNode();
BinaryTreeNode node1 = new BinaryTreeNode();
BinaryTreeNode node2 = new BinaryTreeNode();
BinaryTreeNode node3 = new BinaryTreeNode();
BinaryTreeNode node4 = new BinaryTreeNode();
root.leftNode = node1;
root.rightNode = node2;
node1.leftNode = node3;
node1.rightNode = node4;
root.value = 1;
node1.value = 2;
node2.value = 3;
node3.value = 4;
node4.value = 5;
Test test = new Test();
System.out.println(test.mirrorBinaryTree(root).leftNode.rightNode.value);
}
}
20、顺时针打印矩阵
public class Test{
public void printMatixClockWisely(int[][] array){
if (array==null)
return;
int start =0 ;
while (array[0].length>start*2 && array.length>start*2){
printOneCircle(array,start);
start++;
}
}
private void printOneCircle(int[][] array, int start) {
for (int i=start;i<array[0].length-start;i++){
System.out.print(array[start][i]+" ");
}
if (array.length-1-start>start){
for (int i=start+1;i<array.length-start-1;i++){
System.out.print(array[i][array[0].length-1-start]+" ");
}
}
if (array[0].length-1-start>start && array.length-1-start >start){
for (int i=array[0].length-1-start;i>start;i--){
System.out.print(array[array.length-start-1][i]+" ");
}
}
if (array.length-1-start > start && array[0].length-1-start >start){
for (int i=array.length-start-1;i>start;i--){
System.out.print(array[i][start]+" ");
}
}
}
public static void main(String[] args) {
Test test = new Test();
int[][] arr = {{1,2,3,0},{4,5,6,0},{7,8,9,0},{10,11,12,0}};
test.printMatixClockWisely(arr);
}
}