線性表的基本運(yùn)算包括哪些 c語言數(shù)據(jù)表怎么做

線 性 表，線性表的基本操作:插入、刪除、查找等運(yùn)算在鏈?zhǔn)酱鎯Y(jié)構(gòu)上的運(yùn)算，線性表的操作，數(shù)據(jù)結(jié)構(gòu)實驗:線性表的順序表示和鏈?zhǔn)奖硎炯安迦搿h除、查找運(yùn)算，數(shù)據(jù)結(jié)構(gòu)線性表基本操作，線性表的基本操作c語言實現(xiàn)。

本文導(dǎo)航

• 線性表零基礎(chǔ)
• 線性表的兩種存儲結(jié)構(gòu)
• 對線性表的總結(jié)和體會
• 數(shù)據(jù)結(jié)構(gòu)中的順序表是什么
• 數(shù)據(jù)結(jié)構(gòu)鏈表圖解
• c語言數(shù)據(jù)表怎么做

線性表零基礎(chǔ)

線性表是最基本、最簡單、也是最常用的一種數(shù)據(jù)結(jié)構(gòu)。線性表中數(shù)據(jù)元素之間的關(guān)系是一對一的關(guān)系，即除了第一個和最后一個數(shù)據(jù)元素之外，其它數(shù)據(jù)元素都是首尾相接的。線性表的邏輯結(jié)構(gòu)簡單，便于實現(xiàn)和操作。因此，線性表這種數(shù)據(jù)結(jié)構(gòu)在實際應(yīng)用中是廣泛采用的一種數(shù)據(jù)結(jié)構(gòu)。

線性表是一種常用的數(shù)據(jù)結(jié)構(gòu)，本章介紹線性表及其順序存儲，并對棧和隊列及它們的順序?qū)崿F(xiàn)給出了詳細(xì)的設(shè)計描述。

在實際應(yīng)用中，線性表都是以棧、隊列、字符串、數(shù)組等特殊線性表的形式來使用的。由于這些特殊線性表都具有各自的特性，因此，掌握這些特殊線性表的特性，對于數(shù)據(jù)運(yùn)算的可靠性和提高操作效率都是至關(guān)重要的。

線性表是一個線性結(jié)構(gòu)，它是一個含有n≥0個結(jié)點的有限序列，對于其中的結(jié)點，有且僅有一個開始結(jié)點沒有前驅(qū)但有一個后繼結(jié)點，有且僅有一個終端結(jié)點沒有后繼但有一個前驅(qū)結(jié)點，其它的結(jié)點都有且僅有一個前驅(qū)和一個后繼結(jié)點。一般地，一個線性表可以表示成一個線性序列：k1,k2,…,kn，其中k1是開始結(jié)點，kn是終端結(jié)點。

是一個數(shù)據(jù)元素的有序（次序）集

線性結(jié)構(gòu)的基本特征為:

1．集合中必存在唯一的一個“第一元素”；

2．集合中必存在唯一的一個 “最后元素” ；

3．除最后一個元素之外，均有 唯一的后繼(后件)；

4．除第一個元素之外，均有 唯一的前驅(qū)(前件)。

由n(n≥0)個數(shù)據(jù)元素(結(jié)點)a1,a2,…,an組成的有限序列。

數(shù)據(jù)元素的個數(shù)n定義為表的長度。

當(dāng)n=0時稱為空表。

常常將非空的線性表(n>0)記作：

(a1，a2，…an)

數(shù)據(jù)元素ai(1≤i≤n)只是一個抽象的符號，其具體含義在不同的情況下可以不同。

線性表的基本操作

1）Setnull（L） 置空表

2）Length（L） 求表長度；求表中元素個數(shù)

3）Get（L，i） 取表中第i個元素（1≤i≤n）

4）Prior（L，i） 取i的前趨元素

5）Next（L，i） 取i的后繼元素

6）Locate（L，x） 返回指定元素在表中的位置

7）Insert（L，i，x）插入元素

8）Delete（L，x） 刪除元素

9）Empty（L） 判別表是否為空

線性表具有如下的結(jié)構(gòu)特點：

1.均勻性：雖然不同數(shù)據(jù)表的數(shù)據(jù)元素可以是各種各樣的，但對于同一線性表的各數(shù)據(jù)元素必定具有相同的數(shù)所類 長度。

2.有序性：各數(shù)據(jù)元素在線性表中的位置只取決于它們的序與，數(shù)據(jù)元素之前的相對位置是線性的，即存在唯一的“第一個“和“最后一個“的數(shù)據(jù)元素，除了第一個和最后一個外，其它元素前面均只有一個數(shù)據(jù)元素直接前趨和后面均只有一個數(shù)據(jù)元素（直接后繼）。

在實現(xiàn)線性表數(shù)據(jù)元素的存儲方面，一般可用順序存儲結(jié)構(gòu)和鏈?zhǔn)酱鎯Y(jié)構(gòu)兩種方法。鏈?zhǔn)酱鎯Y(jié)構(gòu)將在本網(wǎng)站線性鏈表中介紹，本章主要介紹用數(shù)組實現(xiàn)線性表數(shù)據(jù)元素的順序存儲及其應(yīng)用。另外棧．隊列和串也是線性表的特殊情況，又稱為受限的線性結(jié)構(gòu)。

線性表的兩種存儲結(jié)構(gòu)

萬惡的數(shù)據(jù)結(jié)構(gòu) 你是幾班的啊～～～我電信071～～～～

對線性表的總結(jié)和體會

我做的過的一個數(shù)據(jù)結(jié)構(gòu)的課程設(shè)計的題目（以下是報告，代碼可以運(yùn)行的）：也是用單鏈表做的，可以看一下，自己改下代碼就好，原理都一樣的…………

題目：約瑟夫問題的一種描述是：編號為1、2、3……n的n給人按瞬時針方向圍坐一圈，每個人持有一個密碼（正整數(shù)）。一開始任選一個正整數(shù)作為報數(shù)上限值m，從第一個人開始按順時針方向自1開始順序報數(shù)，報到m時停止報數(shù)。報m的人出列，將他的密碼作為新的m值，從他在順時針方向上的下一個人開始重新從1報數(shù)，如此下去，直至所有人全部出列為止。試設(shè)計一個程序求出出列順序。

一、需求分析

1.利用單向循環(huán)鏈表存儲結(jié)構(gòu)模擬此過程，按照出列順序印出個人的編號。

2.程序執(zhí)行的命令包括：1）構(gòu)造單向循環(huán)鏈表 2)求出出列的順序

3.測試數(shù)據(jù)：m的出植為20；n=7，7個人的密碼一次為：3，1，7，2，4，8，4，首先m植為6（正確的出列順序應(yīng)為6，1，4，7，2，3，5）。

二、概要設(shè)計

為實現(xiàn)上述程序功能，需創(chuàng)建一個循環(huán)單鏈表。

本程序包括四個模塊：

1． 程序模塊：

int main()

{調(diào)用intLinklist函數(shù)，建立鏈表L;

調(diào)用link_lit函數(shù)處理鏈表;}

2．建立鏈表模塊：

輸入m、n及n個密碼，建立鏈表L，L指向尾結(jié)點。

3．鏈表處理表模塊：

按要求處理鏈表L并輸出出列順序。

三、詳細(xì)設(shè)計

#include<stdio.h>

#include<stdlib.h>

#include<malloc.h>

#define OVERFLOW -2

#define INFEASIBLE -1

#define ERROR O

int m,n;

typedef int ElemType; //元素類型

typedef struct LNode

{ElemType num;

ElemType pas;

LNode *next;

}LNode ,*Linklist; //結(jié)點類型、指針類型

void FreeNode(Linklist &p)

{ //釋放p所指的結(jié)點

}

int intLinklist (Linklist &L)

{//創(chuàng)建循環(huán)單鏈表

printf("請輸入報數(shù)的上限m："); //輸入m的值

scanf("%d",&m);

if(m<1) return INFEASIBLE;

int i,pas;

Linklist p,q;

printf("請輸入人數(shù)n：");

scanf("%d",&n);

if(n<1) return INFEASIBLE;

L=p=(Linklist)malloc(sizeof(LNode));

if(!p)exit(OVERFLOW);

printf("請輸入第個人的密碼：");

p->num=1;

scanf("%d",& p->pas);

for(i=2;i<=n;i++)

{q=(Linklist)malloc(sizeof(LNode));

if(!q) exit(OVERFLOW);

p->next=q;

p=p->next;

printf("請輸入第%d個人的密碼：",i);

scanf("%d",&p->pas);

p->num=i;

}

p->next=L;

}

int link_list(Linklist &L,int &m) //鏈表處理

{

printf("出列的順序為：\n");

Linklist r,s;

int j;

s=L;

while(s->next->next!=s)

{

if(m==1)

{r=s;

while(s->next!=r) //m=1時，查找r前面的一個結(jié)點,用指針s指向它

s=s->next;

printf("%d\n",r->num);

m=r->pas;

s->next=r->next;

s=s->next;

}

else

{for(j=1;j<m-1;j++)

s=s->next; //查找第m-1個結(jié)點，用s指針指向它

r=s->next; //r指針指向第m個結(jié)點

printf("%d\n",r->num);

m=r->pas;

s->next=r->next;

s=s->next;}

}

printf("%d\n",s->num); //當(dāng)剩下兩個結(jié)點時直接輸出這兩個結(jié)點的num值

printf("%d\n",s->next->num);

return 0;

}

int main()

{Linklist L;

intLinklist(L); //調(diào)用intLinklist函數(shù)，建立鏈表L

link_list(L,m); //調(diào)用link_lit函數(shù)處理鏈表

return 0;

}

四、調(diào)試分析

1. 開始時對循環(huán)單鏈表的建立考慮不足，程序不夠簡潔。

2. 原來的程序中將L指向鏈表的首元結(jié)點，當(dāng)m=1時要查找最后一個結(jié)點，將L改為指向尾結(jié)點后就不需有考慮m=1的情況了。

3.原來的主函數(shù)因為有各個數(shù)據(jù)的輸入而不夠簡潔，將m,n及各個密碼的值的輸入放到創(chuàng)建鏈表的函數(shù)中完成后，主函數(shù)比原來簡潔易讀得多，函數(shù)的調(diào)用一目了然。

五、測試結(jié)果

1．輸入m值：20，n值：7，七個密碼分別為：3、1、7、2、4、8、4

輸出的結(jié)果為：6、1、4、7、2、3、5

2. 輸入m值：1，n值：5，七個密碼分別為：5、4、3、2、1

輸出的結(jié)果為：1、2、3、4、5

數(shù)據(jù)結(jié)構(gòu)中的順序表是什么

#include<stdio.h>#include<stdlib.h>

typedef int ElemType;

/*構(gòu)建結(jié)點結(jié)構(gòu)體 */typedef struct LNode

{

int data;

struct LNode * next;

}LNode, * LinkList;

/*用于創(chuàng)建鏈表的函數(shù) */

/*反序構(gòu)建的*/

LinkList CreateList_L(LinkList L, int n)

{

int i;

LinkList p;

L = (LinkList)malloc(sizeof(LNode));

L->next = NULL;

for(i = 0; i < n; ++i)

{

p = (LinkList)malloc(sizeof(LNode));

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

p->next = L->next;

L->next = p;

}

return L;

}

/*用于查找的函數(shù)*/LinkList GetElem_L(LinkList L,int i,ElemType &e)

{

LinkList p = L;

int j;

p = L->next;j = 1;

while(p && j<i)

{

p = p->next;

++j;

}

if(!p || j>i)

{

printf("表中無此位置。\n");

return L;

}

e = p->data;

printf("%d\n",e);

return L;

}

/* 用于插入結(jié)點的函數(shù) */LinkList ListInsert_L(LinkList L, int i, int newnode)

{

LinkList p = L;

LinkList s;

int j = 0;

while(p&&j<i-1)

{

p = p->next;

++j;

}

if(!p||j>i-1)

{

printf("位置小于1或大于表長。\n");

return L;

}

s = (LinkList)malloc(sizeof(LNode));

s->data = newnode;

s->next = p->next;

p->next = s;

return L;

}

/* 用于刪除結(jié)點的函數(shù) */LinkList ListDelete_L(LinkList L, int i)

{

LinkList p = L;

LinkList s;

int j=0;

while(p->next&&j<i-1)

{

p = p->next;

++j;

}

if(!(p->next)||j>i-1)

{

printf("刪除位置不合理。\n");

return L;

}

s = p->next;

p->next = s->next;

printf("%s%d\n","被刪除的結(jié)點是：",s->data);

free(s);

return L;

}

/*用于遍歷鏈表的函數(shù) */

void ListDisp_L(LinkList L)

{

LinkList p;

int i=0;

p = L->next;

while(p)

{

printf("%d:%d\n", ++i,p->data);

p = p->next;

}

}

int main(){

int where;

int value;

int count;

int search;

int output;

LinkList L; printf("請輸入鏈表初始結(jié)點數(shù):");

scanf("%d",&count);

printf("請輸入各個結(jié)點數(shù)值，每輸入一個按回車確認(rèn)：\n");

L = CreateList_L(L, count);

printf("請輸入要查找的位置:");

scanf("%d",&search);

L = GetElem_L(L,search,output);

printf("請輸入插入的位置:");

scanf("%d", &where);

printf("請輸入要插入的數(shù)值:");

scanf("%d", &value);

L = ListInsert_L(L,where,value);

ListDisp_L(L);

printf("請輸入要刪除的位置:"); scanf("%d",&where);

L = ListDelete_L(L,where);

ListDisp_L(L);

return 0;

}

數(shù)據(jù)結(jié)構(gòu)鏈表圖解

#include <iostream>

#include <cstdio>

#include <cstdlib>

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

#define LIST_INIT_SIZE 100

#define LISTINCREMENT 10

using namespace std;

typedef int Elemtype;

typedef struct

{

Elemtype *elem;

int length;

int listsize;

} SqList;

int InitList_Sq(SqList &L)//L在下面發(fā)生變化，故用引用

//構(gòu)造一個新的線性表

{

L.elem=(Elemtype *)malloc(LIST_INIT_SIZE*sizeof(Elemtype));

if(!L.elem)

exit(OVERFLOW);

L.length=0;//空表長度為0

L.listsize=LIST_INIT_SIZE;//初始存儲容量

return OK;

}

int ListInsert_Sq(SqList &L,int i,Elemtype e)

//在順序表L中的第i個位置插入新的元素e

//i的合法值為1<=i<=ListLength_Sq(L)+1

{

Elemtype * newbase;

Elemtype* p;

Elemtype* q;

if(i<1||i>L.length+1)//判斷i值是否合法

return ERROR;

if(L.length>=L.listsize)//增加分配空間

{

newbase=(Elemtype*)realloc(L.elem,

(L.listsize+LISTINCREMENT)*sizeof(Elemtype));

if(!newbase)//存儲分配失敗

exit(OVERFLOW);

L.elem=newbase;//新基址

L.listsize+=LISTINCREMENT;//增加存儲容量

}

/*for(int j=L.length;j>=i;j--)//元素右移

L.elem[j+1]=L.elem[j];

L.elem[i]=e;//插入e

L.length++;//表長增加

return OK;*/

q=&(L.elem[i-1]);//指針操作

for(p=&(L.elem[L.length-1]); p>=q; --p)

{

*(p+1)=*p;

}

*q=e;

++L.length;

return OK;

}

int main()

{

int i,n,x,k;

SqList La;

cout<<"請輸入線性表La的長度:";

cin>>n;

cout<<"請輸入線性表La中的元素:";

InitList_Sq(La);

for(i=0; i<n; i++)

{

cin>>La.elem[i];

La.length++; //如果不加這句，你要讓La.length=n；

}

cout<<"請輸入要插入到線性表La中的數(shù)字x和插入的位置k：";

cin>>x>>k;

ListInsert_Sq(La,k,x);

cout<<"線性表La=";

for(i=0; i<La.length; i++)//你的是i<n你插入元素的時候n沒有變，不，

cout<<La.elem[i]<<" ";

return 0;

}

你自己看看

c語言數(shù)據(jù)表怎么做

代碼如下：

頭文件：

2_1.h

#ifndef; _2_1_H

#define; _2_1_H

typedef void SeqList;

typedef void SeqListNode;

//創(chuàng)建線性表

SeqList * SeqList_Create(int capacity);

//銷毀線性表

void SeqList_DesTroy(SeqList * list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

源文件：

// 順序線性表.cpp : 定義控制臺應(yīng)用程序的入口點。

//

#include "stdafx.h"

#include <malloc.h>

#include <stdlib.h>

#include "2_1.h"

typedef unsigned int TSeqListNode;

typedef struct {

int len;; ; ;//長度

int capacity;//總長度

TSeqListNode * node;//每個節(jié)點的指針

} TSeqList;

int main()

{

SeqList* list = SeqList_Create(5);//創(chuàng)建線性表

int i = 6;//賦值6個變量，已超過線性表最大值 5

int j = 1;

int k = 2;

int x = 3;

int y = 4;

int z = 5;

int index = 0;

SeqList_Insert(list, &i, 7); //將這6個變量插入線性表中

SeqList_Insert(list, &j, 0);

SeqList_Insert(list, &k, 0);

SeqList_Insert(list, &x, 0);

SeqList_Insert(list, &y, 0);

SeqList_Insert(list, &z, 0);

//遍歷

for(index=0; index<SeqList_Length(list); index++)

{

int* p = (int*)SeqList_Get(list, index);

printf("%d; ", *p);

}

printf("\n");

//刪除操作

while( SeqList_Length(list) > 0 )

{

int* p = (int*)SeqList_Delete(list, 0);

printf("刪除了： %d\n", *p);

}

SeqList_Clear(list);

SeqList_DesTroy(list);

system("pause");

return 0;

}

//創(chuàng)建線性表

SeqList * SeqList_Create(int capacity)

{

TSeqList* ret = NULL ;

if(capacity >= 0)

{

ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity);; //為線性表分配空間，包含結(jié) //構(gòu)體和節(jié)點的總大小

}

if(NULL != ret)

{

ret->len = 0;

ret->capacity = capacity;

ret->node = (TSeqListNode*)(ret + 1);//將節(jié)點指向上述分配到的空間的后部分

}

return ret;

}

//銷毀

void SeqList_DesTroy(SeqList * list)

{

free(list);

}

//清空

void SeqList_Clear(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

if(NULL != ret)

{

ret->len = 0;

}

}

//獲得線性表的長度

int SeqList_Length(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int len = -1;

if(NULL != ret)

{

len = ret->len;

}

return len;

}

//線性表的總長度

int SeqList_Capacity(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int capacity = -1;

if(NULL != ret)

{

ret->capacity = capacity;

}

return capacity;

}

//插入

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)

{

TSeqList * sList = (TSeqList*)list;

int i,ret = -1;

if((sList != NULL) &&(pos >= 0) && sList->capacity >= sList->len+1)

{

if(pos >= sList->len)

{

pos = sList->len;

}

for(i = sList->len; i > pos; i--)

{

sList->node[i] = sList->node[i-1];

}

sList->node[i] = (TSeqListNode)node;

++sList->len;

ret = 1;

}

return ret;

}

//獲得指定位置的節(jié)點

SeqListNode* SeqList_Get(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

TSeqListNode* node = NULL;

if(NULL != sList && pos>=0 && pos < sList->len)

{

node = (TSeqListNode*)sList->node[pos];

}

return node;

}

//刪除

SeqListNode* SeqList_Delete(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

SeqListNode * node = SeqList_Get( list, pos);

int i;

if(sList != NULL && pos >= 0 && pos< sList->len)

{

for( i=pos+1; i<sList->len; i++)

{

sList->node[i-1] = sList->node[i];

}

sList->len--;

}

return node;

}

演示：

資料拓展：

線性表是最基本、最簡單、也是最常用的一種數(shù)據(jù)結(jié)構(gòu)。

線性表中數(shù)據(jù)元素之間的關(guān)系是一對一的關(guān)系，即除了第一個和最后一個數(shù)據(jù)元素之外，其它數(shù)據(jù)元素都是首尾相接的（注意，這句話只適用大部分線性表，而不是全部。比如，循環(huán)鏈表邏輯層次上也是一種線性表（存儲層次上屬于鏈?zhǔn)酱鎯Γ?，但是把最后一個數(shù)據(jù)元素的尾指針指向了首位結(jié)點）。

我們說“線性”和“非線性”，只在邏輯層次上討論，而不考慮存儲層次，所以雙向鏈表和循環(huán)鏈表依舊是線性表。

在數(shù)據(jù)結(jié)構(gòu)邏輯層次上細(xì)分，線性表可分為一般線性表和受限線性表。一般線性表也就是我們通常所說的“線性表”，可以自由的刪除或添加結(jié)點。受限線性表主要包括棧和隊列，受限表示對結(jié)點的操作受限制。

線性表的邏輯結(jié)構(gòu)簡單，便于實現(xiàn)和操作。因此，線性表這種數(shù)據(jù)結(jié)構(gòu)在實際應(yīng)用中是廣泛采用的一種數(shù)據(jù)結(jié)構(gòu)。