线性表的关键算法

‘壹’ 线性表的链式存储结构的典型算法(求代码)

假设是单链表存贮，从头遍历到尾，遍历每个元素是将指针反转，只需要一个额外空间。

算法描述：
header : 指向链表头

p=header;
pre=NULL;
next=NULL;
while(p!=NULL)
{
next=p->next;
p->next=pre;
pre=p;
p=next;
}
head=p;

这样就反转了。用了两个额外空间,时间复杂度O(n).

‘贰’ 数据结构线性表（C版）问题 设计算法

Locate_Sq(Splist *L,int i)
{ if(L->len==0) return 0;
for(j=1;j<=l->len;j++)
if(l->elem[i]==x) retrun i;
else return 0;
}

‘叁’ java设计线性表排序算法

import java.util.Scanner;
import java.util.Arrays;

public class P
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);

float[] A=new float[1],B=new float[1];
int alen=0,blen=0,i,j,k;
String line;

System.out.println("请输入线性表A的各元素,每行一个（输入#结束）：");
while(true)
{
line=sc.nextLine();
if(line.equals("#"))
break;
A=Arrays.Of(A,++alen);
A[alen-1]=Float.parseFloat(line);
}
System.out.println("请输入线性表B的各元素,每行一个（输入#结束）：");
while(true)
{
line=sc.nextLine();
if(line.equals("#"))
break;
B=Arrays.Of(B,++blen);
B[blen-1]=Float.parseFloat(line);
}
Arrays.sort(A);
Arrays.sort(B);
System.out.println("升序排序后，线性表A的各元素是：");
for(i=0;i<alen;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
System.out.println();
System.out.println("升序排序后，线性表B的各元素是：");
for(i=0;i<blen;i++)
{
System.out.print(B[i]+" ");
}
System.out.println();
System.out.println();
A=Arrays.Of(A,alen+blen);
for(i=0;i<blen;i++)
{
if(B[i]>=A[alen-1])
A[alen++]=B[i];
else
{
for(j=0;j<alen-1;j++)
{
if(B[i]<=A[j])
break;
}
for(k=alen-1;k>=j;k--)
{
A[k+1]=A[k];
}
A[j]=B[i];
alen++;
}
}
System.out.println("线性表B按顺序插入线性表A中后，线性表A的各元素是：");
for(i=0;i<alen;i++)
{
System.out.print(A[i]+" ");
}
sc.close();
}
}

‘肆’ 线性表顺序存储结构及其有关算法的实现

将顺序表初始化为5个元素,在结构中定义了顺序表的长度,int length:所以在主函数中可以直接调用用printf(

‘伍’ 线性表链式存储结构的基本操作算法实现

这是我学数据结构时亲手码的，好用的话记得给分。。。。。
#include<iostream>
using namespace std;

//线性表的单链表存储表示
struct LNode
{
int data;
struct LNode *next;
};

//逆序创建链表
void CreateList(LNode *L,int a[],int n)
{
LNode *s;
L->next = NULL;
for(int i=n-1;i>=0;--i)
{
s= new LNode;
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
//显示链表
void display(LNode *L)
{
LNode *p;
p=L->next;
while(p)
{
cout<<p->data<<" ";
p=p->next;
}
}
//插入结点操作
void ListInsert(LNode *L,int d, LNode *s)
{
LNode *p;
int i=1;
p=L->next;
while(i<d-1)
{
p=p->next;
i++;
}
s->next=p->next;
p->next=s;
}
//删除节点操作
void ListDelete(LNode *L,int d,int &e)
{
LNode *p,*q;
int i=0;
p=L->next ;
while(i<d-1)
{
q=p;
p=p->next;
i++;
}
e=p->data;
q->next=p->next;
delete p;
}
//查找元素
LNode* LocalElem(LNode *L,int e)
{
LNode *p;
p=L->next;
while(p&&p->data!=e) p=p->next;
return p;
}
//逆置单链表
void InvertLinkedList(LNode *L)
{
LNode *p,*s;
p=L->next;
L->next=NULL;
while(p)
{
s=p;
p=p->next;
s->next=L->next;
L->next=s;
}
}

int main()
{
LNode *H;
int n;
cout<<"please enter the length of the list: ";
cin>>n;
int *A=new int[n];
int i;
H=new LNode;
H->next=NULL;
cout<<"please enter "<<n<<" number of the list:"<<endl;
for(i=0;i<n;i++)
cin>>A[i];
CreateList(H,A,n);
cout<<"show the members of the list: ";
display(H);
cout<<endl;

int d;
cout<<"please enter the address of the add member: ";
cin>>d;
LNode *s;
s= new LNode;//初始化局部变量s
cout<<"please enter the data of the add member: ";
cin>>s->data;
ListInsert(H,d, s);
display(H);
cout<<endl;

int p;
cout<<"please enter the address of the delete member: ";
cin>>p;
int c=0;
int &e=c;//非常量引用的初始值必须为左值!!!
ListDelete(H,p,e);
display(H);
cout<<endl;

int g;
cout<<"please enter the member that you want to find: ";
cin>>g;
cout<<"the local of the member is: "<<LocalElem(H,g);
cout<<endl;

InvertLinkedList(H);
cout<<"the invertlinklist is: ";
display(H);
cout<<endl;
return 0;
}

花时间好好看看，一定要看懂

‘陆’ 数据结构的线性表算法

插入元素之后，再次输出元素，但是插入的元素不在线性表中（我用的while（true）控制程序是否结束），
这可能是你在插入后没有修改表将L.length++

删除一个元素之后，再次输出元素的时候，元素还在。如果每次删除的是最后一个的话，没进行插入操作，那删除的元素当然还在表中，这时只是修改了表长L.length

‘柒’ 如何设计一个算法求线性表中最大元素

int sqMax(s,n) //用顺序表实现，返回最大值，s是数组名，n是数组长度
{
int t;
for(int i=0,i<n,i++)
for(int j=i+1,j<n,j++)
if(s[i]<s[j])
{
t =s[i];
s[i]=s[j];
s[i]=t ;
}
return s[i];
}

‘捌’ 写出线性表操作的算法

你已经十分明白了，还问什么？

#include<stdio.h>
void search(int a[];int b)
{
int i=0;
while(i<10&&a[i]!=b)
i++;
if(i<10){
printf("found!");
return;
}
else
{
printf("not found");
return;
}
}
main()
{
int a[]={12,26,39,30,52,43,80,92,101,89};
search(a,b);
}

‘玖’ 【数据结构】求线性表的长度和线性表上的查找算法

/* 顺序存储类型*/
typedef struct
{ ElemType data[MAXSIZE]; /*存放线性表的数组*/
int length; /* length是顺序表的长度*/
}SqList; SqList L;
/* 求顺序表长度*/
int ListLength(SqList L)
{return(L.length);}
/* 给定序号从顺序表中查找元素*/
void ListGet(SqList L ,int i)
{ if(L.length==0) printf("顺序表空\n");
else if(i<1||i>L.length) printf("查找的位置不正确\n");
else printf("顺序表中第%d个元素的值为:%d\n",i,L.data[i-1]);
}
/* 从顺序表中查找与给定元素值相同的元素在顺序表中的位置*/
int ListLocate(SqList L, ElemType x)
{int i=0;
while(i<L.length && L.data[i]!=x)
i++;
if (i<L.length) return (i+1);
else return 0;
}