数据结构X实验一

## 顺序表 ##
/**
 *定义头文件和常量
 **/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define OK   1
#define ERROR  0
#define TRUE 1
#define FALSE 0

/*定义顺序链表数据*/
#define ElemType int
#define MAXSIZE  100   /*此处的宏定义常量表示线性表可能达到的最大长度*/
typedef  struct
{ 
    ElemType  elem[MAXSIZE];  /*线性表占用的数组空间*/
    int       last;    /*记录线性表中最后一个元素在数组elem[ ]中的位置（下标值），空表置为-1*/
}SeqList;

/*查找操作*/
int  Locate(SeqList L, ElemType e)
{   
    int i=0;        /*i为扫描计数器，初值为0，即从第一个元素开始比较*/
    while ((i<=L.last)&&(L.elem[i]!=e))     /*顺序扫描表，直到找到值为key的元素, 或扫描到表尾而没找到*/
        i++; 
    if  (i<=L.last)
        return(i+1);  /*若找到值为e的元素，则返回其序号*/
    else
        return(-1);  /*若没找到，则返回空序号*/
}

/*插入操作*/
/*在顺序表L中第i个数据元素之前插入一个元素e。 插入前表长n=L->last+1，
i的合法取值范围是 1≤i≤L->last+2  */
int  InsList(SeqList *L,int i,ElemType e)
{ 
    int k;
    if(L->last>= MAXSIZE-1)
    {
        printf("表已满无法插入\n");
        return(ERROR);
    }
    if((i<1) || (i>L->last+2)) /*首先判断插入位置是否合法*/
    {
        printf("插入位置i值不合法\n");
        return(ERROR);
    }
    for(k=L->last;k>=i-1;k--)   /*为插入元素而移动位置*/
        L->elem[k+1]=L->elem[k];
    L->elem[i-1]=e;   /*在C语言数组中，第i个元素的下标为i-1*/
    L->last++;
    return(OK);
}

/*删除操作*/
int  DelList(SeqList* L,int i,ElemType *e)
/*在顺序表L中删除第i个数据元素，并用指针参数e返回其值。i的合法取值为1≤i≤L.last+1 */    
{ 
    int k;
    if((i<1)||(i>L->last+1))   
    { 
        printf("删除位置不合法!\n");
        return(ERROR);
    }
    *e = L->elem[i-1];  /* 将删除的元素存放到e所指向的变量中*/
    for(k=i; k<=L->last; k++)
        L->elem[k-1] = L->elem[k];  /*将后面的元素依次前移*/
    L->last--;
    return(OK);
}

/*输出顺序表*/
void show(SeqList *l){
    for(int i=0; i<=l->last; i++)
    {
        printf("%d",l->elem[i]);
        if(i < l->last) printf(" -> "); 
    }
}


/*初始化顺序表*/
void init(SeqList *l){
    printf("请输入你想建立的顺序表的元素，以0结束:\n");
    int r=0;
    int d;
    while(TRUE){
        printf("请输入元素: ");
        scanf("%d",&d);
        if(r >= MAXSIZE){
            printf("顺序表已满!\n");
            break;
        }
        if(d == 0){
            break;
        }else{
            l->elem[r]=d;
            r++;
        }
    }
    l->last = r-1;
    printf("你建立的顺序表为: ");   
    show(l);    
    printf("\n顺序表的长度为: %d\n",l->last+1);
}


/*实现按值查找元素*/
void toLocateByVal(SeqList l){
    int p,q;
    printf("输入你想查找的元素：");
    scanf("%d",&q);
    p=Locate(l,q);
    if(p == -1)
        printf("在此线性表中没有该元素!\n");
    else
        printf("该元素在线性表中的位置为:%d\n",p);
}

/*实现序号查找元素*/
void toLocateByNum(SeqList l){
    int p,e;
    printf("输入你想查找的元素的序号：");
    scanf("%d",&p);

    if(p<1 || p>l.last+1)
        printf("序号已超出线性表的长度\n");
    else
        e = l.elem[p-1];
        printf("你查找的元素为: %d\n",e);
}

/*实现插入*/
void toInsert(SeqList *l){
    printf("请输入要插入的位置:\n");
    int p,e;
    scanf("%d",&p);
    printf("请输入要插入的元素值:\n");
    scanf("%d",&e);
    int status = InsList(l,p,e);
    if(status == OK)
    printf("元素%d插入成功\n",e );
    else printf("元素%d插入失败",e);
}

/*实现删除元素*/
void toDelList(SeqList *l){
    ElemType e;
    int index;
    printf("请输入你想删除的元素序位："); 
    scanf("%d",&index);
    int status = DelList(l,index,&e);
    if(status == OK)
    printf("已删除第%d个元素%d\n",index, e );
    else printf("删除第%d个元素失败");
}

/*操作分支*/
void opSwitch(int op,SeqList* l){
    switch(op){
        case 1:
        // 插入元素
            toInsert(l);
            printf("插入后顺序表为：");show(l); break;
        case 2:
        // 按值查找元素
            toLocateByVal(*l);break;
        case 3:
        // 按序号查找元素
            toLocateByNum(*l);break;
        case 4:
        // 删除元素
            toDelList(l);
            printf("删除后顺序表为：");show(l); break;
        case 9:
        // 输出全部元素
            show(l);break;
        default:
            printf("你的输入有误，请重新选择\n");

    }
}

/*选择操作*/
void oprate(SeqList l){
    int op=TRUE;
    while(op){
        printf("\n\n\n******请输入的选择你的的操作******\n");
        printf("1 插入运算--插入元素\n");
        printf("2 查找运算--按值查找元素\n");
        printf("3 查找运算--按序号查找元素\n");
        printf("4 删除运算--删除元素\n");
        printf("9 输出全部元素\n");
        printf("0 退出程序\n");
        printf("*********************************\n");
        scanf("%d",&op);
        if(op == 0) break;
        opSwitch(op,&l);
    }

}


/*程序主入口*/
int main()
{
    /*定义顺序表*/
    SeqList l;
    /*初始化顺序表*/
    init(&l);
    /*程序选项操作*/
    oprate(l);
    printf("感谢您的使用\n");
    return 0;
}


-------------------------------------------------
## 链表 ##

/**
 *定义头文件和常量
 **/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define OK   1
#define ERROR  0

 //定义链表数据结构
typedef struct node 
{
    int num;
    node *next;
}node;

/*获取链表段的长度*/
int getLength(node *list){
    int length = 0;
    node* temp;
    temp = list;
    while(temp != NULL){
        temp=temp->next;
        length++;
    }
    return length;
}

/*打印链表*/
void printList(node* list)
{
    node *temp;
    temp=list;
    while(temp!=NULL)/*只要是非空表*/
    {
        printf("%d",temp->num);/*输出链表节点的值*/
        if(temp->next != NULL){
            printf("->");
        }
        temp=temp->next;/*跟踪链表增长*/
    }
    printf("\n链表的长度为%d\n",getLength(list));
}


/*初始化链表*/
node* init(node *list)
{
    node *p1,*p2;
//利用malloc()函数向系统申请分配一个节点的内存空间
    p1=p2=(node*)malloc(sizeof(node));
    printf("请输入你想建立的链表的元素，以0结束:\n");
    scanf("%d",&p1->num);                   /*输入节点的值*/
    p1->next=NULL;                          /*将新节点的指针置为空*/
    while(p1->num > 0)                      /*输入节点的数值大于0*/
    {
        if(list==NULL)
            list=p1;                        
        else 
            p2->next=p1;                
        p2=p1;
        p1=(node*)malloc(sizeof(node));/*下一个新节点*/
        scanf("%d",&p1->num);   /*输入节点的值*/
    }
    free(p1);                   //释放  
    p1=NULL;                    //使指向空  
    p2->next = NULL;             
    printf("你建立的链表为:");
    printList(list);            /*打印单链表*/  
    return list;
}


/*按序号定位元素地址*/
node* locate(node *list,int postion){
    int i=0;
    node *element,*temp;
    temp = list;
    // 
    while(temp != NULL) {       
        if ( (postion-1)==i )
        {
            element=temp;
            return element;
        }
        temp=temp->next;
        i++;

    }
    // 如果找不到指定位置元素地址就返回NULL
    return NULL;
}


/*按值定位元素地址*/
int locateByValue(node* list, int value){
    node *element,*temp;
    temp = list;
    int i = 0;
    while(temp->next != NULL) {
        temp=temp->next;
        i++;
        if (value == (temp->num))
        {
            element=temp;
            return i;
        }

    }
    // 如果找不到元素就返回0
    return 0;
}

/*插入元素*/
int insert(node* list, int position){
    if(position > getLength(list) || position < 1) return ERROR;
    node* pre=locate(list,position);
    node* next = pre->next;
    node* temp = NULL;
    if(pre != NULL){
        temp = (node*) malloc(sizeof(node*));
        printf("请输入你要插入的元素");
        scanf("%d",&temp->num);
        pre->next=temp;
        temp->next=next;
        return OK;
    }
    else{
        printf("插入元素失败\n");
    }
    return ERROR;
}

/*移除元素*/
node* del(node *list, int position){
    node* location=locate(list,position);
    node* next = location->next;
    if(location != NULL){
        location->next = next->next;
        free(next);
        next = NULL;
        return location->next;
    }
    else{
        return NULL;
    }
}

/*实现按序号查找*/
void toLocate(node *list){
    printf("请输入你要查询的位置");
    int postion;
    scanf("%d",&postion);
    node *result = locate(list->next,postion);
    if(result == NULL){
        printf("找不到该位置的元素\n");
    }
    else
        printf("位置%d的元素为%d",postion,result->num);
}

/*实现插入元素*/
void toInsert(node *list){
    printf("请输入你要插入的位置");
    int position;
    scanf("%d",&position);
    int result = insert(list,position);
    if(result == ERROR){
        printf("你插入的位置有误\n");
    }else{
        printf("元素插入成功\n");
    }
}

/*实现移除元素*/
void toDel(node *list){
    printf("请输入你要移除的位置");
    int position;
    scanf("%d",&position);
    node* result = del(list,position);
    if(result == NULL){
        printf("你输入的位置有误\n");
    }else{
        printf("元素移除成功！\n");
    }
}

/*实现按值定位元素地址*/
void toLocateByValue(node* list){
    int value;
    printf("请输入你要查询的元素的值：");
    scanf("%d", &value);
    int result = locateByValue(list,value);
    if(result == 0){
        printf("%d元素不在链表中", value);
    }else{
        printf("你查询的元素%d在链表中的位置为%d",value,result);
    }

}


void oprate(node* list){
    int op = 1;
    while(op != 0){
    printf("\n\n*************************\n");
    printf("*************************\n");
    printf("请选择操作选项\n");
    printf("1 插入元素\n");
    printf("2 移除元素\n");
    printf("3 按序号定位元素\n");
    printf("4 按元素值定位元素位置\n");
    printf("5 输出链表\n");
    printf("0 退出程序\n");
    printf("*************************\n");
        scanf("%d",&op); 
    switch(op){
        case 1:
            toInsert(list);break;
        case 2:
            toDel(list);break;
        case 3:
            toLocate(list);break;
        case 4:
            toLocateByValue(list);break;
        case 5:
            printList(list->next);break;
        case 0:
            break;
        default:
            printf("你的选项有误，请重新输入"); 
    }       
    }
}
/*主函数，程序的入口*/
int main( )
{
    node *nodes,List;
    nodes=NULL; 
    nodes=init(nodes);/*初始化单链表节点*/
    List.next=nodes; 
    oprate(&List);
    printf("谢谢您的使用\n");
    return 0;
}