剑指offer---3

1.反转单链表,输入链表的头节点,输出该链表,并输出反转后的头节点

这个题目不用再说了,写过N边了

SLnode reverse(SLnode head)
{
    SLnode reverse_head = NULL;
    SLnode pnode = head->next;
    SLnode prev = NULL;
    SLnode pnext = NULL;
    while(pnode != NULL)
    {
        pnext = pnode->next;
        if(pnext == NULL)
            reverse_head = pnode;
        pnode->next = prev;
        prev = pnode;
        pnode = pnext;
    }
    head->next = reverse_head;
    return head;
}

以前自己还写过一段代码,两种方式的思路不同,这种是从第一个节点开始,把它的next指针指向它的前一个节点,直到最后一个节点为止

下一种也是从第一个节点开始,但是把它的下一个节点放到它的前面,比较不容易理解

SLnode reverse(SLnode head)
{
    if(head == NULL || head->next == NULL)
        return head;

    SLnode p = NULL;
    SLnode tmp = head->next;
    while(tmp->next != NULL)
    {
        p = tmp->next;
        tmp->next = p->next;
        p->next = head->next;
        head->next = p;
    }
    return head;
}

2.合并排序的链表,使合并后仍然递增,这个也是写了很多边了,递归和非递归实现

SLnode mergelist2(SLnode head1, SLnode head2)
{
    if(head1 == NULL)
        return head2;
    if(head2 == NULL)
        return head1;
    SLnode MergerHead = NULL;
    if(head1->data > head2->data)
    {
        MergerHead = head1;
        MergerHead->next = mergelist2(head1->next, head2);
    }
    else
    {
        MergerHead = head2;
        MergerHead->next = mergelist2(head1, head2->next);
    }
    return MergerHead;
}

再一次强调递归和非递归的本质区别,一个是使用系统提供的栈,即函数参数压栈,一个是我们自己使用栈,此处的非递归采用的是迭代,某种程度上来说,也是使用的栈

SLnode mergelist(SLnode head1, SLnode head2)
{
	if(head1 == NULL)
		return head2;
	if(head2 == NULL)
		return head1;
	SLnode node1 = head1->next;
	SLnode node2 = head2->next;

	SLnode mergehead = (SLnode)malloc(sizeof(SLnode));

	if(node1->data > node2->data)
	{
		mergehead->next = node1;
		node1 = node1->next;
	}
	else
	{
		mergehead->next = node2;
		node2 = node2->next;
	}

	SLnode temp = mergehead->next;
	while(node1 != NULL && node2 != NULL)
	{
		if(node1->data > node2->data)
		{
			temp->next = node1;
			node1 = node1->next;
			temp = temp->next;
		}
		else
		{
			temp->next = node2;
			node2 = node2->next;
			temp = temp->next;
		}
	}
	if(node1 != NULL)
		temp->next = node1;
	if(node2 != NULL)
		temp->next = node2;

	return mergehead;
}

3.输入两颗二叉树,判断B是不是A的子结构

这个题目很有思想,我是看了思路之后才写出来的,需要分为两步考虑,首先从A中查找是否有B的根节点,如果找到了,再比较A的左子树和B的左子树,A的右子树和B的右子树是否相

等,如果找不到,则继续在A的左子树和右子树中查找是否有和B的根节点相同的,直到A的叶子节点为止

#include <stdio.h>
#include <stdlib.h>

typedef struct BitreeNode
{
	int data;
	struct BitreeNode*left, *right;
}BitreeNode;

void construct_bitree(BitreeNode **root)
{
	int x;
	scanf("%d",&x);

	if(x != -1)
	{
		*root =  (BitreeNode*)malloc(sizeof(struct BitreeNode));
		if(*root == NULL)
			printf("malloc error\n");
		(*root)->data = x;
		(*root)->left = NULL;
		(*root)->right = NULL;

		printf("input the left node, -1 to end\n");
		construct_bitree(&((*root)->left));

		printf("input the right node, -1 to end\n");
		construct_bitree(&((*root)->right));
	}
}
void print_tree(BitreeNode *root)
{
	if(root != NULL)
	{
		printf("%d\n",root->data);
		print_tree(root->left);
		print_tree(root->right);
	}
}

void Free(BitreeNode *root)
{
	if(root != NULL)
		return;
	else
	{
		Free(root->left);
		Free(root->right);
		free(root);
	}
}

int find_subtree_core(BitreeNode *root1, BitreeNode *root2)
{
	if(root1 == NULL)
		return 0;
	if(root2 == NULL)
		return 1;
	if(root1->data != root2->data)
		return 0;
	return find_subtree_core(root1->left, root2->right)&&
		find_subtree_core(root1->right, root2->right);
}

int find_subtree(BitreeNode *root1, BitreeNode *root2)
{
	int ret = 0;
	if(root1 != NULL && root2 != NULL)
	{
		if(root1->data == root2->data)
			ret = find_subtree_core(root1, root2);
		else
		{
			if(!ret) find_subtree(root1->left, root2);
			if(!ret) find_subtree(root1->right, root2);
		}
	}
	return ret;
}

void main()
{

	BitreeNode *root1 = NULL;
	BitreeNode *root2 = NULL;

	printf("please input the root1:\n");
	construct_bitree(&root1);
	print_tree(root1);

	printf("please input the root2:\n");
	construct_bitree(&root2);
	print_tree(root2);

	if(find_subtree(root1, root2))
		printf("find the subtree\n");

	Free(root1);
	Free(root2);
}

4.二叉树的镜像,要求输入一个二叉树,输出它的镜像

思路:如果根节点的左右孩子节点存在,就交换根节点的左右孩子节点,如果左右孩子节点存在,再递归调用

void mirror_of_bitree(BitreeNode *root)
{
	if(root == NULL || (root->left == NULL)&&(root->right == NULL))
		return;
	BitreeNode *temp = root->left;
	root->left = root->right;
	root->right = temp;

	mirror_of_bitree(root->left);
	mirror_of_bitree(root->right);
}

5.顺时针打印一个矩阵,如果输入的是

1     2     3     4

5     6     7     8

打印的是1  2  3  4  8  7  6  5

这个题目我按照自己思路来解决的,没有按照书上给的思路,直接来想就是打印最外面一圈,然后缩小范围,打印里面一圈,直到范围内曾大小为0时为止

#include <stdio.h>
#define column 4
#define row 4
//这个程序是我自己写出来的,虽然比较臃肿和难以理解,但是思路很清晰
void main()
{
	int a[row][column] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};

	int begin1 = 0, end1 = row-1;
	int begin2 = 0, end2 = column-1;
	int i = 0, j = 0;
	while(i <= end1)
	{
		if(j > end2)
			break;
		for( ; j <= end2; j++)
			printf("%d\n",a[i][j]);
		j--;
		i++;
		if(i > end1)
			break;
		for( ; i <= end1; i++)
			printf("%d\n",a[i][j]);
		j--;
		i--;
		if(j < begin2)
			break;
		for( ; j >= begin2; j--)
			printf("%d\n",a[i][j]);
		i--;
		j++;
		if(i <= begin1)
			break;
		for( ; i > begin1; i--)
			printf("%d\n",a[i][j]);
		i++;
		j++;
		begin1++;begin2++;
		end1--;end2--;
	}
}

6.定一个栈的数据结构,并实现一个能够得到最小元素的min函数,调用min,pop,push函数的时间复杂度都是O(1)

首先我们要明白这个题目的入手点在于用栈去实现这样的数据结构,我当时还傻不啦叽的自己去实现一个栈,找到了切入点,我们再来看怎么去实现这个函数,

在栈中添加一个成员变量作为最小元素?那要是这个变量弹出了怎么办?所以,我们可以每次入栈元素的时候就添加一个变量,这个时候我们可以使用辅助栈,这里的关键在于

每次入栈的时候我们要去更新辅助栈中元素,使它的栈顶是最小元素

#include <iostream>
#include <stack>
#include <stdlib.h>
using namespace std;

template<class T>
class Stack
{
private:
	stack<T> m_data;
	stack<T> m_min;
public:
	Stack();
	~Stack();

	void push(T data);
	void pop();

	const T& min() const;
};
template<class T>
Stack<T>::Stack()
{}

template<class T>
Stack<T>::~Stack()
{}

template<class T>
void Stack<T>::push(T data)
{
	m_data.push(data);
	if(!m_min.empty() && data > m_min.top())
			m_min.push(m_min.top());//每次入栈都要考虑最小元素的入栈
	else
		m_min.push(data);
}

template<class T>
void Stack<T>::pop()
{
	if(m_data.empty())
	{
		cout<<"the stack is empty"<<endl;
		return;
	}
	m_data.pop();
	m_min.pop();
}

template<class T>
const T& Stack<T>::min() const
{
	return m_min.top();
}

int main()
{
	Stack<int> SS;
	SS.push(2);
	SS.push(3);
	SS.push(4);
	int ret = SS.min();
	SS.pop();
	cout<<"min num "<<ret<<endl;

	SS.push(1);
	SS.push(8);
	SS.pop();
	SS.pop();
	SS.push(7);
	ret = SS.min();
	cout<<"min num "<<ret<<endl;

	return 0;
}

7.一个整数数组里面,除了两个数字外,其它的数字都出现了两次,写出程序找出这两个只出现一次的数字,时间复杂度为O(n),空间复杂度为O(1)

这个题目还是曾经百度的笔试题目,思路是这样的:

既然其它数字都出现了两次,那么所有的数字求异或之后,得到的值就是只出现一次的那两个数字的异或值,然后我们找到这个值的二进制的最右边的那个1,并以此为依据,将这个数

组分为两部分,因为其它出现两次的数字在个各位上的值一样,所以这两部分就分出了这两个数字

一下是我的参考代码:

#include <stdio.h>

int find_the_last1(int x)
{
	int n = 0;
	x = x&~(x-1);
	while((1 & x) == 0)
	{
		x>>1;
		n++;
	}
	return n;
}

void num_appear_once(int a[], int n)
{
	int ret = 0, ret1 = 0, ret2 = 0, i;
	for(i = 0; i < n; i++)
		ret ^= a[i];
	int m = find_the_last1(ret);
	for(i = 0; i < n; i++)
	{
		if((a[i]>>m)&1)
			ret1 ^= a[i];
		else
			ret2 ^= a[i];
	}
	printf("%d\t%d\n",ret1, ret2);
}

void main()
{
	int a[] = {1,2,3,3,2,5,6,1};
	num_appear_once(a, 8);
}

类比去年小米校招的题目:在一个长度为n的整形数组a里，除了三个数字只出现一次外，其他的数字都出现了2次。请写程序输出任意一个只出现一次的数字，程序时间和空间复杂度越小越好。例如： a = {1,3,7,9,5,9,4,3,6,1,7}，输出4或5或6

这个题目的思路和上面是一样的,只不过是三个数字,所以在我们异或之后,我们可以两两异或,三个数的两两异或就可以分为两组,参考代码:

// lowbit表示的是某个数从右往左扫描第一次出现1的位置
int lowbit(int x)
{
	return x&~(x-1);
}
void find(int* a , int n)
{
	int i , xors;
	xors = 0;
	for(i = 0 ; i < n ; ++i)
		xors ^= a[i];
	// 三个数两两的异或后lowbit有两个相同，一个不同，可以分为两组
	int fips = 0;
	for(i = 0 ; i < n ; ++i)
		fips ^= lowbit(xors ^ a[i]);//这一步是个关键
	// 表示的是：flips=lowbit(a^b)^lowbit(a^c)^lowbit(b^c)
	int b;    // 假设三个只出现一次的其中一个数为b
	b = 0;
	for(i = 0 ; i < n ; ++i)
	{
		if(lowbit(xors ^ a[i]) == fips)
			b ^= a[i];
	}
	// 成功找到三个数中一个数
	cout<<b<<endl;
}