C部分代码

// 2015_11_12.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#define PI 3.14
#include <stdio.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
//元素类型
typedef struct
{
    int number;
    char *name;
}ElemType;
//线性表
typedef struct
{
    ElemType *elem;  //存储数据类型
    int length;      //当前长度
    int listsize;    //当前分配的存储容量
}SqList;
//判断链表是否为空
int ListEmpty(SqList &L)
{
    if(L.length == 0)
        return 1;
    return 0;
}
//获取线性表上第i个元素的值
void GetElem(SqList &L,int i)
{
	if(i<1 || i>L.length+1){
		printf("位置不合法");
		exit(-1);
	}
	printf("Name:%s ,Number:%d\n",L.elem[i-1].name,L.elem[i-1].number);
}
//显示输出
void Print(SqList &L)
{
	if(!ListEmpty(L)){
		for(int i = 0;i < L.length;i++){
			printf("Name:%s ,Number:%d\n",L.elem[i].name,L.elem[i].number);
		}
	}else{
		printf("链表为空");
	}
}
//初始化链表
void InitList(SqList &L)
{
	L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
	if(!L.elem){
		printf("初始化空间失败");
		exit(-1);
	}
    L.length = 0;
    L.listsize = LIST_INIT_SIZE;
}
//插入元素在i位置
void ListInsert(SqList &L,int i,ElemType e)
{
    if(i<1 || i>L.length+1){
        printf("插入位置不合法！\n");
        exit(0);
    }
    //在原始基础上增加新的空间
    if(L.length>=LIST_INIT_SIZE){
        ElemType *newBase = (ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
        if(!newBase)
            exit(0);
        L.elem = newBase;
        L.length+=LISTINCREMENT;
    }
	//指针q指向要插入的位置
    ElemType *q = &(L.elem[i-1]);
	//从第i位置上的元素一次向后移动
    for(ElemType *p = &(L.elem[L.length-1]);p>=q; --p)
        *(p+1) = *p;
	//第i位置上的元素设置为e
	*q = e;
    ++(L.length);
}
//删除第i个元素
void ListDelete(SqList &L,int i)
{
	if(i<1 || i>L.length+1){
		printf("位置不合法");
		exit(-1);
	}
	for(ElemType *p = &(L.elem[i-1]);p<&(L.elem[L.length-1]);p++){
		*p = *(p+1);
	}
	L.length--;//元素个数-1
	printf("删除成功\n");
	Print(L);
}

int menu_1()
{
    printf("Hello world!\n");

	SqList L;//声明
    InitList(L);
    ElemType e;
    e.name = "Jay";
    e.number = 1;
    ListInsert(L,1,e);
	e.name = "JJ";
	e.number = 2;
	ListInsert(L,2,e);
	Print(L);
	GetElem(L,1);
	ListDelete(L,1);
    return 0;
}



typedef struct LNode
{
	ElemType data; // 数据类型
	LNode *next;   // 后继指针
	int length;
}LNode,*LinkList;

void CreateLinkList(LinkList &L)
{
	L = (LinkList)malloc(sizeof(LNode));//初始化，分配一个元素空间给头节点
	L->next = NULL;
	L->length = 0;
	LNode *ln = (LNode *)malloc(sizeof(LNode));//给元素分配空间
	ln->data.name = "Js";
	ln->data.number = 3;

	ln->next = L->next;
	L->next = ln;
	L->length++;


	ln = (LNode *)malloc(sizeof(LNode));
	ln->data.name = "Ja";
	ln->data.number = 4;

	ln->next = L->next;
	L->next = ln;
	L->length++;
	printf("Length = %d\n",L->length);
}
void Show(LinkList L)
{
	LinkList head = L;//透指针
	LNode *p = head->next;//第一个元素
	while(p){
		printf("Name=%s,Number=%d\n",p->data.name,p->data.number);
		p = p->next;
	}
}

void LinkListInsert(LinkList L,LNode *ln)
{
	ln->next = L->next;
	L->next = ln; 
}
void LinkListDelete(LinkList L,LNode *ln)
{
	LinkList head = L;
	LNode *p = head->next,*q;
	q = head;
	while(p){
		if( p == ln){
			q->next = p->next;
		}
		q = p;
		p = p->next;
	}
}
void Get_Elem(LinkList L,int n)
{
	LinkList head = L;// 获取头指针
	LNode *p = head->next;//链表第一个元素
	while(p){
		if((n--)==0){ //如果是第n个元素，那么输出
			printf("Name=%s,Number=%d\n",p->data.name,p->data.number);
		}
		p = p->next;//指向下一个元素
	}
}

void menu_2()
{
	LinkList L;
	CreateLinkList(L);
	Show(L);
	Get_Elem(L,1);
	LNode ln;    //已经初始化分配了空间，如果是指针，那么一定要分配给指针指向的空间
	             //例如：LNode *ln = (LNode *)malloc(sizeof(LNode));//给元素分配空间
	ln.data.name = "Jh";
	ln.data.number = 5;
	LinkListInsert(L,&ln);
	Show(L);
	LinkListDelete(L,&ln); //让虚参数的指针指向实参的取地址
	Show(L);
}

typedef struct DuLNode
{
	int x;
	DuLNode *prior,*next;
}DiLNode,*DuLinkList;
//判断链表是否为空
bool isEmpty(DuLinkList L)
{
	if(L->next == NULL)
		return true;
	return false;
}
//显示链表信息
void ShowDuLinkList(DuLinkList L)
{
	if(!isEmpty(L)){  //链表不为空的话
		DuLNode *p = L->next; //p指向第一个节点
		while(p){
			printf("P=%d\n",p->x);
			p = p->next;
		}
	}
}
//插入元素
void DuLinkListInsert(DuLinkList L,DuLNode *dl)
{
	DuLNode *head = L;
	if(head->next == NULL){//当前链表为空的话，将第一个元素加入到头节点和NULL之间
		dl->next = head->next;
		head->next = dl;
		dl->prior = head;
	}	
	else{              //已经包含元素的话，将该节点插入到头节点和第一个节点之间
		dl->next = head->next;
		head->next->prior = dl;
		head->next = dl;
		dl->prior = head;
	}
}


//删除第一个元素
void DuLinkListDelete(DuLinkList L)
{
	DuLNode *s = L->next;
	if(!isEmpty(L)){
		if(s->next){//还有>=2个节点
			s->prior->next = s->next;
			s->next->prior = s->prior;
		}else{
			//只剩一个节点的情况
			L->next = NULL;
		}
		
	}
}


//创建双链表
void CreateDuLinkList(DuLinkList &L)
{
	L = (DuLinkList)malloc(LIST_INIT_SIZE*sizeof(DuLNode));
	L->prior =NULL;
	L->next = NULL;
}
void menu_3()
{
	DuLinkList L;
	CreateDuLinkList(L);      //创建链表
	DuLNode dl1,dl2,dl3;      //结构体，直接初始化，内存数据已经存在
	dl1.x = 1;
	DuLinkListInsert(L,&dl1); //插入元素
	dl2.x = 2;
	DuLinkListInsert(L,&dl2);
	dl3.x = 3;
	DuLinkListInsert(L,&dl3);
	ShowDuLinkList(L);         //遍历链表
	DuLinkListDelete(L);       //删除第一个节点
	ShowDuLinkList(L);
}

#define SElemType int
typedef struct {
	SElemType *base;
	SElemType  *top;
	int stacksize;
}SqStack;

//初始化栈
void InitStack(SqStack &S)
{
	S.base = (SElemType *)malloc(LIST_INIT_SIZE*sizeof(SElemType));
	S.top = S.base;
	S.stacksize = LIST_INIT_SIZE;
}
//获取栈顶
SElemType GetTop(SqStack S)
{
	return *(S.top-1);
}
//出栈
SElemType Pop(SqStack S)
{
	return *(--S.top);
}
//入栈
void Push(SqStack &S,SElemType e)
{
	if(S.top - S.base>=LIST_INIT_SIZE){
		SElemType *newBase = (SElemType *)realloc(S.base,(S.stacksize+LISTINCREMENT)*sizeof(SElemType));
		S.base = newBase;
		S.top = S.base+S.stacksize;
		S.stacksize+=LISTINCREMENT;
	}
	*S.top++= e;
}

void menu_4()
{
	SqStack S;
	InitStack(S);
	Push(S,2);
	Push(S,3);
	Push(S,4);
	printf("Top :%d\n",GetTop(S));
}

//链队列
typedef struct QNode
{
	SElemType data;
	QNode *next;
}QNode,*QueuePtr;
//队列头和尾指针
typedef struct 
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;
void Pri()
{
	printf("\n");
}
//初始化队列
void InitQueue(LinkQueue &L)
{
	//分配初始化空间
	L.front = L.rear = (QueuePtr)malloc(sizeof(QNode));
	L.front->next = NULL;
}
//入队列
void EnQueue(LinkQueue &L,SElemType e)
{
	QNode *p = (QueuePtr)malloc(sizeof(QNode));//分配空间
	p->data = e;     //获取值
	p->next = NULL;  //后继指向NULL；
	L.rear->next = p;//原队列的队尾节点的后继指向p
	L.rear =p;       //设置新队尾指针
}
//出队列
SElemType DeQueue(LinkQueue L)
{
	SElemType e;         //保留节点数据
	if(L.front != L.rear){
		QNode *p = L.front->next;
		e = p->data;    //保存删除的节点的数据
		L.front->next = p->next;
		if(L.rear == p)//如果只有一个节点，删除之后来年表为空
			L.front = L.rear;

	}
	return e;
}
//显示队列信息
void ShowQueue(LinkQueue L)
{
	if(L.front!=L.rear){      //队列不为空
		QNode *p = L.front->next;  //获取第一个节点
		while(p!=NULL){
			printf("%d ",p->data);
			p = p->next; 
		}
		Pri();
	}else{
		printf("队列为空！\n");
	}
}
//销毁队列,销毁所有已经分配的空间，包括F.front指向的空间
void DestoryQueue(LinkQueue &L)
{
	while(L.front){
		L.rear = L.front->next;//队尾指向第一个元素
		free(L.front);         //释放第一个空间
		L.front = L.rear;      //同时指向第一个元素
	}
}

void menu_5()
{
	LinkQueue L;
	InitQueue(L);
	EnQueue(L,1);
	EnQueue(L,2);
	EnQueue(L,3);
	ShowQueue(L);
	printf("De:%d\n",DeQueue(L));
	ShowQueue(L);
	DestoryQueue(L);
	ShowQueue(L);

}


//线性循环队列
#define MAX_SIZE 100
typedef struct 
{
	SElemType *base;
	int front;
	int rear;
}Queue;

//初始化循环队列
void InitQueue(Queue &Q)
{
	Q.base = (SElemType*)malloc(MAX_SIZE*sizeof(SElemType));
	Q.front = Q.rear = 0;
}
//插入元素
void InsertQueue(Queue &Q,SElemType e)
{
	if((Q.rear+1)%MAX_SIZE == Q.front){
		printf("队列已满!\n");
		exit(0);
	}
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear+1)%MAX_SIZE;
}
//出队列
void DeQueue(Queue &Q)
{
	if(Q.front == Q.rear){
		printf("队列为空!\n");
		exit(0);
	}
	printf("DeQueue %d\n",Q.base[Q.front]);
	Q.front = (Q.front+1)%MAX_SIZE;
}
void menu_6()
{
	Queue Q;
	InitQueue(Q);
	InsertQueue(Q,1);
	InsertQueue(Q,2);
	InsertQueue(Q,3);
	DeQueue(Q);
	DeQueue(Q);
	DeQueue(Q);
}
int _tmain(int argc, _TCHAR* argv[])
{
	cout << PI <<endl;
	menu_1();
	menu_2();
	menu_3();
	menu_4();
	menu_5();
	menu_6();
	return 0;
}