『壹』 線性表問題，求解
問題很多，數據結構抽象都不對。給個樣板你參考吧。
#include <stdio.h>
#include <malloc.h>
typedef struct node{
int data;
struct node *next;
}node_t;
node_t *creat_list(int n)
{
node_t *head;
node_t *p;
node_t *q;
int i = 1;
if(n == 0)
{
return NULL;
}
head = (node_t *)(malloc(sizeof(node_t)));
scanf("%d", &head->data);
p = head;
while (i < n)
{
i++;
q = (node_t *)(malloc(sizeof(node_t)));
scanf("%d", &q->data);
p->next = q;
p = q;
}
q->next = NULL;
return head;
}
void print_node(node_t *h)
{
while(h != NULL)
{
printf("%d->", h->data);
h= h->next;
}
printf("NULL\n");
}
int list_len(node_t *head)
{
int len = 0;
while (head != NULL)
{
len++;
head = head->next;
}
return len;
}
node_t *insert_node(node_t *head, int n)
{
node_t *p;
node_t *q = head;
node_t *r;
int i = 1;
p = (node_t *)(malloc(sizeof(struct node)));
scanf("%d", &p->data);
while (i < n - 1)
{
q = q->next;
i++;
}
if (n == 1)
{
p->next = head;
head = p;
}
else if (list_len(head) > n)
{
r = q->next;
p->next = r;
q->next = p;
}
else
{
q->next = p;
p->next = NULL;
}
return head;
}
node_t *find_node(node_t *head, int n)
{
while (n > 1)
{
head = head->next;
n--;
}
return head;
}
node_t *del_node(node_t *head, int n)
{
node_t *p = head;
node_t *q;
int i = 1;
while (i < n - 1)
{
p = p->next;
i++;
}
if (n == 1) // delete first node
{
head = head->next;
free(p);
}
else if(n == list_len(head))
{
q = p->next;
p->next = NULL;
free(q);
}
else
{
q = p->next;
p->next = q->next;
free(q);
}
return head;
}
node_t *change_list(node_t *head, int n)
{
int i = 1;
while (i < n)
{
i++;
head = head->next;
}
scanf("%d", &head->data);
return head;
}
node_t *reverse_list(node_t *head)
{
node_t *p = head;
node_t *q = head->next;
node_t *r;
head->next = NULL;
while (q != NULL)
{
r = q->next;
q->next = p;
p = q;
q = r;
}
return p;
}
int main()
{
node_t *list;
printf("Create a list please input 5 nodes\n");
list = creat_list(5);
print_node(list);
printf("\nThe list's lenth:%d\n", list_len(list));
printf("\nThe 2th node:%d\n", find_node(list, 2)->data);
printf("\nInsert a node,please inout a node\n");
list = insert_node(list, 2);
print_node(list);
printf("\nDelete the 3th node\n");
list = del_node(list, 3);
print_node(list);
printf("\nChange the 2th node\n");
change_list(list, 2);
print_node(list);
printf("\nReverse list\n");
list = reverse_list(list);
print_node(list);
return 0;
}
『貳』 線性表及其應用（多項式相加、相乘）----根據程序畫出流程圖及對每句程序加註釋(c語言）
#include "stdio.h"
typedef struct node
{ int c,e; //節點的數據域，c是多項式的系數，e是多項式的指數
struct node *next; //節點的指針域
}PN; //自定義節點結構體，類型PN
PN *createPoly() //這個函數用來建立鏈表，返回值是一個節點指針
{ int n, e, c;
PN *head, *p; //定義頭結點指針head，和節點指針p
printf("請輸入多項式項數:");
scanf("%d", &n); //得到n的值，既項數
head=p=new PN ; // * malloc(sizeof(PN));//讓head,p都指向頭結點（頭結點不用來存放數據）
p->next=NULL; //到這里為止，一個空鏈表建立完成
while( n-- ) //循環n次
{
p->next=new PN;// * malloc(sizeof(PN));//動態分配新的節點，並接在鏈表末尾（尾插法）
p=p->next;
// printf("c e:"); //給新的節點，添加數據
scanf("%d%d" , &p->c, &p->e);
}
p->next=NULL; //將表尾的指針域置為空
return head; //返回頭結點地址
}
void printPoly( PN *head) //這個函數用來輸入鏈表信息
{ PN *p=head->next; //節點指針p用來遍歷鏈表,p先指向表頭
while(p) //當p=NULL時（已經到表尾），結束循環
{ printf(" (%d,%d) ", p->c, p->e); //顯示當前節點的數據
p=p->next; //將p指向移到下一個節點
}
printf("\n"); //輸出一個回車
}
void freePoly( PN *head) //這個函數用來銷毀鏈表
{ PN *p; //用來釋放節點（動態內存塊）
while( head ) //當head=NULL時（已經到表尾），結束循環
{ p=head; //讓p指向head所指的節點
head=head->next; //將head指向移到下一個節點
delete(p); //釋放p所指的節點（動態內存塊）
}
}
PN *polyAdd(PN *ha, PN *hb) //這個函數用來將兩個多項式相加
{ int c, e; //c是多項式的系數，e是多項式的指數
PN *pa=ha->next, *pb=hb->next, //pa,pb用來遍歷通過參數傳進來的兩個鏈表（參數是兩個鏈表的頭結點指針），暫且稱它們為鏈表a,b
*hc, *pc; //hc是兩個鏈表對應節點相加後的新鏈表的頭結點，pc用來遍歷新鏈表,此鏈表稱它為c
hc=pc=new PN;
while( pa || pb ) //當兩個鏈表都遍歷完畢，則循環停止
{
if( pa && (pb==NULL || pa->e < pb->e)) //取指數較小的一項鏈入鏈表或者鏈表b已經遍歷完畢時，執行該if中的內容
{ c=pa->c;
e=pa->e;
pa=pa->next;
}
else if( pb && (pa==NULL || pa->e > pb->e)) //取指數較小的一項鏈入鏈表或者鏈表a已經遍歷完畢時，執行該if中的內容
{ c=pb->c;
e=pb->e;
pb=pb->next;
}
else //指數相等的時候，執行
{ c=pa->c+pb->c;
e=pa->e;
pa=pa->next;
pb=pb->next;
}
if( c ) //將兩個鏈表相加後的每個項 都放入新鏈表中
{
pc->next=new PN;
pc=pc->next;
pc->c=c;
pc->e=e;
}
}
pc->next=NULL;
return hc; //將新鏈表的頭結點指針返回
}
PN *mulxmul(PN *ha, PN *hb) //這個函數將a表中每個項都掉用一次onexmul函數，最終實現多項式a與b的相乘
{ PN *t, *hc, *pa=ha->next;
PN *onexmul( PN *pa , PN *hb); //函數聲明，因為接下來就要用到它
PN *polyAdd(PN *ha, PN *hb); //函數聲明，因為接下來就要用到它
t=new PN; t->next=NULL; //存放最終結果的鏈表，t是表頭,此表暫稱為t表
while( pa ) //遍歷a鏈表
{ hc=onexmul( pa, hb ); //將a表中pa所指的項與b表中所有的項相乘（即多項式a中的某一項與多項式b相乘）
t=polyAdd( t, hc ); //將每次相乘的結果相加
freePoly( hc ); //將調用onexmul函數產生的中間鏈表銷毀，因為該鏈表的項，已經放到t鏈表中
pa=pa->next;
}
return t; //將t表的頭結點指針返回
}
PN *onexmul ( PN *pa, PN *hb ) //這個函數用來將a表中pa所指的項與b表中所有的項相乘（即多項式a中的某一項與多項式b相乘）
{ PN *hc, *pc, *pb=hb->next; //hc是新鏈表的頭結點，pc用來遍歷新鏈表
hc=pc=new PN; //讓hc,pc都指向頭結點
while( pb ) //遍歷b鏈表
{ pc->next=new PN; //建立新鏈表的節點
pc=pc->next;
pc->c=pa->c * pb->c; //給新節點賦值，系數等於系數相乘
pc->e=pa->e + pb->e; //指數等於指數相加
pb=pb->next;
}
pc->next=NULL;
return hc; //將新鏈表的頭結點指針返回
}
int main()
{ PN *ha, *hb, *hc;
freopen("poly.in" , "r" , stdin); //只讀模式打開poly.in
freopen("poly.txt", "w", stdout); //只寫模式打開poly.txt
ha=createPoly(); //建立新鏈表，ha為頭結點指針(多項式a)
printPoly(ha); //輸出ha為頭結點指針的鏈表信息
hb=createPoly(); //建立新鏈表，hb為頭結點指針(多項式b)
printPoly(hb); //輸出hb為頭結點指針的鏈表信息
hc=polyAdd(ha, hb); //多項式a與多項式b相加，結果放在hc為頭結點指針的鏈表中
printPoly(hc); //輸出相加後的鏈表信息
freePoly(hc); //銷毀該鏈表
hc=mulxmul(ha,hb); //多項式a與多項式b相乘，結果放在hc為頭結點指針的鏈表中
printPoly(hc); //輸出相乘後的鏈表信息
freePoly(ha); //銷毀該鏈表
freePoly(hb); //銷毀該鏈表
freePoly(hc); //銷毀該鏈表
return 0;
}
OK,花了不少時間幫你寫了下注釋，應該比較完整了吧，原理和數學模型完全一樣的，應該能看懂，流程圖，相信看懂了程序，畫起來不難，自己嘗試下吧。
『叄』 c語言數據結構順序表，要求程序輸出如圖內容
#include<stdio.h>
#include <iostream>
#include <conio.h>
#include <stdlib.h>
using namespace std;
#define OK 1
#define FAULT 0
typedef int Status;
#define ListInitSize 100
#define ListIncrement 10
typedef struct //存儲結構類型定義
{
int* data;
int length;
int MaxSize;
}hahaList;
Status InitList_haha(hahaList &L) //線性表初始化
{
L.data=(int*)malloc(ListInitSize*sizeof(int));
if(!L.data) return 0;
L.length =0;
L.MaxSize = ListInitSize;
return OK;
}
void Search(hahaList L,int x) //查找
{
int i,a;
for(i=0;i<L.length ;i++)
if(x== L.data[i])
printf("元素%d是第%d個元素\n",x,i+1);
}
void print(hahaList L) //輸出
{
int i;
printf("線性表la=");
for (i=0;i<L.length ;i++)
printf("%3d",L.data[i]);
printf("\n線性表的長度為%d",L.length);
for (i=0;i<L.length ;i++)
printf("\n第一個元素是：%d",L.data[i]);
}
Status Insert(hahaList &L,int i,int e) //插入
{
int j;int* newbase;
if(i<1||i>L.length +1)return 0;
if(L.length >=L.MaxSize )
{
newbase=(int*)realloc(L.data ,(L.MaxSize+ListIncrement)*sizeof(int));
if(!newbase) return 0;
L.data =newbase;
L.MaxSize +=ListIncrement;
}
for(j=L.length-1;j>=i-1;j--)
L.data [j+1]=L.data [j];
L.data [i-1]=e;
++L.length ;
return OK;
}
Status Delete(hahaList &L,int i,int e) //刪除
{
int j;
if(i<1||i>L.length +1)return 0;
e=L.data [i-1];
for(j=i;j<=L.length-1;j++)
L.data [j-1]=L.data [j];
--L.length ;
printf("刪除元素%d後線性表為:",i);
for (i=0;i<L.length ;i++)
printf("%3d",L.data[i]);
printf("\n線性表La的長度=%d",L.length);
return OK;
}
int main ()
{
int i,x;
int num,e;
hahaList L ;
InitList_haha(L) ;
for(i=0;i<6;i++)
{
Insert(L, i+1, i+1);
}
print(L);
printf("\n請輸入要查詢的元素");
scanf("%d",&x);
Search(L,x);
printf("請輸入要刪除的元素");
scanf("%d",&i);
Delete(L,i,e);
cout<<endl;
return 0;
}
『肆』 數據結構順序存貯線性表的程序，我想知道每個步驟的意思
建議您可以學習一下單步調試，具體網路教程即可。在單步調試中，你可以得到計算機具體執行程序的每一步操作的結果信息。
第四行有了一個全局變數n，和一個全局變數數組table，這兩個變數在主函數和函數中都可以調用更改。
在main（）函數中，choice表示選擇的操作的編號。接著7行輸出cout...，接著是「cin>>choice」讀入一次數據賦值給choice，根據choice的值調用那個函數。
creat_table()函數，每次讀取一個手動鍵入的數字，然後存進table數組的最後一位（下標為n的地方），然後增加n的數值為n+1。
out_table（）函數：n代表的是整個table數組的長度，數組內存的元素從下標0到下標n-1，長度就是n了！所以跑一次循環整體輸出。
append_data(): cin>>table[n++] 實際上等價於 cin>>table[n]（讀取一個數字存到下標為n的地方）然後n++，n再自增一。
inset_data()： 需要先讀入loc的值，也就是插入的元素的下標；然後整體將下標n-1到loc的元素依次後移一位，再來讀入一個新的數據 直接覆蓋了下標為loc上的數據。這樣達到插入數據的目的！（這里還有一個小bug，n再插入一個元素後需要n++一次，畢竟插入新的元素後總長度加一了哈！）
我之前寫過一點C語言學習經驗，可以看看網頁鏈接網頁鏈接
希望以上內容可以對你有所幫助，忘採納；如有疑問，接著追問~~
『伍』 數據結構 線性表程序 要求先插入後刪除
#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100 //線性表存儲空間初始分配量
#define LISTINCREMENT 10 //線性表存儲空間分配增量
typedef struct
{
int *elem; //存儲空間基址
int length; //當前長度
int listsize; //當前分配存儲容量
}SqList;
void InitList(SqList *L) //初始化
{
L->elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));
if(!L->elem) exit(1);
L->length = 0;
L->listsize = LIST_INIT_SIZE;
}
int GetElem(SqList *L,int i) //取得i位置的元素
{
if(i<1 || i>L->length) exit(1);
return (L->elem[i-1]);
}
void ListInsert(SqList *L,int i,int e) //插入
{
//順序線性表L中第i個位置之前插入新元素e
int *newbase,*q,*p;
if(i<1 || i>L->length+1) exit(1);
if(L->length>=L->listsize) //存儲空間滿，增加分配
{
newbase = (int *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(int));
if(!newbase) exit(1); //分配失敗
L->elem = newbase; //指向新地址
L->listsize += LISTINCREMENT;
}
q = &(L->elem[i-1]); //插入位置
for(p=&(L->elem[L->length-1]);p>=q;--p)
*(p+1) = *p;
*q = e; //插入
++L->length;
}
void ListDelete(SqList *L,int i) //刪除
{
int *q,*p;
if((i<1) || (i>L->length)) exit(1);
p = &(L->elem[i-1]);
q = L->elem + L->length -1; //表尾元素位置
for(++p;p<=q;++p) //向左移動
*(p-1) = *p;
--L->length;
}
void MergeList(SqList La,SqList Lb,SqList *Lc) //合並兩表
{
int *pa,*pb,*pc,*pa_last,*pb_last;
pa = La.elem;
pb = Lb.elem;
Lc->listsize = Lc->length = La.length + Lb.length;
pc = Lc->elem = (int*)malloc(Lc->listsize*sizeof(int));
if(!Lc->elem) exit(1); //分配失敗
pa_last = La.elem + La.length-1;
pb_last = Lb.elem + Lb.length-1; //取得最後一個元素的位置
while(pa<=pa_last && pb<=pb_last) //歸並
{
if(*pa<=*pb) *pc++ = *pa++;
else *pc++ = *pb++;
}
while(pa<=pa_last) *pc++ = *pa++; //插入剩餘元素
while(pb<=pb_last) *pc++ = *pb++;
}
void display(SqList *L) //顯示
{
int i;
printf("the list is :");
for(i=0;i<L->length;i++)
{
printf("%d\n",L->elem[i]);
}
}
int main()
{
SqList sl,sl2,sl3;
InitList(&sl);
InitList(&sl2);//初始化兩表
printf("%d\n",sl.length);
ListInsert(&sl,1,1);
ListInsert(&sl,2,2);//插入表1
ListInsert(&sl2,1,3);
ListInsert(&sl2,2,4);
display(&sl);
display(&sl2);
printf("merge a and b:\n");
MergeList(sl,sl2,&sl3);
display(&sl3);
return 0;
}
『陸』 求構建一個線性表的完整程序 數據結構C語言版
#include "stdafx.h"
#define maxSize 100
typedef int elemType;
#include <stdio.h>
#include <stdlib.h>
typedef int elemType;
struct SeqList {
elemType *list;
int size;
int LmaxSize;
};
/* 初始化線性表L，即進行動態存儲空間分配並置L為一個空表 */
void initList(struct SeqList *L, int ms)
{
/* 檢查ms是否有效，若無效的則退出運行 */
if(ms <= 0){
printf("MaxSize非法！");
exit(1); /* 執行此函數中止程序運行，此函數在stdlib.h中有定義 */
}
L->LmaxSize = ms; /* 設置線性表空間大小為ms */
L->size = 0;
L->list = (int *)malloc(ms * sizeof(elemType));
if(!L->list){
printf("空間分配失敗！");
exit(1);
}
return;
}
/* 空間擴展為原來的2倍，並由p指針所指向，原內容被自動拷貝到p所指向的存儲空間 */
void againMalloc(struct SeqList *L)
{
elemType *p = (int *)realloc(L->list, 2 * L->LmaxSize * sizeof(elemType));
if(!p){ /* 分配失敗則退出運行 */
printf("存儲空間分配失敗！ ");
exit(1);
}
L->list = p; /* 使list指向新線性表空間 */
L->LmaxSize = 2 * L->LmaxSize; /* 把線性表空間大小修改為新的長度 */
}
/* 清除線性表L中的所有元素，釋放存儲空間，使之成為一個空表 */
void clearList(struct SeqList *L)
{
if(L->list != NULL){
free(L->list);
L->list = NULL;
L->size = L->LmaxSize = 0;
}
return;
}
/* 返回線性表L當前的長度，若L為空則返回0 */
int sizeList(struct SeqList *L)
{
return L->size;
}
/* 判斷線性表L是否為空，若為空則返回1, 否則返回0 */
int emptyList(struct SeqList *L)
{
if(L->size ==0){
return 1;
}
else{
return 0 ;
}
}
/* 返回線性表L中第pos個元素的值，若pos超出范圍，則停止程序運行 */
elemType getElem(struct SeqList *L, int pos)
{
if(pos < 1 || pos > L->size){ /* 若pos越界則退出運行 */
printf("元素序號越界！");
exit(1);
}
return L->list[pos - 1]; /* 返回線性表中序號為pos值的元素值 */
}
/* 順序掃描（即遍歷）輸出線性表L中的每個元素 */
void traverseList(struct SeqList *L)
{
int i;
for(i = 0; i < L->size; i++){
printf("%d ", L ->list[i]);
printf(" ");
}
return;
}
/* 從線性表L中查找值與x相等的元素，若查找成功則返回其位置，否則返回-1 */
int search(struct SeqList *L, elemType x)
{
int i;
for(i = 0; i < L->size; i++){
if(L->list[i] == x){
return i;
}
}
return -1;
}
/* 把線性表L中第pos個元素的值修改為x的值，若修改成功返回1，否則返回0 */
int updatePosList(struct SeqList *L, int pos, elemType x)
{
if(pos < 1 || pos > L->size){ /* 若pos越界則修改失敗 */
return 0;
}
L->list[pos - 1] = x;
return 1;
}
/* 向線性表L的表頭插入元素x */
void inserFirstList(struct SeqList *L, elemType x)
{
int i;
if(L->size== L->LmaxSize){ /* 重新分配更大的存儲空間 */
againMalloc(L);
}
for(i = L->size - 1; i >= 0; i--)/*元素後移*/
L->list[i + 1] = L ->list[i];
L->list[0] = x;
L->size ++;
}
/* 向線性表L的表尾插入元素x */
void insertLastList(struct SeqList *L, elemType x)
{
if(L->size == L ->LmaxSize){ /* 重新分配更大的存儲空間 */
againMalloc(L);
}
L->list[L->size] = x; /* 把x插入到表尾 */
L->size++; /* 線性表的長度增加1 */
return;
}
/* 向線性表L中第pos個元素位置插入元素x，若插入成功返回1，否則返回0 */
int insertPosList(struct SeqList *L, int pos, elemType x)
{
int i;
if(pos < 1 || pos > L->size + 1){ /* 若pos越界則插入失敗 */
return 0;
}
if(L->size == L->LmaxSize){ /* 重新分配更大的存儲空間 */
againMalloc(L);
}
for(i = L->size - 1; i >= pos - 1; i--){
L->list[i + 1] = L->list[i];
}
L->list[pos - 1] = x;
L->size++;
return 1;
}
/* 向有序線性表L中插入元素x,使得插入後仍然有序*/
void insertOrderList(struct SeqList *L, elemType x)
{
int i, j;
/* 若數組空間用完則重新分配更大的存儲空間 */
if(L->size == L->LmaxSize){
againMalloc(L);
}
/* 順序查找出x的插入位置 */
for(i = 0; i < L->size; i++){
if(x < L->list[i]){
break;
}
}
/* 從表尾到下標i元素依次後移一個位置， 把i的位置空出來 */
for(j = L->size - 1; j >= i; j--)
L->list[j+1] = L->list[j];
/* 把x值賦給下標為i的元素 */
L->list[i] = x;
/* 線性表長度增加1 */
L->size++;
return;
}
/* 從線性表L中刪除表頭元素並返回它，若刪除失敗則停止程序運行 */
elemType deleteFirstList(struct SeqList *L)
{
elemType temp;
int i;
if(L ->size == 0){
printf("線性表為空，不能進行刪除操作！ ");
exit(1);
}
temp = L->list[0];
for(i = 1; i < L->size; i++) /* 元素前移 */
L->list[i-1] = L->list[i];
L->size--;
return temp;
}
/* 從線性表L中刪除表尾元素並返回它，若刪除失敗則停止程序運行 */
elemType deleteLastList(struct SeqList *L)
{
if(L ->size == 0){
printf("線性表為空，不能進行刪除操作！ ");
exit(1);
}
L->size--;
return L ->list[L->size]; /* 返回原來表尾元素的值 */
}
/* 從線性表L中刪除第pos個元素並返回它，若刪除失敗則停止程序運行 */
elemType deletePosList(struct SeqList *L, int pos)
{
elemType temp;
int i;
if(pos < 1 || pos > L->size){ /* pos越界則刪除失敗 */
printf("pos值越界，不能進行刪除操作！ ");
exit(1);
}
temp = L->list[pos-1];
for(i = pos; i < L->size; i++)
L->list[i-1] = L->list[i];
L->size--;
return temp;
}
/* 從線性表L中刪除值為x的第一個元素，若成功返回1，失敗返回0 */
int deleteValueList(struct SeqList *L, elemType x)
{
int i, j;
/* 從線性表中順序查找出值為x的第一個元素 */
for(i = 0; i < L->size; i++){
if(L->list[i] == x){
break;
}
}
/* 若查找失敗，表明不存在值為x的元素，返回0 */
if(i == L->size){
return 0;
}
/* 刪除值為x的元素L->list[i] */
for(j = i + 1; j < L->size; j++){
L->list[j-1] = L->list[j];
}
L->size--;
return 1;
}
int main(int argc, char* argv[])
{
struct SeqList * ListPerson;
int Listsize=10;
int i;
int num;
ListPerson=(SeqList*)malloc(sizeof(SeqList)); //這句話很重要
initList(ListPerson,Listsize);
for (i=0;i<10;i++)
{
inserFirstList(ListPerson, i);
}
for (i=0;i<5;i++)
{
inserFirstList(ListPerson, i);
}
num=sizeList(ListPerson);
for (i=0;i<num;i++)
{
printf(" %d ", ListPerson->list[i]);
}
printf("\n");
insertPosList(ListPerson, 5, 100);
num=sizeList(ListPerson);
for (i=0;i<num;i++)
{
printf(" %d ", ListPerson->list[i]);
}
return 0;
}