data structure test

1、设计算法，对带头结点的单链表实现就地逆置。并给出单链表的存储结构（数据类型）的定义。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
using namespace std;

typedef char ElemType;

typedef struct Node{
	ElemType data;
	struct Node *next;
}Node, *LinkList;

LinkList CreateList()
{
	LinkList L;
	ElemType c;
	L = (LinkList)malloc(sizeof(Node));
	L->next = NULL;
	Node *p , *tail;
	tail = L;
	c = getchar();
	while(c != '#')
	{
		p = (Node *)malloc(sizeof(Node));
		p->data = c;
		tail->next = p;
		tail = p;
		c = getchar();
	}
	tail->next = NULL;
	return L;
}

void ShowList(LinkList L)
{
	Node *p;
	p = L->next;
	while(p != NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

void ReverseList(LinkList L)
{
	Node *p, *q;
	p = L->next;
	L->next = NULL;
	while(p != NULL)
	{
		q = p->next;
		p->next = L->next;
		L->next = p;
		p = q;
	}

}

int main()
{
	LinkList L;
	L = CreateList();
	ShowList(L);

	ReverseList(L);
	ShowList(L);
	return 0;
}

2、编写递归算法，将二叉树中所有结点的左、右子树相互交换。并给出算法中使用的二叉树的存储结构（数据类型）的定义。

typedef struct BiNode
{
	char data;
	struct BiNode *left;
	struct BiNode *right;
}BiNode, *BiTree;

BiNode* Exchange(BiNode* T)
{
 BiNode* p;
 if(NULL==T || (NULL==T->lchild && NULL==T->rchild))
  return T;
 p = T->lchild;
 T->lchild = T->rchild;
 T->rchild = p;
 if(T->lchild)
 {
  T->lchild = Exchange(T->lchild);
 }
 if(T->rchild)
 {
  T->rchild = Exchange(T->rchild);
 }
 return T;
}

3、折半查找算法。

#include<iostream>
#include<cstdio>
using namespace std;
int search(int *array, int n, int target)
{
    int low = 0;
    int high = n - 1;
    if( low > high ) return -1;
    while( low <= high )
    {
           int mid = low + ( high - low ) / 2;
           if( array[mid] < target ) low = mid + 1;
           else if( array[mid] > target ) high = mid - 1;
           else return mid;
    }
}
int main()
{
    int a[] = {1,2,3,4,5,6,7,8,9};
    cout<<search(a,9,4)<<endl;
return 0;
}

4、数据结构课本P74，习题2、13

void DeleteNode( ListNode *s)
　　　　{//删除单循环链表中指定结点的直接前趋结点
　　　　　　ListNode *p, *q;
　　　　　　p=s;
　　　　　　while( p->next->next!=s)
　　　　　　　p=p->next;
　　　　　　//删除结点
　　　　　　q=p->next;
　　　　　　p->next=q->next;
　　　　　　free(p);	 //释放空间
　　　　}

5、统计叶子结点数。P168

#include<iostream>
#include<queue>
#include <cstdlib>
#include <cstdio>
using namespace std;
typedef struct BiNode
{
	char data;
	struct BiNode *left;
	struct BiNode *right;
}BiNode, *BiTree;
int sum = 0;
void CreateBinaryTree(BiTree &T)//二叉树建立   abc,,de,g,,f,,,
{
	//T = (BiNode*) malloc (sizeof(BiNode));
	T = new BiNode;
	cin >> T->data;
	if(T->data == ',')
	{
		T = NULL;
	}
	if(T != NULL)
	{
		CreateBinaryTree(T->left);
		CreateBinaryTree(T->right);
	}
}
void PreOrder(BiTree T)//前序遍历
{
	if(T != NULL)
	{
		cout << T->data;
		PreOrder(T->left);
		PreOrder(T->right);
	}
}
void InOrder(BiTree T)//中序遍历
{
	if(T != NULL)
	{
		InOrder(T->left);
		cout << T->data;
		InOrder(T->right);
	}
}
void PostOrder(BiTree T)//后序遍历
{
	if(T != NULL)
	{
		PostOrder(T->left);
		PostOrder(T->right);
		cout << T->data;
	}
}
void LevOrder(BiTree T)//层次遍历
{
	if(T != NULL)
	{
		BiTree p = T;
		queue<BiTree>que;
		que.push(p);
		while(!que.empty())
		{
			p = que.front();
			cout << p->data;
			que.pop();
			if(p->left != NULL)
			{
				que.push(p->left);
			}
			if(p->right != NULL)
			{
				que.push(p->right);
			}
		}
	}
}
int Size(BiTree T)//计算二叉树节点数
{
	if(T != NULL)
	{
		if(T->left == NULL && T->right == NULL)
		{
			sum++;
		}
		Size(T->left);
		Size(T->right);
	}
	return sum;
}
int Deep(BiTree T)//计算二叉树深度
{
	int m, n;
	if(T == NULL) return 0;
	m = Deep(T->left);
	n = Deep(T->right);
	if(m > n) return m + 1;
	else return n + 1;
}
int main(void)
{
	BiTree T;
	CreateBinaryTree(T);

	cout << "前序遍历结果为：" << endl;
	PreOrder(T);
	cout << endl << endl;

	cout << "中序遍历结果为：" << endl;
	InOrder(T);
	cout << endl << endl;

	cout << "后序遍历结果为：" << endl;
	PostOrder(T);
	cout << endl << endl;

	cout<<"层次遍历结果为："<<endl;
	LevOrder(T);
	cout << endl << endl;

	cout << "二叉树叶节点个数为：" << Size(T)<<endl;
	cout << "二叉树深度数为：" << Deep(T) << endl;
	system("pause");
	return 0;
}

6、顺序表的合并。

#define MAXSIZE 100
typedef int ElemType;

typedef struct SeqList
{
	ElemType elem[MAXSIZE];
	int last;
}SeqList;
void mergeList(SeqList *LA, SeqList * LB, SeqList *LC)
{
	int i, j, k;
	i = j = k = 0;
	while (i <= LA->last && j <= LB->last)
	{
		if (LA->elem[i] <= LB->elem[j])
		{
			LC->elem[k++] = LA->elem[i++];
		}
		else
		{
			LC->elem[k++] = LB->elem[i++];
		}
	}
	while (i <= LA->last)
	{
		LC->elem[k++] = LA->elem[i++];
	}
	while (j <= LB->last)
	{
		LC->elem[k++] = LB->elem[j++];
	}
	LC->last = LA->last + LB->last + 1;
}