数据结构实验 —— 线性表

#include<iostream>
#include<stdio.h>
#include<stdlib.h>

//线性表动态 分配顺序存储结构

#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量

#define LISTINCREMENT 10//线性表存储空间的线性增量

#define ERROR -1 //定义错误 ERROR
#define OK 1

typedef int Status;//状态码
typedef int ElemType;//声明 元素类型

//---------------------创造一个线性表结构体
typedef struct{
    ElemType *elem;//存储空间 基址   -----> 一个指向元素类型的指针
    int length;//当前的长度
    int listsize;//当前分配的存储容量【以sizeof(ElemType) 即存储 单位 元素的 内存大小 为单位】
}SqList;

//初始化 结构体
Status InitList_Sq(SqList *L){
    //指向线性表的指针L，对L中的 基地址分配存储空间
    L->elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    //根据创建失败返回0来判定是否申请内存成功
    if(!L->elem)
        return ERROR;
    //申请内存成功，定义空表的长度为0，定义初始存储容量
    int i =0;
    printf("请输入顺序表元素个数:");
    scanf("%d",&i);
    for(int j =0;j<i;j++){
        int x;
        printf("请输入元素:");
        scanf("%d",&x);
        L->elem[j] = x;
        printf("\n");
    }
    L->length = i; //长度为i
    L->listsize = LIST_INIT_SIZE;//初始的存储容量
    printf("线性表初始化成功...\n");
    return OK;
}
//打印结构体
void print(SqList *L){
    printf("打印线性表：");
    int i;
    for(i = 0;i < L->length;i++){
        printf("%d ",L->elem[i]);
    }
    printf("\n");
}

//插入结构体
Status ListInsert_Sq(SqList *L,int i,ElemType e){
    if(i < 1 || i > L->length + 1){
        printf("\n插入位置错误\n");
        return ERROR;
    }
        //i 值 不合法
    if(L->length >= L->listsize){
        ElemType *newbase = (ElemType *)realloc(L->elem,(L->listsize + LISTINCREMENT)*sizeof(ElemType));
        if(!newbase)
            return ERROR;
        L->elem = newbase;
        L->listsize += LISTINCREMENT;
    }
    ElemType *q = &(L->elem[i-1]);
    for(ElemType *p = &(L->elem[L->length - 1]);p >= q;--p)
        *(p+1) = *p;
    *q = e;
    ++L->length;
    return OK;

}
//查找线性表   按【值】查找，返回位置
 int findR(SqList *L,int re){
    for(int i = 0 ;i < L->length;i++){
        if(L->elem[i]  == re){
             printf("\n该元素位于第%d个\n",i+1);
             return i;
        }

    }
    printf("\n 没有发现%d\n",re);
    return ERROR;
 }

//查找线性表  按【位置】查找，返回值
ElemType getElem(SqList *L,int i){
    if(i >L->length || i < 1){
        printf("\n位置错误\n");
        return ERROR;
    }
    printf("\n 该位置值为%d\n",L->elem[i-1]);
    return OK;
}


//删除线性表  按【位置】删除
Status deleteP(SqList *L,int i){
    if(i >L->length || i < 1){
        printf("\n位置错误\n");
        return ERROR;
    }
    --i;
    int k;
    //将后面的元素依次 向前移动
    for(k = i;k < L->length;k++){
        L->elem[k] = L->elem[k+1];
    }
    --L->length;
    return OK;

}


//升序排序
Status orderOn(SqList *L){
    for(int k = 0;k < L->length-1;k++){
        for(int i = 0;i < L->length - 1 - k;i++){
            if(L->elem[i+1] < L->elem[i]){
                int temp = L->elem[i+1];
                L->elem[i+1] = L->elem[i];
                L->elem[i] = temp;
            }
        }
    }
}
//降序排序
Status orderUp(SqList *L){
    for(int k = 0;k < L->length-1;k++){
        for(int i = 0;i < L->length - 1 - k;i++){
            if(L->elem[i+1] > L->elem[i]){
                int temp = L->elem[i+1];
                L->elem[i+1] = L->elem[i];
                L->elem[i] = temp;
            }
        }
    }
}


//两个线性表的合并
Status hebin(SqList *L1,SqList *L2,SqList *L){
    int i = 0,j = 0,k=0;
    int ss = 0;//如果有相同的，则计数，在最后减去此长度
    while(i< L1->length && j < L2->length){
        if(L1->elem[i] < L2->elem[j]){
            L->elem[k] = L1->elem[i];
            ++i;
            ++k;
        }else if (L1->elem[i] > L2->elem[j]){
             L->elem[k] = L2->elem[j];
            ++j;
            ++k;
        }else{
            L->elem[k] = L1->elem[i];
            ++i;
            ++j;
            ++k;
            ss++;
        }
    }

    while(i <= L1->length - 1){
        L->elem[k] = L1->elem[i];
        ++i;
        ++k;
    }
    while(j <= L2->length -1){
        L->elem[k] = L2->elem[j];
        ++j;
        ++k;
    }
    if(ss)
        L->length = L1->length + L2->length - ss;
    else
        L->length = L1->length + L2->length;
    print(L);
    return OK;
}
int main()
{
    SqList L;
    int xuanze;
    while(1){
     printf("\n*************\n1.初始化线性表\n2.打印线性表\n3.插入线性表\n4.按值查找线性表\n5.按位置查找\n6.按位置删除\n7.升序\n8.降序\n9.合并\n输入0结束程序\n*************\n请输入选择：");
     scanf("%d",&xuanze);
     switch (xuanze){
                case 1:
                    InitList_Sq(&L);
                    break;
                case 2:
                    print(&L);
                    break;
                case 3:
                    int x1,x2;
                    printf("\n请输入在第几个元素位置插入:");
                    scanf("%d",&x1);
                    printf("\n请输入要插入的元素:");
                    scanf("%d",&x2);
                    ListInsert_Sq(&L,x1,x2);
                    break;

                case 4:
                    int y1;
                    printf("\n请输入要查找的值:");
                    scanf("%d",&y1);
                    findR(&L,y1);
                    break;
                case 5:
                    int y3;
                    printf("请输入要查找的位置【第n个】：");
                    scanf("%d",&y3);
                    getElem(&L,y3);
                    break;
                case 6:
                    int y4;
                    printf("请输入要删除的位置【第n个】：");
                    scanf("%d",&y4);
                    deleteP(&L,y4);
                    break;
                case 7:
                    orderOn(&L);
                    break;
                case 8:
                    orderUp(&L);
                    break;
                case 9:
                    SqList L1;
                    SqList L2;
                    printf("\n初始化 线性表1：\n");
                    InitList_Sq(&L1);
                    printf("\n初始化 线性表2：\n");
                    InitList_Sq(&L2);
                    hebin(&L1,&L2,&L);
                    break;
                case 0:
                    exit(0);
                default:
                    printf("");
        }
   }
    return 0;
}

#include<stdio.h>
#include<stdlib.h>

#define ERROR -1
#define OK 1

typedef int Status;
typedef int ElemType;

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode;

//头插入法建立单链表，头结点head 作为返回值
LNode *create_LinkList(void){
    int data;
    LNode *head,*p;
    head = (LNode *)malloc(sizeof(LNode));  //创建头结点
    head->next = NULL;
    while(1){
        printf("请输入结点数值（输入32767结束添加）：");
        scanf("%d",&data);
        if(data == 32767)
            break;
        p = (LNode *)malloc(sizeof(LNode)); //不断创建新的结点
        p->data = data;
        p->next = head->next;
        head->next=p;

    }
    return head;
}

//尾插入法建立链表   链表的头结点head作为返回值
LNode  *create_LinkListWEI(void)
{
    int data;
    LNode *head, *p, *q;
    head=p=(LNode  *)malloc(sizeof(LNode));
    p->next = NULL;
    while (1)
    {
        printf("请输入结点数值（输入32767结束添加）：");
        scanf("%d",&data);
        if (data == 32767)
            break;
        q = (LNode  *)malloc(sizeof(LNode));
        q->data = data;
        q->next = NULL;
        p->next = q;
        p = q;
    }
    return head;
}






//打印单链表
void print(LNode *head){
    LNode *p = head;
    printf("单链表：");
    while(p->next){
        printf("%d ",p->next->data);
        p = p->next;
    }
    printf("\n");

}
//返回结点数
int getJieD(LNode *head){
    LNode *p = head;
    int c =0;
    while(p->next){
        c++;
        p = p->next;
    }
    return c;
}
//按值查找,返回节点序号【第几个结点】
int findByValue(LNode *head,ElemType e){
    LNode *p = head;
    int i = 0;
    while(p->next){
        if(p->next->data == e){
            return i;
        }
        i++;
        p = p->next;
    }
    return ERROR;

}
//按位置返回结点值
int findByWeiZhi(LNode *head,int w){
    LNode *p = head;
    int i21 = 0;
    while(p->next){
        if(i21 == w){
            return p->next->data;
        }
        i21++;
        p = p->next;
    }
    return ERROR;
}
//按值删除结点
void deleteByValue(LNode *L,int key){
    LNode *p = L,  *q = L->next;
    while  ( q->next != NULL && q->data != key){
        p=q;
        q=q->next;
    }
    if  (q->data == key){
        p->next = q->next;
        free(q);
    }else if(q->next == NULL){
        printf("所要删除的结点不存在!\n");

    }



}
//按位置删除结点【第i个】
Status deleteByW(LNode *head,int key){
    LNode *p = head,*q = head->next;
    int i = 0;
    while(q->next != NULL){
        if( i == key-1){
            p->next = q->next;
            free(q);
            return OK;
        }else{
            p = q;
            q = q->next;
        }
        i++;
    }
    i++;
    //尾部 情况删除
    if(i == key){
        //printf("delete last one int ... \n");
        p->next = NULL;
        free(q);
        return OK;
    }else{
        printf("位置错误！\n");
        return ERROR;
    }
}
//在第i个位置后插入值
Status addInToi(LNode *head,int i,int e){
    LNode *p,*q;
    p = head;
    q = head->next;
    if( getJieD(head) < i){
        printf("位置错误！\n");
        return ERROR;
    }
    int a = 0;
    while(q != NULL){
        if(a == i)
            break;
        p = q;
        q = q->next;
        a++;
    }
    LNode *r;
    r = (LNode *)malloc(sizeof(LNode));
    p->next = r;
    r->data = e;
    r->next = q;
}
//合并
LNode *heBin(LNode *La, LNode *Lb){
    LNode *Lc,  *pa ,  *pb ,  *pc, *ptr ;
    Lc=La;
    pc=La;
    pa=La->next;
    pb=Lb->next;
    while (pa!=NULL    && pb!=NULL){
        if  (pa->data < pb->data){
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
/*  将pa所指的结点合并，pa指向下一个结点  */
        if  (pa->data>pb->data){
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
/*  将pa所指的结点合并，pa指向下一个结点  */
        if  (pa->data==pb->data){
            pc->next=pa;
            pc=pa;
            pa=pa->next;
            pb=pb->next;
        }
/*  将pa所指的结点合并，pb所指结点删除  */
    }
    if (pa!=NULL)
        pc->next=pa;
    else
        pc->next=pb;     /*将剩余的结点链上*/
    return(Lc);
}






int main(){
    int xuanze;
    LNode *p;
    LNode *a,*b;
    int c;
    int nn;
    int ii;
    int i2,i3;
    while(true){
        printf("\n***************\n");
        printf("1.头插入法初始化链表\n");
        printf("2.尾插入法初始化链表\n");
        printf("3.打印链表\n");
        printf("4.得到链表的结点数\n");
        printf("5.按值查找结点\n");
        printf("6.按位置查找结点【返回第i个结点数值】\n");
        printf("7.按值删除节点\n");
        printf("8.删除第i个位置的结点\n");
        printf("9.在第i个位置插入新的结点\n");
        printf("10.合并\n");
        printf("\n");
        printf("***************\n");
        printf("请输入选项：");
        scanf("%d",&xuanze);

        switch(xuanze){
        case 1:
            p = create_LinkList();
            break;
        case 2:
            p = create_LinkListWEI();
            break;
        case 3:
            print(p);
            break;
        case 4:
            c = getJieD(p);
            print(p);
            printf("结点数：%d\n",c);
            break;
        case 5:
            printf("请输入要查找的数值：");
            scanf("%d",&nn);
            print(p);
            ii = findByValue(p,nn);
            if(ii == -1)
                printf("没有该结点\n");
            else
                printf("该结点在第%d个位置\n",ii +1);
            break;

        case 6:
            printf("请输入位置【第i个】：");
            scanf("%d",&nn);
            print(p);
            i2 = findByWeiZhi(p,nn-1);
            if(i2 == -1)
                printf("位置错误\n");
            else
                printf("该结点的数值是：%d\n",i2);
            break;
        case 7:
            printf("请输入要删除的值【将删除第一个与之相同的结点】:");
            scanf("%d",&nn);
            deleteByValue(p,nn);
            print(p);
            break;
        case 8:
            printf("请输入要删除的地址【将删除第i个位置的结点】：");
            scanf("%d",&nn);
            deleteByW(p,nn);
            print(p);
            break;
        case 9:
            printf("请输入要插入的位置【第i个结点之后】：");
            scanf("%d",&ii);
            printf("请输入要插入结点的值：");
            scanf("%d",&nn);
            addInToi(p,ii,nn);
            print(p);
            break;
        case 10:
            printf("尾插入法初始化第一个链表\n");
            a =  create_LinkListWEI();
            printf("尾插入法初始化第二个链表\n");
            b =  create_LinkListWEI();
            printf("合并\n");
            p = heBin(a,b);
            printf("合并完成的链表:");
            print(p);
            printf("\n");
            break;
        }

    }
    return 0;
}