数据结构代码练习05

#include<stdio.h>
#include<stdlib.h>
typedef  int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
/*有头结点单链表初始化*/
/*返回初始化好的单链表*/
LinkList initList()
{
    LNode *L;
    L=(LNode *)malloc(sizeof(LNode));
    if(!L) return NULL;
    L->next=NULL;
    return L;
}
/*在单链表中pos位置插入元素e*/
/*插入成功返回1，不成功返回0*/
int insertList(LinkList head, int pos, ElemType e)
{
    LNode*p=head,*s;
    int j=0;
    while(p&&j<pos-1){/*寻找插入位置*/
        p=p->next;
        if(p==NULL)
            printf("error\n");
        j++;
    }
    if(pos<1)
    {
        printf("error\n");
        return 0;
    }
    if(!p||j>pos-1)return 0;/*若插入的位置不存在，返回失败*/
    s=(LNode*)malloc(sizeof(LNode));/*申请一个新结点储存元素*/
    if(!s)return 0;
    s->data=e;
    s->next=p->next;/*插入结点，修改指针域*/
    p->next=s;
    printf("yes\n");
    return 1;
}
/*依次输出单链表的元素*/
void printList(LinkList head)
{
    LNode *p;
    for(p=head->next;p!=NULL;p=p->next)
        printf("%d ",p->data);
}
int main()
{
    LinkList head;
    ElemType e;
    int i,n,m,pos;
    scanf("%d%d",&n,&m);
    head=initList();
    LNode *p,*p1;
    p=head;
    /*以下创建n个结点的单链表*/
 for(i=1;i<=n;i++){
        p1=(LNode*)malloc(sizeof(LNode));
        scanf("%d",&e);
        p1->data=e;
        p1->next=NULL;
        p->next=p1;
        p=p->next;
    }
    /*以下插入m个数据*/
for(i=1;i<=m;i++){
        scanf("%d",&pos);
        scanf("%d",&e);
        insertList(head,pos,e);
    }
    /*输出全部元素*/
    printList(head);
    return 0;
}
 

#include<stdio.h>
#include<stdlib.h>
 
typedef int ElemType;
/*结构体部分*/
typedef struct Node
{
    ElemType data;   //数值域
    struct Node *next;  //指针域
}Linklist;
 
Linklist *InitList(Linklist *L)    //初始化单链表
{
    L = (Linklist *) malloc(sizeof(Linklist));
    L->next = NULL;
    return L;
}
 
Linklist *CreateList(int n)
{
    /*通过输入n个数据，创建一个单链表*/
    int x,i;
    Linklist *L,*r,*p;
    L = InitList(L); //构造头结点
    r = L;
    printf("input %d value: ",n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&x);
        p = (Linklist *)malloc(sizeof(Linklist));
        p -> data = x;
        p -> next = NULL;
        r->next = p;
        r = r->next;    //指针r始终指向链表中末数据元素所在位置
 
    }
    return L;
}

int InsItem1(Linklist *L,ElemType item,int x) /*给定的序号来插入*/
{
    int i = 1;
    Linklist *p,*t;
    p = L;
    t = (Linklist *)malloc(sizeof(Linklist));
    t ->data = item;
    if(L->next==NULL)
    {   /*若L为空表且要求将新结点插入到第0个位置*/
        if(x==1)
            {
                L->next=t;
                t->next=NULL;
                return 1;
            }
        /*若L为空表且要求将新结点插入到第非0个位置     ，则操作失败*/
        else
        {
            printf("wrong!\n");
            return 0;
        }
    }
    while(p->next!=NULL&&i<x)
    /*查找第i个节点*/
    {
        p = p->next;
        i++;
    }
    if(p->next==NULL&&i<x)
    /*在表中不存在插入位置i ，找不到，则插入操作失败*/
    {
        printf("The node %d is not exist\n",x);
        return 0;
    }
    else
    {
        t->next = p->next;
        p->next = t;
        return 1;
    }
}
 
int InsItem2(Linklist *L,ElemType item,ElemType k) /*插入给定值在链表中的位置*/
{
    Linklist *q,*p,*t;
    t = (Linklist *)malloc(sizeof(Linklist));
    t->data = item;
    if(L->next==NULL)
    {
        printf("The linklist is empty\n");
        return 0;
    }
    else
    {
        q = L;
        p = L->next;
        while(p->next!=NULL)/*查找值为k的结点*/
        {
            if(p->data!=k)
            {
                q = p;
                p = p->next;
            }
            else
                break;
        }
        if(p==NULL)/*如p= =NULL，则没有值为k的结点，插入操作失败*/
        {
            printf("The node %d is not exist\n",k);
            return 0;
        }
        else
        {
            q->next = t;
            t->next = p;
            return 1;
        }
    }
}

int DelItem(Linklist *L,int x)
//在单链表中删除数据元素
{
    int i = 1;
    Linklist *p,*q;
    p = L;
    if(L->next==NULL) /*L为空表，无结点可删除*/
    {
        printf("The linklist is empty!\n");
        return 0;
    }
    while(p->next!=NULL&&i<x)
    {
        p = p->next;
        i++;
    }
    if(p->next==NULL)
        /*若没有第i个结点，则删除操作失败*/
    {
        printf("The node %d is not exist\n",x);
        return 0;
    }
    else
    {
        q = p->next;
        p->next = p->next->next;
        free(q);
        return 1;
    }
 
}

int LocItem(Linklist *L,ElemType x)
//查找给定值的结点位置
{
    Linklist *p,*q,*r;
    int i = 1;
    if(L->next==NULL)
    {
        printf("The linklist is empty\n");
        return 0;
    }
    else
    {
        p = L->next;
        while(p!=NULL)
        {
            if(p->data!=x)
            {
                i++;
                p = p->next;
            }
            else
                break;
        }
        if(p==NULL)
        /*如p= =NULL，则没有值为item的结点，删除操作失败*/
        {
            printf("The node %d is not exist\n",x);
            return 0;
        }
        /*若找到该节点返回该节点的位置*/
        else
            return i;
    }
}

void output(Linklist *L) //输出
{
    Linklist *p;
    p = L->next;
    printf("output element: \n");
    for(;p!=NULL;p=p->next)
    {
        printf(" %d ",p->data);
    }
    printf("\n");
}

int main()
{
    ElemType x = 5;
    Linklist *L;
    L = CreateList(x);
    output(L);
    InsItem1(L,3,2);
    output(L);
    InsItem1(L,3,4);
    output(L);
    DelItem(L,3);
    output(L);
    printf("3的位置是: %d",LocItem(L,3));
}

//
//顺序表递增有序，设计算法在最少时间内查找值为x的元素
//若找到，则将其后继元素位置交换，否则按递增顺序插入顺序表 
void search(Sqlist &L,int x){
	int low=0,high=L.length-1;
	int mid,temp,i;
	while(low<=high){
		mid=(low+high)/2;
		if(L.data[mid]==x)
			break;
		else if(L.data[mid] > x)
			high=mid-1;
		else
			low=mid+1;
	}
	if(L.data[mid]==x&&mid!=L.length-1){
		temp=L.data[mid];
		L.data[mid]=L.data[mid+1];
		L.data[mid+1]=temp;
	}
	if(low>high){
		for(i=L.length-1;i>high;--i)
			L.data[i+1]=L.data[i];
		L.data[i+1]=x;
		L.length++;
	}
} 

//
//找到单链表中值为key的元素，将其与前一个结点位置互换
void fun(LNode *&L,int k){
	LNode *l=L;
	if(l->next->data==k)
		return;
	while(l->next->next)
		if(l->next->next->data!=k)
			l=l->next;
		else
			break;
	if(l->next->next!=NULL){
		LNode *p=l->next;
		LNode *q=p->next;
		p->next=q->next;
		l->next=q;
		q->next=p;
	}
} 

//
//在顺序表中二分查找值为key的元素 
//法一，递归
int bi(Sqlist L,int key,int low,int high){
	if(low>high)
		return -1;
	int mid=(low+high)/2;
	if(L.data[mid] < key)
		bi(L,key,mid+1,high);
	else if(L.data[mid]>key)
		bi(L,key,low,mid-1);
	else
		return mid+1;
} 
//法二 
int binsearch(Sqlist L,int key){
	int low=0,high=L.length-1,mid;
	while(low<=high){
		mid=(low+high)/2;
		if(L.data[mid]==key)
			return mid+1;
		else if(L.data[mid]<key)
			low=mid+1;
		else
			high=mid-1;
	}
	return -1;
}

//
//判断给定二叉树是否是二叉排序树
int pre=-INT_MAX;
int JudgeBST(BTNode *root){
	if(root==NULL)
		return 1;
	int a=JudgeBST(root->lchild);
	if(root->data <= pre||a==0)
		return 0;
	else
		pre=root->data;
	int b=JudgeBST(root->rchild);
	return b; 
} 

//
//寻找二叉排序树中最大值和最小值
BiTree Min(BTNode *bt){
	while(bt->lchild!=NULL)
		bt=bt->lchild;
	return bt;
} 
BiTree Max(BTNode *bt){
	while(bt->rchild!=NULL)
		bt=bt->rchild;
	return bt;
} 

//
//设求出指定结点在给定二叉树的层次
int level(BTNode *bt,char k){
	int n=1;
	BTNode *t=bt;
	if(bt!=NULL){
		while(t->data!=k){
			if(t->data<k)
				t=t->rchild;
			else
				t=t->lchild;
			++n;
		}
	}
	return n;
} 

//
//输出二叉搜索树所有值大于key的结点
void fun(BTNode *T,char key){
	if(T!=NULL){
		if(T->lchild!=NULL)
			fun(T->lchild,key);
		if(T->data >= key)
			printf("%d",T->data) ;
		if(T->rchild!=NULL)
			fun(T->rchild,key);
	}
}

//
//判断一个二叉树是否为平衡二叉树
void fun(BTNode *bt,int &balance,int &h){
	int bl=0,br=0,h1=0,hr=0;
	if(bt==NULL){
		h=0;
		balance=1;
	}
	else if(!bt->lchild&&!bt->rchild){
		h=1;
		balance=1;
	}
	else{
		fun(bt->lchild,b1,h1);
		fun(bt->rchild,br,hr);
		h=(hl>hr?hl:hr)+1;
		if(abs(hl-hr)<2)
			balance=bl&&br;
		else
			balance=0;
	}
} 


//关键路径算法实现 
Status TopologicalSort(GraphAdjList GL){
    EdgeNode* e;
    int i, k, gettop;
    int top = 0;         // 用于栈指针下标
    int count = 0;       // 用于统计输出顶点个数
    int* stack;          // 建栈将入度为0的顶点入栈
    stack = (int*)malloc(GL->numVertexes * sizeof(int));
    for (i = 0; i < GL->numVertexes; i++)
        if (0 == GL->adjList[i].in)
            stack[++top] = i;
    int top2 = 0;            // 初始化为0
    int* etv=(int*)malloc(GL->numVertexes * sizeof(int));  // 事件最早发生时间
    for (i = 0; i < GL->numVertexes; i++)  // 初始化为0
        etv[i] = 0;
    int* stack2 = (int*)malloc(GL->numVertexes * sizeof(int));  // 初始化
    while (top != 0) {
        gettop = stack[top--];
        count++;
        stack2[++top2] = gettop;   // 将弹出的顶点序号压入拓扑排序的栈
        for (e = GL->adjList[gettop].firstedge; e; e = e->next) {
            k = e->adjvex;
            if (!(--GL->adjList[k].in))
                stack[++top] = k;
            if ((etv[gettop] + e->weight) > etv[k])  // 求各顶点事件最早发生时间值
                etv[k] = etv[gettop] + e->weight;
        }
    }
    if (count < GL->numVertexes)
        return ERROR;
    else
        return OK;
}