数据结构代码笔记

数据结构

线性结构

链表

带头节点的单链表

定义(初始化一个带头节点的单链表)

typedef struct LNode{	//定义单链表节点类型
	ElemType data;		//每个节点存放一个数据元素
	struct LNode *next;	//指针指向下一个节点
}LNode,*LinkList;	//这里的LNode是结构体的别名，不是结构变量名
					//而LinkLisk是struct LNode * 的别名

//初始化一个单链表（带头结点）
bool InitList(LinkList &L){
    L = (LNode *)malloc(sizeof(LNode));	//分配一个头节点
    if (L == NULL)	//内存不足，分配失败
        return false;
    L->next = NULL;	//头节点之后暂时还没有节点
    return true;
}
//初始化单链表过程
void test(){
    LinkList L;	//声明一个指向单链表的指针
    //初始化一个空表
    InitList(L)
}
//判断单链表是否为孔（带头结点）
bool isEmpty(LinkList L){
    if (L->next == NULL)
        return true;
    else
        return false;
}

单链表的插入删除

按位序插入，带头节点

//在第i个位置插入元素e（带头结点）
bool ListIstert(LinkList &L,int i,ElemType e){
    if (i < 1)	//i不合法
        return false;
    LNode *p;	//定义一个指向当前位置的指针p
    int j = 0;	//当前指针指向的是第几个节点
    p = L;	//让p指向头节点
    while(p != NULL && j < i-1){	//循环找到第i个节点
        p = p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));	//为新节点分配空间
    s->data = e;	//新节点赋值为e
    //插入
    s->next = p->next;	
    p->next = s;
    return true;
}

按位序插入，不带头节点

bool ListInsert(LinkList L,int i,ElemType e){
    if(i<1)	//i不合法
        return false;
    if(i == 1){	//当插入位置是第一个节点之前的时候，需要特殊处理
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        L = s;
        return true;
    }
    //后续正常处理
    LNode *p;	//定义当前指针p
    int j = 1;	//p指向的位置
    p = L;	//p初始指向头指针
    while(p != NULL && j < i-1){	//循环找到第i个位置
        p = p->next;
        j++;
    }
    if(p == NULL){	//i不合法
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));	//为新节点分配空间
    //插入
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

后插

//后插操作：在p节点之后插入元素e,判断是否合法->分配空间->插入
bool InsertNextNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s == NUll){
        return false;
    }
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

前插

//前插操作，在p节点之前插入元素e，需要传入一个头指针L
bool InsertPriorNode(LinkList L,LNode *p,ElemType e){
	if(p == NULL)
        return false;
    //寻找p节点
    LNode *cur;
    
    while(cur != NULL){
        if(cur->next == p){
            break;
        }
        cur = cur->next;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s == NULL)
        return false;
    s->data = e;
    s->next = p;
    cur->next = s;
    return true;
}

//第二种方法
bool InsertPriorNode(LNode *p,ElemType e){
    if(p==NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s == NULL){
        return false;
    }
    //把s插入到p后面，然后交换s和p的data实现前插
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}

删除节点

//删除第i个节点
bool ListDelete(LinkList &L,int i,ElemType &e){
    if(i < 1)
        return false;
    LNode *p;	//定义当前指向的节点p
    int j = 0;	//当前p指向的是第几个节点
    p = L;	//p初始指向头节点
    while(p != Null && j < i-1){	//循环找到第i-1个节点
        p = p->next;
        j++;
    }
    if(p == NULL)
        return false;
    if(p->next == NULL)	//第i-1个节点之后已无其他节点
        return false;
    LNode *q = p->next;	//令q指向被删除的节点
    e = q->data;	//用e返回元素的值
    p->next = q->next;	//将*q节点从链中断开
    free(q);	//释放q的内存空间
    return true;
}

//删除指定节点
bool DeleteNode(LNode *p){
    if(p == NULL)
		return false;
    LNode *q = p->next;
    p->data = p->next->data;
    p->next = q->next;
    free(q);
    return true;
}