链表算法

㈠ 链表排序的算法

我看过了程序，觉得思想应该是这样的，9次遍历该链表。每次找出一个MAX，并将他赋给一个新的结点，同时删除原链表中这个最大值。
最后将这些新的接点组成一个链表，就是排好序的。
现在来看看程序中的错误，主要是在排序中：
⒈while条件错误，假如是temp!=NULL,想一想遍历到链表最一个值，这时temp不为NULL，而temp->next为NULL，while循环中用到了这个，所以程序崩溃。修改方法：该while条件，或是改循环中的temp->next。
⒉swaptemp->next=swaptemp->next->next;错误,会使程序崩溃，理由同上，应该是swaptemp->data=max;swaptemp=swaptemp->next;
⒊对max的处理应该放在while循环外面，这样才能对最大的max处理。
程序看上去比较得乱，也就没有调试，说了这么多你应该能自己调试成功吧。再说一下，尽量不要让程序有警告，有时警告也会让你的程序无法正常运行！

㈡ 单链表的元素插入算法

#include <stdlib.h>#include<stdio.h>typedef struct LNode{
int data;
LNode *next;
}*List,LNode;void Creat(List &L,int n){//创建链表
List p;//用于循环创建的节点
L=(List)malloc(sizeof(struct LNode));
L->next=NULL;
for(int i=1;i<=n;i++){
p=(List)malloc(sizeof(struct LNode));
scanf("%d",&p->data);
p->next =L->next;
L->next=p;
}
}//创建成功void Print(List L3){
L3=L3->next;
while(L3){
printf("%d",L3->data);
L3=L3->next;
}
}void Insert(List &L,int i,int e){//在第i个位置之前插入e
List p,s;
p=L;
int j=0; while(p&&j<=i-1){
if(j==i-1){
s=(List)malloc(sizeof(struct LNode));
s->data=e;
s->next=p->next;
p->next=s;
}
j++;
p=p->next;
}
}

int main(){ List L;
int n,i,e;
scanf("%d,%d,%d",&n,&i,&e);
Creat(L,n);
Insert(L,i,e);
Print(L); return 0;
}1

㈢ 建立一个单链表，并求其长度的算法描述

int Length(PLNode head)/*求长度*/
{
int n=0;
PLNode p;
p=head->next;
while(p)
{
n++;
p=p->next;
}

从头节点开始，遍历链表，如果未到链表末尾，则长度加一，如此反复，知道链表结尾

㈣ 链表算法题

因为我是学习计算机软件专业的，故我可以很负责地告诉你，你的这个大作业肯定是不会有人满足你的。因为从编程的角度上讲，使用任何一种语言编写带有一定复杂功能的任何程序，实际本质上都是一项艰苦的脑力劳动。
首先暂且不谈到底是 C++ 语言、还是 JAVA 语言？因为该问题已经不仅仅是涉及到到底是使用哪一种具体的编程语言来实现其对应功能的事情了。你的要求中还涉及到在编程过程中需要用到的很多计算机软件的理论知识。例如：数据结构和算法的设计（例如：链表的创建、排序等）、整个程序总体的设计风格、以及即使你在集成编程环境下面录入完全部的程序源代码，但是程序肯定是必须要经过一系列的不断调试（例如：在可疑的语句处设置断点、单步跟踪等）、编译、链接，直到运行出最终的正确结果。

故别的任何人无法帮助你实现你的程序功能，只能够依靠自己的刻苦努力来完成该大作业了。

㈤ 求几个有关链表的最基本算法

这个也太多了！
1.循环单链表,且含有头结点的
p = head->next;
for(len=0；p->next!=head；p=p->next)
{
len++ //长度加1
}
2.插入
Status ListInsert(DuLinkList L, int i, ElemType e)
{
DuLinkList p, s;
//i值不合法
if(i < 1 || i > ListLength(L) + 1) return ERROR;

//在L中确定第i个元素前驱的位置指针p
p = GetElemP(L, i - 1);

//p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱)
if(!p) return ERROR;

//给插入的数据分配空间
s = (DuLinkList)malloc(sizeof(DuLNode));

//如果为空，分配失败
if(!s) return OVERFLOW;

//在第i-1个元素之后插入
s->data = e;
s->prior = p;
s->next = p->next;
p->next->prior = s;
p->next = s;

return OK;
}
删除
Status ListDelete(DuLinkList L,int i,ElemType *e)
{
DuLinkList p;

// i值不合法
if(i < 1) return ERROR;

// 在L中确定第i个元素的位置指针p
p = GetElemP(L, i);

// p=NULL,即第i个元素不存在
if(!p) return ERROR;
*e = p->data;
p->prior->next = p->next;
p->next->prior = p->prior;
free(p);
return OK;
}
3.带有头结点
p=head->next;
head->next =NULL;
q= head;
while(p)
{
q->next = p;
q = p;
p=p->next
}
4.带头结点
p=head->next;
head->next = head;
q = head;
while(p!=head)
{
if(head->next = head){q->next=p;q->next = head;}
else{q->next = p;}
q = p;
}
5.带头结点
p = head->next;
p->prior = NULL;
q = head;
while(p)
{
q->prior = p;
q->next = p->next;
p->next->prior = q;
p->next = q;

}

㈥ 统计单链表结点个数的算法要解释…

给你一个完整的代码，包括链表的创建，输出和求链表长度 #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node *next; }NODE,*List; void initList(List L) { L = NULL; } List createList() { List head, p, q; int flag; head = (List)malloc(sizeof(NODE)); head->next = NULL; q = head; printf("请输入节点的值,输入字母终值输入: "); flag = scanf("%d", &q->data); while(flag) { p = (List)malloc(sizeof(NODE)); printf("请输入节点的值: "); flag = scanf("%d", &p->data); q->next = p; p->next = NULL; q = q->next; } return head; } int listLength(List L) { int count = 0; List p = L; while (p->next != NULL) { p = p->next; count++; } return count; } void displayList(List L) { printf("链表中的元素为：\n"); while (L->next != NULL) { printf("%d ", L->data); L = L->next; } printf("\n"); } void main() { List L; L = createList(); printf("链表的长度为: %d\n", listLength(L)); displayList(L); }

㈦ 数据结构关于单链表算法问题

typedef
int
ElemType;
typedef
struct
LNode
/*定义链表结点类型*/
{
ElemType
data;
struct
LNode
*
next;
}LNode,
*
LinkList;
void
Output_des(LinkList
*head)
{//按值递减的次序逐个输出head中各结点的数据元素，同时释放该结点空间。利用简单的插入排序思想。
LNode
*q,*pre_q,*p,*pre_p;//q指向元素值最大的结点，pre_q指向q结点的前驱结点,pre_p指向p所指结点的前驱
while((*head)->next!=NULL)
{//单链表不空，输出表中元素
q=(*head)->next
;//初始化q指向第一个结点
pre_q=(*head);//pre_q指向q的前驱即头结点
p=q->next
;//p指向q的后继结点
pre_p=q;
while(p!=NULL)
{//找出链表中值最大的结点
if(p->data>q->data)
{//如果p所指结点的元素值大于q所指结点的元素值，那么将q指向p所指的结点，同时移动pre_q
pre_q=pre_p;
q=p;
}
pre_p=p;
p=p->next;//p和pre_p移动到下一个结点
}
printf("%d\t",q->data);//输出元素值
pre_q->next=q->next;//删除最大的结点q
free(q);//释放该结点
}
free(*head);//释放头结点
}

㈧ 算法中的链表到底是什么，用处在哪里

链表由多个结点连接而成，一个结点分为数据域和指针域，数据域存储数据，指针域存储下一个结点的内存地址。链表结点的内存地址可以不连续，可以充分利用内存空间，代价是查找慢，必须从头结点开始查找。

㈨ 编写链表算法

直接利用两个指针，指向两个节点，p1
p2，p1指向两者较大的，最后p1所指向的就是
表中值最大的节点：
typedef
struct
node
{
int
elem;
struct
node*
next;
}node;
//*****************初始化表*******************
void
initlink(node*
&l)
{
l
=
new
node;
l->next
=
null;
}
//*****************创建表**********************
void
creatlink(node*
l)
{
cout<<"请输入表数据，以-1结束输入:"<
>s->elem,s->elem
!=
-1)
{
s->next
=
null;
p->next
=
s;
p
=
s;
s
=
new
node;
}
delete
s;
}
//*****************打印表************************
void
print(node*
l)
{
node*
p
=
l->next;
while(p)
{
cout<
elem<<"
";
p
=
p->next;
}
cout<
next;
p2
=
p1->next;
while(p2)
{
if(p2->elem
>
p1->elem)
{
p1
=
p2;
p2
=
p2->next;
}
else
{
p2
=
p2->next;
}
}
return
p1;
}
int
main()
{
node*
l;
initlink(l);
creatlink(l);
cout<<"链表为:";
print(l);
node*
p
=
searchmax(l);
cout<<"表中最大值为:";
cout<
elem<
评论
0
0
加载更多

㈩ 定义链表的算法

定义列表的话，要先定义列表的节点。在亮点的节点中，至少包含一个数据域和一个链接域，用来指向下一个节点的地址。