数据结构顺序表算法

‘壹’ 数据结构实验 线性表中顺序存储结构的基本操作算法（建顺序表，查询，插入，删除，遍历）

有序线性表插入一个数依然有序
#include<stdio.h>
#define MAXSIZE 6
typedef char datatype;
typedef struct SeqList
{
datatypedata[MAXSIZE];
int last;
}SeqList;

SeqList *init_SeqList()
{
SeqList *L;
L=(SeqList*)malloc(sizeof(SeqList));
L->last=-1;
return L;
}

int main()
{ SeqList *L;
int k,x,j;
intInser_SeqList(SeqList *L);
L->last=0;
L=init_SeqList();
for(k=0;k<(MAXSIZE-1);k++)
{ scanf("%d",&x);
L->data[k]=x;
L->last++;
}
Inser_SeqList(L);
for(j=0;j<L->last;j++)
printf("%d",L->data[j]);

return 0;
}
int Inser_SeqList(SeqList *L)
{
int j,x;
if(L->last==MAXSIZE-1)
{printf("表满");
return (-1);
}

L->last++;
for(j=L->last;j>=0;j--)
if(L->data[j]<x)
L->data[L->last]=x;
else
L->data[j+1]=L->data[j];

return 1;
}
你好，上面是我的程序：符合你的1 2 4点 查询、删除操作在课本里找到 写入即可 谢谢

‘贰’ （C语言数据结构） 设计两个有序顺序表的合并排序算法。

#include
#include
typedef
struct
node//定义结构体
{
int
score;
struct
node
*next;
}node;
node
*create(int
n)//创建链表
{
node
*head,*tail,*p;
head=tail=null;
int
i;
for(i=1;i<=n;i++)
{
p=(node
*)malloc(sizeof(node));
p->next=null;
printf("please
input
%d
score:",i);
scanf("%d",&p->score);
if(head==null)
head=tail=p;
else
{
tail->next=p;
tail=p;
}
}
return
head;
}
node
*range(node
*head)//排序
{
node
*p,*q;
int
score,i,n=0;
p=head;
while(p)
{
n++;
p=p->next;
}
for
(i=0;i
next!=null)//内循环
{
q=p->next;
if
(p->score>q->score)//值交换
{
score=p->score;
p->score=q->score;
q->score=score;
}
p=q;
}
}
return
head;
}
node
*connect(node
*head1,node
*head2)//合并
{
node
*p;
p=head1;
while(p->next!=null)
p=p->next;
p->next=head2;
return
head1;
}
void
output(node
*head)//输出
{
node
*p;
p=head;
while(p)
{
printf("%d
",p->score);
p=p->next;
}
printf("\n");
}
int
main()
{
node
*head,*hea1,*head2;
int
n1,n2;
printf("please
input
a
n1:");//第一个链表的成绩个数
scanf("%d",&n1);
hea1=create(n1);
printf("第一个链表的成绩:");
output(hea1);
printf("please
input
a
n2:");//第二个链表的成绩个数
scanf("%d",&n2);
head2=create(n2);
printf("第二个链表的成绩:");
output(head2);
head=connect(hea1,head2);
head=range(head);
printf("合并后，并排好序:");
output(head);
return
0;
}

‘叁’ C语言数据结构的一个顺序表算法,求分析bug

#include<stdio.h>

typedef int datatype;

const int maxsize=100; //modify

typedef struct{

datatype data[maxsize];

int n;

}sqlist;

int main()

{

//在一个递增数列中插入一个x后仍是一个递增数列

sqlist L;

sqlist *p;

p=&L;

int insert(sqlist *L,datatype x,int i);

int locate(sqlist *L,datatype x);

void print(sqlist *L);

datatype x;

int j;

int i;

printf("input the number of the sqlist's length\n");

scanf("%d",&j);

p->n=j;

for(i=0;i<j;i++)//输入数列

scanf("%d",&p->data[i]);

printf("input the x");

scanf("%d",&x);//插入x

insert(p,x,locate(p,x)) ;

print(p);//输出

return 0;

}

int insert(sqlist *L,datatype x,int i) {

//将x插入到顺序表L的第i个位置上

int j;

if(L->n==maxsize)

{return -1;}

if(i<1 || i>L->n+1)

{return 0;}

for(j=L->n;j>=i;j--)

L->data[j]=L->data[j-1]; //结点后移

L->data[i-1]=x;//插入x，第i个结点的数组下标是i-1

L->n++; //修改表长

return 1; //插入成功

}

int locate(sqlist *L,datatype x) {

int i;

i=1;

while(i<=L->n && L->data[i-1]<=x) i++;

if(i<=L->n) return i; //找到

else return L->n; //未找到

}

void print(sqlist *l){

for(int i=0;i<l->n;i++)

printf("%d ",l->data[i]);

}

‘肆’ 数据结构顺序表问题 指出算法的功能

图一：
第1个for循环找出该顺序表中最大值的下标，保存到j中。
第2个for循环把j后面的元素依次向前移动，并令顺序表的长度减1。
该算法功能：删除该顺序表中值最大的元素。

图二：
第1个for循环找出该顺序表中最后一个最小值的下标，保存到j中。
第2个for循环把j以及其后的元素依次向后移动，相当于把j的位置空出来，然后把第二个参数x插入到j的位置。并令顺序表的长度加1。
该算法功能：查找该顺序表中最后一个值最小的元素下标，然后把新元素x插入到该下标处，该位置及其后的原有元素整体向后移动一个位置。

‘伍’ 数据结构中对一个顺序表进行初始化的算法

if判断的是系统有没有成功动态分配了内存给你，如果系统内存满了，就没有分配内存给你，L->elem 为NULL，就是OVERFLOW.
struct xxx
用xxx.abc
struct *xxx
用xxx->abc
结构体用点，结构体指针用箭头。

‘陆’ 数据结构 顺序表中插入和删除元素的算法、顺序栈中入栈和出栈的算法

//顺序表的插入
void Insert(int i, int item)
{
if (length >= MaxSize)
{
cerr << "上溢";
exit(1);
}
if (i<1 || i>length + 1)
{
cerr << "插入位置非法";
exit(1);
}
for (int j = length; j >= i - 1; j--)
data[j + 1] = data[j];
data[i - 1] = item;
length++;
}
//顺序表的删除
int Delete(int i)
{
if (length == 0)
{
cerr << "下溢";
exit(1);
}
if (i<1 || i>length)
{
cerr << "删除位置非法";
exit(1);
}
int x = data[i - 1];
for (int j = i; j < length; j++)
data[j - 1] = data[j];
length--;
return x;
}
//入栈操作
void Push(T x)
{
if (top == MaxSize - 1)
{
cerr << "上溢";
exit(1);
}
top++;
data[top] = x;
}
//出栈操作
int Pop()
{
if (top == -1)
{
cerr << "下溢";
exit(1);
}
int x = data[top--];
return x;
}

‘柒’ 编程：如何把数据结构顺序表算法变成程序

#include<stdio.h>
#include<stdlib.h>/*动态存储分配库函数*/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10typedef int ElemType;typedef struct
{
int *elem;
int length;
int listsize;
}SqList;void InitList_Sq(SqList *L)
{
L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
if(!L->elem)
printf("Memory allocate failure!!");
L->length=0;
L->listsize=LIST_INIT_SIZE;
}void InputElem_Sq(SqList *L)
{
int x;
int i;
i=0;
scanf("%d",&x);
while(x!=0)
{
L->elem[i]=x;
i++;
scanf("%d",&x);
}
L->length=i;
}void ListInsert_Sq(SqList *L,int i,int x)
{
int j;
int *newbase;
if(i<1||i>L->length+1)
printf("插入位置不存在");
else
{
if(L->length>=L->listsize)
{/* 当前存储空间已满，增加分配 */
newbase=( int * )realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(int));
if(!newbase) printf("再分配失败!");
else
{
L->elem=newbase;
L->listsize+=LISTINCREMENT;
}
}
for(j=L->length;j>=i;j--)
L->elem[j]=L->elem[j-1];
L->elem[i-1]=x;
L->length++;
}
}void ListDelete_Sq(SqList *L,int i)
{
int j;
if(i<1||i>L->length)
printf("删除位置不存在。");
else
{
for(j=i+1;j<=L->length;j++)
L->elem[j-2]=L->elem[j-1];
L->length--;
}
}void PrintList_Sq(SqList *L)
{
int i;
i=0;
while(i<L->length)
{
printf("%5d",L->elem[i]);
i++;
}
printf("\n");
}
void main( )
{

SqList L;
int i;
int data; InitList_Sq(&L); printf("Input the numbers of L:\n");
InputElem_Sq(&L);

printf("The list is:\n");
PrintList_Sq(&L);

printf("Do inserting:\n");
printf("Input the location of insertion:\n");
scanf("%d",&i);
printf("Input the nember of insertion:\n ");
scanf("%d",&data);
ListInsert_Sq(&L,i,data);
printf("Output the L after insertion:\n");
PrintList_Sq(&L);

printf("Do deleting:\n");
printf("Input the location of deletion:\n");
scanf("%d",&i);
ListDelete_Sq(&L,i);
printf("Output the L after deletion:\n");
PrintList_Sq(&L);}

‘捌’ 数据结构于算法之顺序表

#include <iostream>
using namespace std;

#define N 6

void init(char * arr)//初始化
{
arr = (char *)malloc(sizeof(char) * N);
if(arr == 0)
{
cout<<"error!"<<endl;
exit(1);
}
}

void assi(char * arr)//尾插法
{
for(int i = 'a' ; i<= 'e' ; i++)
arr[i-'a'] = i;
}

void output(char * arr)//输出
{
for(int i = 0 ; i < N ; i++)
cout<<arr[i]<<" ";
cout<<endl;
}

void insert(char * arr , char c , int n)//插入
{
int i ;
for( i = N-1 ; i > n-1 ; i--)
arr[i] = arr[i-1];
arr[i] = c;
}

void dele(char* arr , int n)//删除
{
for(int i = n -1 ; i < N ; i++)
arr[i] = arr[i+1];
}

int main()
{
char *arr;
init(arr);
assi(arr);
output(arr);
insert(arr,'f',3);
output(arr);
dele(arr,4);
output(arr);
return 0;
}

下面是链表的
#include <iostream>
using namespace std;

typedef struct list
{
char c ;
struct list * next;
}*listhead;

void init(listhead &h)//初始化
{
h = (listhead)malloc(sizeof(struct list));
if(h == 0)
{
cout<<"error!";
exit(1);
}
h->next = NULL;
h->c = 't';
}

void assi(listhead &h)//尾插法
{
listhead t1 = h , t2;
for(char i = 'a' ; i<= 'e' ; i++)
{
t2 = (listhead)malloc(sizeof(struct list));

t2->c = i;
t2->next = NULL;

t1 ->next = t2;
t1 = t2;
}
}

void output(listhead &h)//输出
{
listhead t = h->next;
if(t == NULL)
exit(1);
while(t)
{
cout<<t->c<<" ";
t = t->next;
}
cout<<endl;
}

void insert(listhead &h , char ch, int n)//插入
{
int i = 0;
listhead t1 = h , t2 ;
if(t1 == NULL)
exit(1);

while( i<n-1 && t1->next)
{
t1 = t1->next;
++i;
}
t2 = (listhead)malloc(sizeof(struct list));
t2->c = ch;
t2->next = t1->next;
t1->next = t2;

}
void dele(listhead &h , int n)//删除
{
int i = 0;
listhead t1 = h , t2 ;
if(t1 == NULL)
exit(1);
while( i<n-1 && t1->next)
{
t1 = t1->next;
++i;
}
t2 = t1->next;
t1->next = t2->next;

free(t2);
}
int main()
{
listhead head;
init(head);
assi(head);
output(head);
insert(head,'f',3);
output(head);
dele(head,4);
output(head);
return 0;
}

‘玖’ C语言数据结构顺序表算法

这个算法很简单啊，这里我给出一个核心函数，自己看看……
void del(int c,int r[],int n){//c为目标元素值，r为顺序表，n为表中元素个数
int i,j;
for (i=0;i<n;i++)
if(r[i]==c) {for (j=i;j<n-1;j++) f[j]=f[j+1];n--;}
}

‘拾’ 数据结构问题 顺序表 有序表 的查找算法分别是什么

顺序表用直接查找法，有序表用二分（折半）查找法。