/*单链表简要实现
*
*
*/
#include <stdio.h>
#include <stdlib.h>
struct Node;
typedef struct Node* PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;
typedef int ElementType;
struct Node{
ElementType data;
Position Next;
};
/*整表创建(头插法)*/
List CreateList_Pre();
/*整表创建(尾插法)*/
List CreateList_Bac();
/*整表删除*/
void DeleteList(List L);
/*得到当前链表的长度*/
int ListLength(List L);
/*得到指定位置的元素*/
int getElement(List L, ElementType i);
/*插入指定值到指定位置前面*/
void Insert_Pre(List L, ElementType element, int i);
/*插入指定值到指定位置后面*/
void Insert_Bac(List L, ElementType element, int i);
/*删除指定位置的元素*/
void Delete(List L, ElementType i);
/*遍历链表*/
void ListTraverse(List L);
List CreateList_Pre(){
Position NewNode;
List L = malloc(sizeof(struct Node));
if (L == NULL)
return;
L->Next = NULL;
for (int i = 1; i <= 10; i++){
NewNode = malloc(sizeof(struct Node));
NewNode->data = i;
NewNode->Next = L->Next;
L->Next = NewNode;
}
return L;
}
List CreateList_Bac(){
Position NewNode;
Position FirstNode;
List L = malloc(sizeof(struct Node));
FirstNode = L;
if (L == NULL)
return;
for (int i = 1; i <= 10; i++){
NewNode = malloc(sizeof(struct Node));
NewNode->data = i;
L->Next = NewNode;
L = NewNode;
}
L->Next = NULL;
return FirstNode;
}
void DeleteList(List L){
Position P, Q;
P = L->Next;
while (P != NULL){
Q = P->Next;
free(P);
P = Q;
}
L->Next = NULL;
}
int ListLength(List L){
Position P;
int count = 0;
P = L->Next;
while (P != NULL){
P = P->Next;
count++;
}
return count;
}
int getElement(List L, ElementType i){
Position P;
int count = 1;
P = L->Next;
if (P == NULL && i < count)
return;
while (P != NULL && i > count){
P = P->Next;
count++;
}
return P->data;
}
void Insert_Pre(List L, ElementType element, int i){
Position P, NewNode;
int count = 1;
P = L;
while (P->Next != NULL && count < i){
P = P->Next;
count++;
}
if (P == NULL || i < count)
return;
NewNode = malloc(sizeof(struct Node));
NewNode->data = element;
NewNode->Next = P->Next;
P->Next = NewNode;
}
void Insert_Bac(List L, ElementType element, int i){
Position P, NewNode;
int count = 1;
P = L->Next;
while (P != NULL && count < i){
P = P->Next;
count++;
}
if (P == NULL || i < count)
return;
NewNode = malloc(sizeof(struct Node));
NewNode->data = element;
NewNode->Next = P->Next;
P->Next = NewNode;
}
void Delete(List L, ElementType i){
Position P, Tmp;
int count = 1;
P = L;
while (P->Next != NULL && i > count){
P = P->Next;
count++;
}
if (P->Next == NULL || i < count)
return;
Tmp = P->Next;
P->Next = Tmp->Next;
free(Tmp);
}
void ListTraverse(List L){
Position P;
P = L->Next;
while (P != NULL){
printf("%d ", P->data);
P = P->Next;
}
printf("\n");
}
void main(){
List L;
L = CreateList_Bac();
printf("新建链表(尾插法): ");
ListTraverse(L);
printf("当前链表长度为: %d\n", ListLength(L));
printf("当前链表第7个元素为: %d\n", getElement(L, 7));
Insert_Pre(L, 16, 5);
printf("插入至指定元素前面: ");
ListTraverse(L);
Insert_Bac(L, 16, 5);
printf("插入至指定元素后面: ");
ListTraverse(L);
Delete(L, 5);
printf("删除指定元素: ");
ListTraverse(L);
DeleteList(L);
printf("删除链表: ");
ListTraverse(L);
printf("当前链表长度为: %d\n", ListLength(L));
printf("\n");
L = CreateList_Pre();
printf("新建链表(头插法): ");
ListTraverse(L);
printf("当前链表长度为: %d\n", ListLength(L));
printf("当前链表第7个元素为: %d\n", getElement(L, 7));
Insert_Pre(L, 16, 5);
printf("插入至指定元素前面: ");
ListTraverse(L);
Insert_Bac(L, 16, 5);
printf("插入至指定元素后面: ");
ListTraverse(L);
Delete(L, 5);
printf("删除指定元素: ");
ListTraverse(L);
DeleteList(L);
printf("删除链表: ");
ListTraverse(L);
printf("当前链表长度为: %d\n", ListLength(L));
}
/*链式栈的简要实现
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
struct StackNode;
struct LinkStack;
typedef struct StackNode* PtrToStack;
typedef struct LinkStack* PtrToLink;
typedef PtrToStack Node;
typedef PtrToStack LinkStackPtr;
typedef PtrToLink Link;
typedef int ElementType;
struct StackNode{
int data;
Node Next;
};
struct LinkStack{
LinkStackPtr top;
int count;
};
Link InitStack();/*初始化链栈*/
void ClearStack(Link L);/*清空链栈*/
void StackEmpty(Link L);/*检查链栈是否为空*/
int StackLength(Link L);/*检查链栈长度*/
int GetTop(Link L);/*得到栈顶元素*/
int Push(Link L, ElementType e);/*压栈操作*/
int Pop(Link L);/*弹栈操作*/
void LinkTraverse(Link L);/*遍历链栈*/
/*初始化链栈*/
Link InitStack(){
Link L = malloc(sizeof(struct LinkStack));
if (L == NULL)
return;
L->top = malloc(sizeof(struct StackNode));
if (L->top == NULL)
return;
L->top = NULL;
L->count = 0;
return L;
}
/*清空链栈*/
void ClearStack(Link L){
LinkStackPtr P, Q;
P = L->top;
while (P != NULL){
Q = P->Next;
free(P);
P = Q;
}
L->count = 0;
}
/*检查链栈是否为空*/
void StackEmpty(Link L){
if (L->count == 0)
printf("链栈为空\n");
else
printf("链栈不为空\n");
}
/*检查链栈长度*/
int StackLength(Link L){
return L->count;
}
/*得到栈顶元素*/
int GetTop(Link L){
if (L->top == NULL)
return NULL;
if (L->top == NULL)
return;
return L->top->data;
}
/*压栈操作*/
int Push(Link L, ElementType e){
LinkStackPtr S = malloc(sizeof(struct StackNode));
S->data = e;
S->Next = L->top;
L->top = S;
L->count++;
return e;
}
/*弹栈操作*/
int Pop(Link L){
LinkStackPtr P;
int e = L->top->data;
P = L->top;
L->top = P->Next;
free(P);
L->count--;
return e;
}
/*遍历链栈*/
void LinkTraverse(Link L){
LinkStackPtr P;
P = L->top;
while (P != NULL){
printf("%d\n", P->data);
P = P->Next;
}
}
void main(){
Link L;
L = InitStack();
printf("压栈(由底至顶):\n");
for (int i = 1; i <= 10; i++){
Push(L, i);
}
LinkTraverse(L);
StackEmpty(L);
printf("链栈长度为: %d\n",StackLength(L));
printf("链栈顶的元素为: %d\n", GetTop(L));
printf("\n");
printf("出栈(由顶至底):\n");
for (int i = 10; i > 0; i--){
printf("%d\n", Pop(L));
}
LinkTraverse(L);
StackEmpty(L);
printf("链栈长度为: %d\n", StackLength(L));
printf("链栈顶的元素为: %d\n", GetTop(L));
}
/*链式队列的简要实现
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20
struct Node;
struct LinkQueue;
typedef struct Node* PtrToNode;
typedef struct LinkQueue* PtrToQueue;
typedef PtrToNode QNode;
typedef PtrToNode QueuePtr;
typedef PtrToQueue Queue;
typedef int ElementType;
struct Node{
ElementType data;
QNode Next;
};
struct LinkQueue{
QueuePtr front;
QueuePtr rear;
};
Queue InitQueue();/*初始化队列*/
void DestroyQueue(Queue Q);/*销毁一个队列*/
void ClearQueue(Queue Q);/*清空队列*/
void QueueEmpty(Queue Q);/*检查队列是否为空*/
int QueueLength(Queue Q);/*获取队列长度*/
int GetHead(Queue Q);/*得到队列头元素*/
int EnQueue(Queue Q, ElementType e);/*入列*/
int DeQueue(Queue Q);/*出列*/
void QueueTraverse(Queue Q);/*遍历队列*/
/*初始化队列*/
Queue InitQueue(){
Queue Q = malloc(sizeof(struct LinkQueue));
if (Q == NULL)
return NULL;
Q->front = Q->rear = malloc(sizeof(struct Node));
Q->front->Next = NULL;
return Q;
}
/*销毁一个队列*/
void DestroyQueue(Queue Q){
while (Q->front != NULL){
Q->rear = Q->front->Next;
free(Q->front);
Q->front = Q->rear;
}
}
/*清空队列*/
void ClearQueue(Queue Q){
QueuePtr P, K;
Q->rear = Q->front;
P = Q->front->Next;
Q->front->Next = NULL;
while (P != NULL){
K = P->Next;
free(P);
P = K;
}
}
/*检查队列是否为空*/
void QueueEmpty(Queue Q){
if (Q->front == Q->rear)
printf("\n队列为空\n");
else
printf("\n队列不为空\n");
}
/*获取队列长度*/
int QueueLength(Queue Q){
QueuePtr P;
int count = 0;
P = Q->front;
while (Q->rear != P){
P = P->Next;
count++;
}
return count;
}
/*得到队列头元素*/
int GetHead(Queue Q){
QueuePtr P;
if (Q->front == Q->rear)
return NULL;
P = Q->front->Next;
return P->data;
}
/*入列*/
int EnQueue(Queue Q, ElementType e){
QueuePtr S = malloc(sizeof(struct Node));
if (S == NULL)
return NULL;
S->data = e;
S->Next = NULL;
Q->rear->Next = S;
Q->rear = S;
return e;
}
/*出列*/
int DeQueue(Queue Q){
QueuePtr P;
if (Q->front == Q->rear)
return NULL;
P = Q->front->Next;
ElementType e = P->data;
Q->front->Next = P->Next;
if (Q->rear == P) /*如果队头就是队尾*/
Q->front = Q->rear;
free(P);
return e;
}
/*遍历队列*/
void QueueTraverse(Queue Q){
QueuePtr P;
P = Q->front->Next;
while (P != NULL){
printf("%d ", P->data);
P = P->Next;
}
}
void main(){
Queue Q;
Q = InitQueue();
printf("入列:\n");
for (int i = 1; i <= 10; i++){
EnQueue(Q, i);
}
QueueTraverse(Q);
QueueEmpty(Q);
printf("队列长度为: %d\n", QueueLength(Q));
printf("队列头元素为: %d\n", GetHead(Q));
printf("\n");
printf("出列:\n");
for (int i = 1; i <= 5; i++){
DeQueue(Q, i);
}
QueueTraverse(Q);
QueueEmpty(Q);
printf("队列长度为: %d\n", QueueLength(Q));
printf("队列头元素为: %d\n", GetHead(Q));
ClearQueue(Q);
printf("清空队列后,队列长度为: %d\n", QueueLength(Q));
}
/*二叉树的链式结构实现
*
*
*/
#include <stdio.h>
#include <stdlib.h>
struct TreeNode;
typedef int ElementType;
typedef char TElementType;
typedef char* String;
typedef struct TreeNode* PtrToNode;
typedef PtrToNode Tree;
String str = "ABDH#K###E##CFI###G#J##";/*前序遍历序列*/
ElementType index = 0;
struct TreeNode{
TElementType data;
Tree LChild;
Tree RChild;
};
Tree CreateBiTree();/*前序遍历法创建一棵二叉树*/
void Disptree(Tree T);/*凹入表示法输出二叉树* /
void PreOrderTraverse(Tree T);/*前序遍历二叉树*/
void InOrderTraverse(Tree T);/*中序遍历二叉树*/
void PostOrderTraverse(Tree T);/*后序遍历二叉树*/
void TreeEmpty(Tree T);/*检查二叉树是否为空*/
void ClearTree(Tree T);/*清空一颗二叉树*/
int TreeDepth(Tree T);/*返回树的深度*/
TElementType Root(Tree T);/*返回根节点*/
/*前序遍历法创建一颗二叉树*/
Tree CreateBiTree(){
char ch = str[index++];
Tree T;
if (ch == '#')
T = NULL;
else{
T = malloc(sizeof(struct TreeNode));
T->data = ch;
T->LChild = CreateBiTree();
T->RChild = CreateBiTree();
}
return T;
}
/*前序遍历二叉树*/
void PreOrderTraverse(Tree T){
if (T != NULL){
printf("%c ", T->data);
PreOrderTraverse(T->LChild);
PreOrderTraverse(T->RChild);
}
}
/*中序遍历二叉树*/
void InOrderTraverse(Tree T){
if (T != NULL){
InOrderTraverse(T->LChild);
printf("%c ", T->data);
InOrderTraverse(T->RChild);
}
}
/*后序遍历二叉树*/
void PostOrderTraverse(Tree T){
if (T != NULL){
PostOrderTraverse(T->LChild);
PostOrderTraverse(T->RChild);
printf("%c ", T->data);
}
}
/*检查二叉树是否为空*/
void TreeEmpty(Tree T){
if (T == NULL)
printf("二叉树为空");
else
printf("二叉树不为空");
}
//凹入表示法输出二叉树
void Disptree(Tree T)
{
if (T)
{
printf("%c", T->data);
if (T->LChild || T->RChild)
{
printf("(");
Disptree(T->LChild);
if (T->RChild)
printf(",");
Disptree(T->RChild);
printf(")");
}
}
}
/*清空一颗二叉树*/
void ClearTree(Tree T){
if (T != NULL){
ClearTree(T->LChild);
ClearTree(T->RChild);
free(T);
}
return NULL;
}
/*返回树的深度*/
int TreeDepth(Tree T){
int left, right;
if (T == NULL)
return NULL;
if (T->LChild != NULL)
left = TreeDepth(T->LChild);
else
left = 0;
if (T->RChild != NULL)
right = TreeDepth(T->RChild);
else
right = 0;
return left > right ? left + 1 : right + 1;
}
/*返回根节点*/
TElementType Root(Tree T){
if (T != NULL)
return T->data;
}
void main(){
Tree T;
T = CreateBiTree();
printf("凹入表示法:\n");
Disptree(T);
printf("\n前序遍历:\n");
PreOrderTraverse(T);
printf("\n中序遍历:\n");
InOrderTraverse(T);
printf("\n后序遍历:\n");
PostOrderTraverse(T);
printf("\n树是否为空:");
TreeEmpty(T);
printf("\n树的深度为:%d", TreeDepth(T));
printf("\n树的根节点为:%c", Root(T));
}