数据结构复习0---线性表

1.数组实现线性表

/*数组实现线性表*/

/*对于线性结构，有12种基本的操作，分别是：初始化、删除、清空、判断是否为空、
遍历、求表的长度、求某个元素在表中的位置、返回特定序号的元素、求某个元素的前一个元素、
求某个元素的后一个元素、插入一个元素、删除一个元素*/ 

#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct arraylist{ 
    ElemType *Array;//实际存放元素的数组
    int length;    //数组中已经使用了多少元素
    int size;   //数组的容量
}arrayList;

//初始化顺序表：给出初始化长度
bool initialArray(arrayList *arrLst,int len){
    arrLst->length = 0;
    arrLst->size = len;    
    arrLst->Array = (ElemType*)malloc(len*sizeof(ElemType));
    if(NULL == arrLst->Array)
        return false;
    else
        return true;  
}

//删除顺序表
void deleteArray(arrayList *arrLst){
    arrLst->length = 0;
    arrLst->size = 0;
    free(arrLst->Array);
    arrLst->Array = NULL;
}

//清空顺序表
void clearArray(arrayList *arrLst){
    arrLst->length = 0;
}

//判断是否为空
bool is_empty(arrayList *arrLst){
    if(0 == arrLst->length){
        printf("the arrayList is empty!
");
        return true;
    }
    else
    {
        printf("the arrayList is not empty!
");
        return false;        
    }
}

//求有多少个元素
int arrayLength(arrayList *arrLst){
    return arrLst->length;
}

//取出某个元素
bool getElem(arrayList *arrLst,int index,ElemType *e){
    if(index < 0 || index > arrayLength(arrLst)-1)
        return false;
    else
    {
        *e = arrLst->Array[index];
        return true;
    }

}

//遍历顺序表，并打印
void printArray(arrayList *arrLst)
{
    printf("array elements are: ");
    for(int i = 0; i < arrayLength(arrLst);++i)
    {
        printf("%d	",arrLst->Array[i]);
    }
    printf("
");
}

//判断某个元素的位置
int locateElem(arrayList *arrLst,ElemType e)
{
    for(int i = 0; i < arrayLength(arrLst);++i)
    {
        if(e == arrLst->Array[i])
            return i;
    }
    return -1;

}

//求某个元素的前驱：如果没找到返回-2；如果是第一个元素。返回-1；否则返回前驱元素的下标
int preElement(arrayList *arrLst,ElemType e,ElemType *preElem)
{
    for(int i = 0 ; i < arrayLength(arrLst); ++i)
    {
        //如果找到了
        if(e == arrLst->Array[i])
        {
            //如果是第一个元素
            if(0 == i)
            {
                return -1;
            }
            else
            {
                *preElem = arrLst->Array[i-1];
                return i-1;
            }
        }
    }
    return -2;
}

//求某个元素的后继：如果没找到，返回-2,如果是最后一个元素，返回-1；否则返回后继元素的下标
int nextElement(arrayList *arrLst,ElemType e,ElemType *nxtElem)
{
    for(int i = 0; i < arrayLength(arrLst); ++i)
    {
        if(e == arrLst->Array[i])
        {
            if(arrayLength(arrLst) -1 == i)
            {
                return -1;
            }
            else
            {
                *nxtElem = arrLst->Array[i+1];
                return i+1;
            }
        }
    }
    return -2;
}

//将元素插入到指定位置
bool insertElem(arrayList *arrLst,int index ,ElemType e )
{
    //先判断插入位置是否合法
    if(0 > index ||  arrayLength(arrLst) < index)
        return false;

    //如果顺序表存储空间已满，则需要重新分配内存
    if(arrLst->length == arrLst->size)
    {
        arrLst->Array = (ElemType*)realloc(arrLst->Array,2*arrLst->size*sizeof(ElemType));
        if(NULL == arrLst->Array)
            //分配失败，程序退出
            return false;
        else
            //分配成功，扩容
            arrLst->size *= 2;
    }
    //将插入点之后的元素后移
    for(int i = arrayLength(arrLst); i > index; --i)
        arrLst->Array[i] = arrLst->Array[i-1];
    //插入元素
    arrLst->Array[index] = e;
    //顺序表长度自增
    ++arrLst->length;
    return true;
}

bool deleteElem(arrayList *arrLst,int index ,ElemType *e)
{
    if(index < 0 || index > arrayLength(arrLst)-1)
        return false;
    *e = arrLst->Array[index];
    //将删除点的元素依次左移
    for(int i = index; i < arrayLength(arrLst);++i)
    {
        arrLst->Array[i] = arrLst->Array[i+1];
    }
    --arrLst->length;;
    return true;
}

2.链表实现线性表

/* 链表实现线性表 */ 

#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode{
    //存放的数据
    ElemType data;
    //指向下个节点的指针
    LNode *next;
}LNode,*LinkList;

//初始化链表
bool initList(LinkList *lst){
    *lst = (LinkList)malloc(sizeof(LNode));
    if(NULL == lst)
        return false;
    (*lst)->next = NULL;
    return true;
}

//删除链表
void deleteList(LinkList *lst)
{
    LinkList p = (*lst)->next;
    LinkList q;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    free(*lst);
    *lst = NULL;
}

//清空链表
void clearList(LinkList *lst)
{
    LinkList p = (*lst)->next;
    LinkList q;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;        
    }
    (*lst)->next = NULL;
}

//判断链表是否为空
bool is_empty(LinkList *lst)
{
    if(NULL == (*lst)->next)
    {
        printf("the list is empty! 
");
        return true;
    }
    else
    {
        printf("the list is not empty! 
");
        return false;
    }
}

//遍历链表并打印
void printList(LinkList *lst){
    printf("list elements are: ");
    LinkList p = (*lst)->next;
    while(p){
        printf("%d",p->data);
        p = p->next;
    }
    printf("
");
}

//计算链表中的元素个数
int listLength(LinkList *lst){
    int cnt = 0;
    LinkList p = (*lst)->next;
    while(p)
    {
        ++cnt;
        p = p->next;
    }
    return cnt;
}

//在指定位置插入元素
bool insertElem(LinkList *lst,int index,ElemType *e){
    int cnt = 0;
    LinkList p = (*lst);
    LinkList q = (LinkList)malloc(sizeof(LNode));
    while(p)
    {
        if(index == cnt)
        {
            //新插入节点的指针指向当前节点的指针指向的元素
            q->next = p->next;
            //当前节点的指针指向新插入的节点
            p->next = q;
            //存入数据
            q->data = *e;
            return true;
        }
        ++cnt;
        p = p->next;
    }
    return false;
}

//删除某个位置的元素
bool deleteElem(LinkList *lst,int index,ElemType *e)
{
    int cnt = 0;
    LinkList p = (*lst)->next;
    //存储当前节点的前一个节点
    LinkList q = *lst;
    while(p)
    {
        
        if(index == cnt)
        {
            //获取即将删除的节点的元素
            *e = p->data;
            //当前节点的前一个节点指向当前节点的后一个节点
            q->next = p->next;
            //释放当前节点
            free(p);
            break;
        }
        p = p->next;
        q = q->next;
        ++cnt;
    }
    return false;
}

//获取某个元素的位置
int locateElem(LinkList *lst,ElemType e)
{
    int index = 0;
    LinkList p = (*lst)->next;
    while(p)
    {
        if(e == p->data)
            return index;

        ++index;
        p = p->next;
    }
    return -1;
}

//获取某个位置的元素
bool getElem(LinkList *lst,int index,ElemType *e)
{
    int cnt = 0;
    LinkList p = (*lst)->next;
    while(p)
    {
        if(index == cnt)
        {
            *e = p->data;
            return true;
        }
        ++cnt;
        p = p->next;
    }
    return false;
}


//获取下一个元素
bool nextElem(LinkList *lst,ElemType curr,ElemType *nxt){
    LinkList p = (*lst)->next;
    while(p){
        if(curr == p->data)
        {
            *nxt = p->next->data;
            return true;
        }
        p = p->next;
    }
    return false;
}

//获取前一个元素
bool priorElem(LinkList *lst,ElemType curr,ElemType *pre)
{
    LinkList p = (*lst)->next;
    LinkList q = (*lst);
    while(p)
    {
        if(curr == p->data)
        {
            *pre = q->data;
            return true;
        }
        q = q->next;
        p = p->next;
    }
    return false;
}

void inputList(LinkList *lst,int n,int* arr)
{
    for(int i = n-1; i >= 0; --i)
    {
        LinkList pnew = (LinkList)malloc(sizeof(LNode));
        pnew->data = arr[i];
        pnew->next = (*lst)->next;
        (*lst)->next = pnew;
    }
}

3.双向链表

/*双向链表*/

#include <stdio.h>
#include <malloc.h>
#define ElemType int 
typedef struct DNode
{
    ElemType data;
    DNode *next;
    DNode *prior;
}DNode,*DLinkList;

bool initDList(DLinkList* dlst){
    *dlst = (DLinkList)malloc(sizeof(DNode));
    if(*dlst == NULL)
        return false;
    (*dlst)->next = NULL;
    (*dlst)->prior = NULL;
    return true;
}

void deleteDList(DLinkList* dlst){
    DLinkList p = (*dlst)->next;
    DLinkList q;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    free(*dlst);
    *dlst = NULL;
}

bool insertElem(DLinkList* dlst,int index,ElemType e)
{
    int cnt = 0;
    DLinkList p = *dlst;
    while(p)
    {
        if(index == cnt)
        {
            DLinkList pnew = (DLinkList)malloc(sizeof(DNode));
            pnew->data = e;
            pnew->next = p->next;
            pnew->prior = p;
            p->next = pnew ;
            //注意：当第一次插入元素或者在最后一个位置插入元素时，p->next是空的，并没有节点            
            if(pnew->next!=NULL)
                pnew->next->prior = pnew;                    
            return true;
        }
        p = p->next;
        ++cnt;
    }
    return false;

}

void deleteElem(DLinkList* dlst,int index,ElemType *e){
    int cnt = 0;
    DLinkList p = (*dlst)->next;
    while(p)
    {
        if(index == cnt)
        {
            *e = p->data;
            p->prior->next = p->next;
            //如果删除的是链表末尾的元素，则不需要这个步骤
            if(p->next != NULL)
                p->next->prior = p->prior;
            
            free(p);            
            break;
        }
        ++cnt;
        p = p->next;
    } 
}

void printList(DLinkList* dlst){
    printf("elements are: ");
    DLinkList p = (*dlst)->next;
    while(p)
    {
        printf("%d	",p->data);
        p = p->next;
    }
    printf("
");
}

 

4.静态链表

/*静态链表 */

#include <stdio.h>
#define N 100
typedef struct{
    char data;
    int  cur;//游标域或者指针域
}SList;

void init_sl(SList slist[]){//初始化成空闲静态链表，
    int i;
    for(i=0;i<N-1;i++)
    {
        slist[i].cur=i+1;
    }
    slist[N-1].cur=0;    //最后一个指针域指向0
}

int malloc_sl(SList slist[]){//分配空闲节点
    int i=slist[0].cur;//总是取头结点之后的第一个空闲结点做分配，同时空闲链表非空，头结点做调整
    if (i)
    {
        slist[0].cur=slist[i].cur;//空闲链表头结点调整指针域
    }
    return i;//返回申请到的空闲节点的数组下标
}


void free_sl(SList slist[],int k){//将k节点回收
    slist[k].cur=slist[0].cur;//总是将回收的节点放在头结点之后
    slist[0].cur=k;
}


int difference_sl(SList slist[],int n){
    int i,m,q,p;
    char tmp[2];//为避免出现scanf输入字符出现接受回车符，则采用输入字符串的形式
    int start,end;//start是哨兵，end指向最后的节点
    init_sl(slist);//初始化 
    start=malloc_sl(slist);//从空闲链表中取出第一个空闲节点生成链表的头结点
    //注意区分，现在是有一个空闲链表是slist，里面都是空闲节点，每次申请malloc_sl和free_sl都是操作的是slist
    //然后非空静态链表，即集合A的链表是由start这个下标指引一直向后走，end指向非空链表的尾节点，
    //而且你发现start基本上都是1，因为开始的时候slist都是空闲节点，而分配又都是从头结点slist[0]之后的第一个
    //节点，即slist[1]开始分配，所以start=1
    end=start;
    while (n--){
        scanf("%s",tmp);
        i=malloc_sl(slist);
        slist[i].data=tmp[0];
        slist[end].cur=i;
        end=i;//end指针后移
    }
    slist[end].cur=0;//这个勿忘!尾节点的指针为空
    //至此A集合输入完毕，然后处理B集合
    scanf("%d",&m);
    while (m--)
    {
        scanf("%s",tmp);
        //从A集合中扫描，如果A中存在tmp，则在A中删除(free_sl)，即A-B，如果没有则添加入A，即B-A
        q=start;//q是p的前驱
        p=slist[start].cur;
        while (p!=slist[end].cur&&slist[p].data!=tmp[0])
        {
            q=p;
            p=slist[p].cur;
        }
        if (p!=slist[end].cur)//说明在A中找到了tmp，则删除
        {
            slist[q].cur=slist[p].cur;//跨过p节点
            free_sl(slist,p);
            if (end==p)
            {
                end=q;//如果删除的是尾节点，则修改尾节点指针
            }
        }else{
            i=malloc_sl(slist);
            slist[i].data=tmp[0];
            slist[i].cur=slist[end].cur;
            slist[end].cur=i;//插在end后，end位置不变，因为end是标志集合A的结束，但是这里你也可以变化end指针，就是加上end=i即可
        }
    }
    return start;
}


void print_sl(SList slist[],int start){
    int p=slist[start].cur;
    while (p)
    {
        printf("%c ",slist[p].data);
        p=slist[p].cur;
    }
    printf("
");
}


int main(){
    int n,start;
    SList slist[N];
    freopen("1.txt","r",stdin);
    //该程序是求(A-B)U(B-A)集合运算
    while (scanf("%d",&n)==1)
    {
        start=difference_sl(slist,n);
        print_sl(slist,start);
    }
    fclose(stdin);
    return 0;
}

5.约瑟夫环

http://poj.org/problem?id=1012