带头结点的线性链表代码

//单链表的结点定义
typedef struct Node
{
DataType data;
struct Node *next;
}SLNode;

//初始化ListInitiate(SLNode **head)
void ListInitiate(SLNode **head)
{
*head=(SLNode *)malloc(sizeof(SLNode));
(*head)->next=NULL;
}

//求当前元素个数ListLength(SLNode *head)
int ListLength(SLNode *head)
{
SLNode *p=head;
int size =0;
//循环计数
while(p->next!=NULL)
{
p=p->next;
size++;

}
return size;
}

//插入Insert(SLNode *head,int i,DataType x)
int ListInsert(SLNode *head,int i,DataType x)
{
SLNode *p,*q;
int j;

p=head;
j=-1;
while(p->next!=NULL&&j<i-1)
//最终让指针p指向第i-1个结点
{
p=p->next;
j++;
}

if(j!=i-1)
{
printf("插入元素位置参数错!");
return 0;
}

//生成新结点,并赋值
q=(SLNode *)malloc(sizeof(SLNode));
q->data=x;

//插入步骤
q->next=p->next;
p->next=q;
return 1;
}

//删除ListDelete(SLNode *head,int i,DataType *x)
int ListDelete(SLNode *head,int i,DataType *x)
{
SLNode *p,*s;
int j;
p=head;
j=-1;
while(p->next!=NULL&&p->next->next!=NULL&&j<i-1)
//循环结束时指针p指向第i-1个结点
{
p=p->next;
j++;
}

if(j!=i-1)
{
printf("删除元素位置参数错!");
return 0;
}
s=p->next;
*x=s->data;
p->next=p->next->next;//删除
free(s); //释放指针s所指向结点的内存空间
return 1;
}

//取数据元素ListGet(SLNode *head,int i,DataType *x)
int ListGet(SLNode *head,int i,DataType *x)
{
SLNode *p;
int j;
p=head;
j=-1;
while(p->next!=NULL && j<i)
{
p=p->next;
j++;
}
if(j!=i)
{
printf("取元素位置出错!");
return 0;
}
*x=p->data;
return 1;
}

//撤销单链表Destroy(SLNode **head)
void Destroy(SLNode **head)
{
SLNode *p,*p1;
p=*head;
while(p!=NULL)
{
p1=p;
p=p->next;
free(p1);
}
*head=NULL;
}

时间: 2024-10-14 09:32:54

带头结点的线性链表代码的相关文章

带头结点的单链表操作说明

一.单链表简介 相对于以数组为代表的"顺序表"而言,单链表虽然存储密度比较低(因为数据域才是我们真正需要的,指针域只是用来索引,我们并不真正需要它),但是却具有灵活分配存储空间.方便数据元素的删除.方便元素插入等优点 单链表是线性表链式存储的一种,其储存不连续.单链表的数据结构中包含两个变量:数据和指向下一结点的指针.一个结点只知道下一个结点的地址.一个单链表必须有一个头指针,指向单链表中的第一个结点.否则链表会在内存中丢失. 一般的链表可以不带头结点,头指针直接指向第一个节点,如下图

实际应用中带头节点的线性链表

/*========带头节点的线性链表类型=========*/ typedef char ElemType //结点类型 typedef struct LNode { char data; struct LNode *next; }*Link,*Position; //链表类型 typedef struct { Link head,tail; int len; }LinkList; /*======================================================

对带头结点的单链表的简单操作

#pragma once #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<memory.h> #define DataType int           //int 可以改写为其它数据类型 typedef struct Node { DataType data; struct Node *next; }Node,*pNode;          //定义结点结构体      

03.带头结点的单链表

/** * 带头结点的单链表 */ public class LinkListDemo { public static void main(String[] args){ Node n1 = new Node(1,"A"); Node n2 = new Node(2,"B"); Node n3 = new Node(3,"C"); Node n4 = new Node(4,"D"); // LinkList linkList

链表习题(4)-有一个带头结点的单链表,编写算法使其元素递增有序

1 /*有一个带头结点的单链表,编写算法使其元素递增有序*/ 2 /* 3 算法思想:利用直接插入排序的思想,先构成只含有一个数据结点的有序单链表,然后依次插入 4 剩余结点到合适的位置. 5 */ 6 void Sort(LinkList& L) 7 { 8 LNode *p = L->next, *pre; 9 LNode *r = p->next; 10 p->next = NULL; 11 while (p) 12 { 13 r = p->next; 14 pre

线性表的链式存储结构(带头结点的单链表)

首先,我们定义带头节点的单链表存储结构如下: 1 /* 2 ** 线性表的单链表存储结构定义 */ 3 typedef int ListElemType;//线性表数据元素类型 4 typedef struct tagLNode { 5 ListElemType data; 6 struct tagLNode *next; 7 }LNode, *LinkList; 在此基础上可以执行的基本操作如下: 1 #include "linklist_algo.h" 2 #include <

带头结点的单链表

代码: /* *带头节点的单链表 */ #include<iostream> #include<stdlib.h> using namespace std; typedef struct ListNode { int data; struct ListNode* next; } Node,*PNode; //新建结点,num表示结点个数 PNode NewNode(int num) { //新建头结点 PNode head=(PNode)malloc(sizeof(Node));

建立一个带头结点的单向链表,链表中的各结点按结点数据中的数据递增有序链接,函数fun的功能是:把形参x的值放入一个新结点并插入链表中,使插入后各结点数据域中的数据仍保持递增有序

#include <stdio.h> #include <stdlib.h> #define N 8 typedef struct list { int data; struct list *next; } SLIST; void fun( SLIST *h, int x) { SLIST *p, *q, *s; s=(SLIST *)malloc(sizeof(SLIST)); /**********found**********/ s->data=x;将形参x赋给结点的数

从头到尾反向输出带头结点的单链表的每个节点的值

#include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct LinkList { int data; struct LinkList *next; }NODE; NODE* Create_List() { int n; NODE *p,*r,*L=(NODE*)malloc(sizeof(NODE*)); L->data=0; L->next=NULL; r=L; sca