單鏈表存儲插入元素防止丟失

㈠ 用循環單鏈表實現循環隊列,寫出插入,和刪除的演算法,只要這兩個函數的演算法就行了，有頭尾指針。

先寫個循環鏈表的實現
然後 C++ 用繼承
C就組合吧,下面寫個C的實現
typedef struct CircleListNode{
Datatype d;
struct CircleList *pre,*nxt;
}*CircleList,CirListNode;

typedef struct

{
CircleList Head;
int num;
}CircleQueue;

void insertFront(CircleList *L,d);

{
if(!L)return NULL;
if(*L==NULL)
{
*L=(CircleList) malloc(sizeof(CirListNode));
*L->nxt= *L->pre=*L ;
*L->d=d;
}
else
{

CircleList p =(CircleList) malloc(sizeof(CirListNode));
p->nxt=*L;
p->pre=*L->pre;
*L->pre->nxt=p;
*L->pre=p;
*L=p;
}
}
void DeleteBack(CircleList *L)
{ CircleList r=*L->pre;
if(*L->nxt =*L){ free(*L);*L=NULL;return ;}

r->pre->nxt =*L;
*L->pre=r->pre;

free(r);

}

void InsertQueue(CircleQueue *que, Datatype d)
{
if(!que)return;
insertFront(&que->Head,d);
que->num ++;

}
void DeletQueue(CircleQueue *que)
{
if(que->num>0)
{
DeleteBack(&que->Head);
que->num--;
}
}

void InitQueue(CircleQueue *que)
{
if(!que)return;
que->Head=NULL;
que->num=0;
}

Datatype * GetBackData(const CircleQueue *que)
{
if(!que)return NULL;
if(!que->Head)return NULL;
if(que->num<=0)return NULL;
return &(que->Head->pre->d);
}

void ClearQueue(CircleQueue *que)
{
if(!que)return ;
while(que->num>0)
{
DeletQueue(que);
}
}

㈡ C 語言鏈表問題

//* * * * * * * * * * * * * * * * * * * * * * * *
//*CHAPTER :2 (2_2) *
//*PROGRAM :鏈式結構的線性表 *
//*CONTENT :生成,插入,刪除,定位,查找 *
//* * * * * * * * * * * * * * * * * * * * * * * *
#include <conio.h>
#include <dos.h>
#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(struct node) //定義LEN為一個節點的長度
enum BOOL{False,True}; //定義BOOL型
typedef struct node
{char data; //數據域
struct node *next;//指向下一個節點的指針
} *LinkList;
void CreatList(LinkList &,int); //生成一個單鏈表
BOOL ListInsert(LinkList &,int,char); //在單鏈表中插入一個元素
BOOL ListDelete(LinkList &,int,char &); //在單鏈表中刪除一個元素
BOOL ListFind_keyword(LinkList,char,int &); //按關鍵字查找一個元素
BOOL ListFind_order(LinkList,char &,int); //按序號查找一個元素
void ListPrint(LinkList); //顯示單鏈表所有元素
int main()
{LinkList L;
BOOL temp;
int num,loc,flag=1;
char j,ch;
//textbackground(3); //設置屏幕顏色
// textcolor(15);
// clrscr();
//---------------------程序解說-----------------------
printf("本程序實現鏈式結構的線性表的操作。\n");
printf("可以進行插入，刪除，定位，查找等操作。\n");
//----------------------------------------------------
printf("請輸入初始時鏈表長度:"); //輸入生成單鏈表時的元素個數
scanf("%d",&num);
CreatList(L,num); //生成單鏈表
ListPrint(L);
while(flag)
{ printf("請選擇:\n");
printf("1.顯示所有元素\n"); //顯示鏈表元素
printf("2.插入一個元素\n"); //插入鏈表元素
printf("3.刪除一個元素\n"); //刪除鏈表元素
printf("4.按關鍵字查找元素\n"); //按關鍵字查找
printf("5.按序號查找元素\n"); //按序號查找
printf("6.退出程序 \n"); //退出
scanf(" %c",&j);
switch(j)
{case '1':ListPrint(L); break;
case '2':{printf("請輸入元素(一個字元)和要插入的位置:\n");
printf("格式:字元，位置；例如:a,3\n");
scanf(" %c,%d",&ch,&loc); //輸入要插入的元素和要插入的位置
temp=ListInsert(L,loc,ch); //插入
if(temp==False) printf("插入失敗!\n"); //插入失敗
else printf("插入成功!\n"); //成功插入
ListPrint(L);
break;
}
case '3':printf("請輸入要刪除的元素所在位置:");
scanf("%d",&loc); //輸入要刪除的節點的位置
temp=ListDelete(L,loc,ch); //刪除
if(temp==False) printf("刪除失敗!\n"); //刪除失敗
else printf("成功刪除了一個元素:%c\n",ch); //刪除成功，顯示該元素
ListPrint(L);
break;
case '4':if(L->next==NULL) //鏈表為空
printf("鏈表為空!\n");
else{printf("請輸入要查找的元素(一個字元):");
scanf(" %c",&ch); //輸入要查找的元素
temp=ListFind_keyword(L,ch,loc); //按關鍵字查找
if(temp==False) printf("沒有找到該元素!\n"); //查找失敗
else printf("該元素在鏈表的第%d個位置。\n",loc);
//成功查找，顯示該元素位置
}
break;
case '5':if(L->next==NULL) //鏈表為空
printf("鏈表為空!\n");
else{printf("請輸入要查找的位置:");
scanf("%d",&loc); //輸入要查找的元素的位置
temp=ListFind_order(L,ch,loc); //按序號查找
if(temp==False) printf("該位置不存在!\n"); //查找失敗
else printf("第%d個元素是：%c\n",loc,ch);
//成功查找，顯示該元素
}
break;
default:flag=0;printf("程序結束，按任意鍵退出!\n");
}
}
getch();
return 0;
}
void CreatList(LinkList &v,int n)
{//生成一個帶頭結點的有n個元素的單鏈表
int i;
LinkList p;
v=(LinkList)malloc(LEN); //生成頭結點
v->next=NULL;
printf("請輸入%d個字元：例如：abcdefg\n",n);
getchar();
for(i=n;i>0;--i)
{p=(LinkList)malloc(LEN); //生成新結點
scanf("%c",&p->data);
p->next=v->next;
v->next=p;
}
}
BOOL ListInsert(LinkList &v,int i,char e)
{//在單鏈表的第i各位置插入元素e，成功返回True，失敗返回False
LinkList p,s;
int j=0;
p=v;
while(p&&j<i-1) {p=p->next;++j;} //查找第i-1個元素的位置
if(!p||j>i-1) return False; //沒有找到
s=(LinkList)malloc(LEN); //生成一個新結點
s->data=e;
s->next=p->next; //將新結點插入到單鏈表中
p->next=s;
return True;
}

BOOL ListDelete(LinkList &v,int i,char &e)
{//在單鏈表中刪除第i個元素，成功刪除返回True，並用e返回該元素值，失敗返回False
LinkList p,q;
int j=0;
p=v;
while(p->next&&j<i-1) //查找第i-1個元素位置
{p=p->next;++j;}
if(!(p->next)||j>i-1) return False; //查找失敗
q=p->next;p->next=q->next; //刪除該元素
e=q->data; //e取得該元素值
free(q); //釋放該元素空間
return True;
}

BOOL ListFind_keyword(LinkList v,char e,int &i)
{//在單鏈表中查找關鍵字為e的元素，成功返回True,並用i返回該元素位置，
//失敗返回False
i=1;
LinkList p;
p=v->next;
while((p->data!=e)&&(p->next!=NULL))//p指針指向下一個，直到
{p=p->next; i++;} //找到或到鏈表尾為止
if(p->data!=e) //該元素在鏈表中不存在
return False;
else return True;
}

BOOL ListFind_order(LinkList v,char &e,int i)
{//在單鏈表中查找第i個元素，成功返回True，並用e返回該元素值，
//失敗返回False
LinkList p;
int j=0;
p=v;
while(p->next&&j<i) //移動指針，直到找到第i個元素
{p=p->next;++j;}
if(j!=i) return False; //查找失敗
else {e=p->data; //查找成功，用e取得該元素值
return True;
}
}
void ListPrint(LinkList v)
{//顯示鏈表所有元素
LinkList q;
q=v->next;
printf("鏈表所有元素:");
while(q!=NULL)
{printf("%c ",q->data);q=q->next;}
printf("\n");
}
代碼都不想看 就別學編程了

㈢ 單鏈表 在遞增有序單鏈表中插入元素並保持遞增有序

1用遞歸演算法對int型數組進行雙向選擇排序#include<stdio.h>
void paixu(int x[],int m,int n)
{
int max,min,e,q,l=m,k=m;
if(m>=n) return;
max=x[m];
for(e=m;e<=n;e++)
{
if(x[e]>max) {l=e;max=x[e];}
}
q=x[n];x[n]=x[l];x[l]=q;
min=x[m];
for(e=m;e<=n;e++)
{
if(x[e]<min) {k=e;min=x[e];}
}
q=x[m];x[m]=x[k];x[k]=q;
paixu(x,m+1,n-1);
}
void main()
{
int a[21],b,c,i=1,j,top=0;
printf("請輸入數字，中間空格格開，0為結束標志：\n");
scanf("%d",&b);
while(b!=0)
{
a[++top]=b;
scanf("%d",&b);
}
j=top;
paixu(a,i,j);
printf("排序後數組為：\n");
for(c=1;c<=top;c++)
{printf("%d ",a[c]);}
printf("\n");
}

2#include<stdio.h>
#include<malloc.h>
typedef struct node
{
int data;
struct node *next;
}ln;
ln *set()
{
int x;
ln *head,*s;
head=(ln *)malloc(sizeof(ln));
head->next=NULL;
scanf("%d",&x);
while(x!=0)
{
s=(ln *)malloc(sizeof(ln));
s->data=x;
s->next=head->next;head->next=s;
scanf("%d",&x);
}
return head;
}
void del(ln *b)
{
ln *p,*pre;
int c;
pre=b;p=pre->next;
while(p!=NULL)
{
c=p->data;
ln *p1,*pre1;
pre1=p;p1=p->next;
while(p1!=NULL)
{
if(c==p1->data)
{
p1=p1->next;
pre1->next=p1;

}
else{ pre1=p1;p1=p1->next;}
}
pre=p;
p=p->next;
}
}
void dis(ln *b)
{
ln *p;
p=b->next;
while(p!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
}
void main()
{
ln *a;
a=set();
del(a);
dis(a);
}

㈣ 單鏈表的元素插入演算法

#include <stdlib.h>#include<stdio.h>typedef struct LNode{
int data;
LNode *next;
}*List,LNode;void Creat(List &L,int n){//創建鏈表
List p;//用於循環創建的節點
L=(List)malloc(sizeof(struct LNode));
L->next=NULL;
for(int i=1;i<=n;i++){
p=(List)malloc(sizeof(struct LNode));
scanf("%d",&p->data);
p->next =L->next;
L->next=p;
}
}//創建成功void Print(List L3){
L3=L3->next;
while(L3){
printf("%d",L3->data);
L3=L3->next;
}
}void Insert(List &L,int i,int e){//在第i個位置之前插入e
List p,s;
p=L;
int j=0; while(p&&j<=i-1){
if(j==i-1){
s=(List)malloc(sizeof(struct LNode));
s->data=e;
s->next=p->next;
p->next=s;
}
j++;
p=p->next;
}
}

int main(){ List L;
int n,i,e;
scanf("%d,%d,%d",&n,&i,&e);
Creat(L,n);
Insert(L,i,e);
Print(L); return 0;
}1

㈤ 關於雙向循環鏈表的插入元素

對於插入元素來說，最重要的是不要插入後丟了以前鏈表中的元素。只要保證插入後不丟元素，順序你可以改的：
上面的題中，你找到了插入點並用指針P指向它，也就是到現在你只知道頭指針和插入點的指針P，要在P所指向的結點之前插入元素，以前以前元素的信息都靠P來傳達，所以要先修改新增結點中的信息，以使P以前的元素的信息不丟失，再來修改P的信息，可以：
1.s->next = p;
2.s->prior = p->prior;
3.p->prior->next = s;
4.p->prior = s;

㈥ 用VC++實現單鏈表動態插入刪除

只能給你一個大概的演算法，具體代碼自己寫吧，也就花點時間而已。

首先是定義一個宏MAX_LENGTH標示你的動態鏈表的最大節點數。

定義一個結構struct node，用於表示你的鏈表的結點的內部結構。

然後定義一個指針數組void ss[MAX_LENGTH]，用於存儲每個節點的位置。

初始化的時候應該使用malloc直接從內存中挖掘出void * f=malloc(sizeof(node)*MAX_LENGTH)的存儲區域用於作動態鏈表的活動區域。並且定義一個變數count=0用於表示當前的鏈表節點數目。

至於動態的插入和刪除，只要操作數組ss[]即可。插入一個節點時，只要ss[count]=f+sizeof(node)*count;count++;然後將ss[count-1]付值即可。刪除節點如果是末尾的那隻需要count--即可，數組ss當中被刪除的節點編號處直接付給地址0。下次復制或插入時會被覆蓋掉的。
但要記住程序退出時需要釋放f內存塊的。

相比以往的鏈表操作，整塊內存分配會更連貫，讓鏈表操作更便捷。

至於插入位置嘛用f+sizeof(node)*count;就可以找到了。

不過要注意我上面說的數組ss是一個地址數組而不是指針！比如void *m;
m=ss[1];
m->node_sub01=...;
m->node_sub02=...;
...

想要代碼是吧？你給我200RMB我可以考慮下。
代碼都懶得寫還學什麼編程

㈦ 數據結構線性表的單鏈表存儲結構

線性表是一種數據元素有序的邏輯結構，通常採用順序存儲結構和鏈式存儲結構。線性表採用順序存儲結構時，有利用線性表長度的計算、線性表數據元素的存取和數據元素的遍歷，同時也從物理結構上反映了線性表數據元素的邏輯結構，有點類似於c語言中的數組，但是採用順序存儲結構時，插入和刪除數據元素時，要移動較多的數據元素；採用鏈表結構存儲的線性表，克服了插入和刪除數據元素時要移動較多元素的缺點，其只要尋找到需要插入和刪除的數據元素處，處理相應的指針就可以實現數據元素的插入和刪除，同時也和順序存儲的線性表一樣方便遍歷，但是其不利於計算線性表的長度，線性表的鏈表存儲結構有以下幾種常見類型：採用帶頭指針和頭結點的單鏈表、採用僅帶頭指針的單鏈表、帶頭指針和頭結點的循環鏈表、帶頭指針和尾結點的循環鏈表、雙向鏈表等形式。在實際應用中，結合順序表易於計算表長和鏈表易於插入和刪除的特點，實際一般採用兩者結合的一種單鏈表，其鏈表類型為帶有頭指針（含頭結點）和尾指針，以及含有線性表長度的分量，在一元多項式的運算中採用的就是這種鏈式存儲結構。此外，還有一種一般應用於無指針的高級語言中的靜態單鏈表的存儲結構。

㈧ 在單鏈表中插入一個元素 [問題描述] 創建一個單鏈表L。單鏈表數據元素限定為單個字元，單鏈表的長度不限，

#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct em
{
int data;

struct em *next;
}*List,_List;
int InitList(List &L) //初始化一個帶頭結點的鏈表
{
L=(List)malloc(sizeof(_List)); //分配內存空間
if(!L)
return 0;

L->next=NULL;
return 1;
}
int InsertList(List &L,int e) //插入一個結點
{
List help,temp,prior;
temp=L;
temp=temp->next;
if(temp==NULL) //判斷是否為頭結點
{
help=(List)malloc(sizeof(_List));
help->data=e;
help->next=NULL;

L->next=help;
L->data++;
return 1;
}
else
{
++L->data;
help=(List)malloc(sizeof(_List));
help->data=e;
help->next=NULL;
while(temp->data<e)
{
if(!temp->next) //該語句用來判斷是否到了最後一個結點
{
temp->next=help;
return 1;
}
prior=temp;
temp=temp->next;
}
prior->next=help;
help->next=temp;
return 1;
}
}
int DelList (List &L) //保留頭結點，刪除後邊的所有結點
{
List temp,help;
temp=L->next;
while(temp != NULL)
{
help=temp;
temp = temp->next;
free(help);
}
L->next = NULL;
return 1;
}
int DelList (List &L,int n)
{

List temp;
temp=L->next;
if(n<0||n>L->data)
return 0;
cout<<"***"<<endl;
if(n==1)
{
L->next=temp->next;
free(temp);
return 1;
}
for(int i=1;i<n-1;i++) // 用temp確定n-1個結點的位置
{
temp=temp->next;
}
if(L->data==n)
{

free(temp->next);
temp->next=NULL;
}
else
{
free(temp->next);
temp->next=temp->next->next;
}
return 1;
}
int ReadList(List &L) //遍歷整個鏈表
{
List temp;
temp=L->next;
while(temp) //判斷是否到了最後一個結點
{
cout<<temp->data<<" ";
temp=temp->next;
}
return 1;
}
int ComList (List &A,List &B,List &C)
{
List Btemp;
Btemp=B->next;
C=A;
while(Btemp!=NULL)
{
InsertList(C,Btemp->data);
Btemp=Btemp->next;
}
return 1;
}
int main()
{
List L,M,N;
InitList(L);
InitList(M);
InitList(N);

cout<<"***"<<endl;
InsertList(L,1);
InsertList(L,5);
InsertList(L,3);
InsertList(N,4);

DelList(L);

ReadList(L);
ReadList(N);
ComList(L,N,M);
ReadList(M);
return 1;

}

㈨ 鏈表的基本操作

程序這么長，好歹也給點分吧。。。。
毛主席告訴我們，做人要厚道。。。。

㈩ 幫我用C語言寫一個數據結構中單鏈表的建立和插入以及刪除操作，就只寫這三個操作，小弟是新手謝謝各位了

#include<stdio.h>
#include<malloc.h>
typedef struct Node //定義節點
{
int data; //可以為其他類型
struct Node *next;
}List;
void create(struct Node *&L,int a[],int n) //創建，L是鏈表頭,a是要插入數組,n是要插入元素個數
{
List *s;
int i;
L=(List *)malloc(sizeof(List));
L->next=NULL;
for(i=0;i<n;i++)
{
s=(List *)malloc(sizeof(List));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
int insert(List *&L,int i,int e) //插入，i是插入位置，e是插入的值
{
int j=0;
List *p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return 0;
else
{
s=(List *)malloc(sizeof(List));
s->data=e;
s->next=p->next;
p->next=s;
return 1;
}
}
int delete(List *&L,int i,int &e)//i是要刪除元素的位置，e保存被刪除元素的值
{
int j=0;
List *p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return 0;
else
{
q=p->next;
if(q==NULL)
return 0;
e=q->data;
p->next=q->next;
free(p);
return 1;
}
}