數據結構順序表演算法

『壹』 數據結構實驗 線性表中順序存儲結構的基本操作演算法（建順序表，查詢，插入，刪除，遍歷）

有序線性表插入一個數依然有序
#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--;}
}

『拾』 數據結構問題 順序表 有序表 的查找演算法分別是什麼

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