c语言创建有序链表

Ⅰ 用c语言写一个有序链表,链表类型为字符串.

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

struct _Node {
int data;
struct _Node *next;
};

typedef struct _Node Node;

// 交换两个结点的数据
void SwapNodeData(Node *p1, Node *p2) {
int temp = p1->data;
p1->data = p2->data;
p2->data= temp;
}

// 冒泡排序对链表进行排序
void BubbleSort(Node *head) {
Node *pTemp;
int maxIdx, idx;
// 计算链表长度
maxIdx = 0;
for (pTemp = head; pTemp != NULL; pTemp = pTemp->next)
++maxIdx;
idx = 0;
while (idx < maxIdx-1) {
for (pTemp = head; idx < maxIdx-1; pTemp = pTemp->next, ++idx) {
if (pTemp->data > pTemp->next->data)
SwapNodeData(pTemp, pTemp->next);
}
idx = 0;
--maxIdx;
}
}

int main(void)
{
Node *head = NULL, *temp = NULL, *p = NULL;
int i;

srand((unsigned int)time(NULL));
// 产生随机数链表
head = (Node *)malloc(sizeof(Node));
head->data = rand() % 40;
p = head;
for (i = 1; i < 20; ++i) {
temp = (Node *)malloc(sizeof(Node));
temp->data = rand() % 40;
p->next = temp;
p = p->next;
}
p->next = NULL;
// 输出随机数链表
for (p = head; p != NULL; p = p->next)
printf("%d ", p->data);
printf("\n");
// 对链表排序
BubbleSort(head);
// 输出以排序的链表
for (p = head; p != NULL; p = p->next)
printf("%d ", p->data);
printf("\n");
// 释放资源
for (p = head->next; p != NULL; p = p->next) {
free(head);
head = p;
}
free(head);
head = NULL;
getchar();
return 0;
}

Ⅱ c语言采用头插法或尾插法建立链表，从键盘输入递增有序的数据建立链表

#include<stdio.h>
#include<stdlib.h>
/*定义链表结点*/
typedefstructst_node{
intvalue;
structst_node*next;
}node_t;
/*定义链表*/
typedefstruct{
node_thead;
node_t*tail;
}list_t;
/*插入到队列尾部*/
voidlist_push_back(list_t*l,intvalue){
node_t*t=(node_t*)malloc(sizeof(node_t));
t->value=value;
t->next=NULL;

l->tail->next=t;
l->tail=t;
}
/*有序地插入元素*/
voidlist_push_sort(list_t*l,intvalue){
/*找出小于或等于value的节点，插入到该节点前面*/
node_t*p=l->head.next,*last=&l->head,*t;
for(;p;last=p,p=p->next){
if(value<=p->value){
t=(node_t*)malloc(sizeof(node_t));
t->value=value;
t->next=p;

last->next=t;
return;
}
}
/*如果没有小于或等于value的节点，则直接插入到末尾*/
list_push_back(l,value);
}
/*使用数组初始化有序链表*/
voidlist_init(list_t*l,int*p,ints){
inti=0;
l->head.next=NULL;
l->tail=&l->head;
for(;i<s;++i){
list_push_sort(l,p[i]);
}
}
/*清空链表*/
voidlist_clear(list_t*l){
node_t*p=l->head.next,*t;
while(p){
t=p;
p=p->next;
free(t);
}
l->head.next=NULL;
l->tail=&l->head;
}
/*合并有序链表*/
voidlist_merge(list_t*l,list_t*r,list_t*o){
node_t*pl=l->head.next,*pr=r->head.next;
while(pl||pr){
if(pl&&pr){
if(pl->value<=pr->value){
list_push_back(o,pl->value);
pl=pl->next;
}else{
list_push_back(o,pr->value);
pr=pr->next;
}
}elseif(pl){
list_push_back(o,pl->value);
pl=pl->next;
}else{
list_push_back(o,pr->value);
pr=pr->next;
}
}
}
/*删除相同结点*/
voidlist_plicate_delete(list_t*l){
if(&l->head!=l->tail){
node_t*p=l->head.next,*last,*t;
intvalue=p->value;

last=p;
p=p->next;
while(p){
if(value==p->value){
t=p;
last->next=p->next;
p=p->next;
free(t);
}else{
value=p->value;
last=p;
p=p->next;
}
}
}
}
/*打印链表*/
voidlist_show(char*name,list_t*l){
node_t*p=l->head.next;
printf("%s:",name);
for(;p;p=p->next){
printf("%d,",p->value);
}
printf("
");
}
/*主函数*/
voidmain(){
list_tlist1,list2,list3;
inta[]={10,4,6,12,1,8,14,10,14,6};
intb[]={7,11,6,1,13,5,1,14};

/*所有链表需要初始化后才能使用*/
list_init(&list1,a,sizeof(a)/sizeof(int));
list_init(&list2,b,sizeof(b)/sizeof(int));
list_init(&list3,NULL,0);

printf("初始值:
");
list_show("List1",&list1);
list_show("List2",&list2);
list_show("List3",&list3);

/*合并链表*/
list_merge(&list1,&list2,&list3);
printf("合并后:
");
list_show("List1",&list1);
list_show("List2",&list2);
list_show("List3",&list3);

/*去重复*/
list_plicate_delete(&list3);
printf("去重复后:
");
list_show("List1",&list1);
list_show("List2",&list2);
list_show("List3",&list3);

/*所有链表都需要释放空间*/
list_clear(&list1);
list_clear(&list2);
list_clear(&list3);
}

//这可是血汗钱啊.....

Ⅲ 用C语言编写程序建立链表结构体类型实现链表初始化遍历和插入算法

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

#define telemtype char
#define ok 1
#define error 0
#define overflow -1

typedef int status;

typedef struct bitnode
{
telemtype data;
struct bitnode *lchild,*rchild;
}bitnode,*bitree;

void preordertraverse(bitree T)
{
if(T)
{
printf("%c ",T->data);
preordertraverse(T->lchild);
preordertraverse(T->rchild);
}
}

status createbitree(bitree &T)
{
int ch;
ch=getchar();
if(ch==' ')
T=NULL;
else
{
if(!(T=(bitnode*)malloc(sizeof(bitnode))))
exit(overflow);
T->data=ch;
createbitree(T->lchild);
createbitree(T->rchild);
}
return ok;
}

void prinbtree(bitree T)
{
if(T!= NULL)
{

printf("%c", T->data);
if(T->lchild!=NULL||T->rchild!=NULL)
{
printf("(");
prinbtree(T->lchild);
if(T->rchild!=NULL)
{
printf(",");
}
prinbtree(T->rchild);
printf(")");
}
}
}

int main()
{
bitree T=NULL;

printf("先序输入二叉树：\n");
createbitree(T);

printf("先序遍历二叉树为：\n");
preordertraverse(T);
printf("\n");

prinbtree(T);
printf("\n");

return 0;
}

我写的，希望对你有用！

Ⅳ 用C语言编写一个算法，实现有序链表的插入。链表有序且不允许有重复元素

如代码所示，c++语言，设带头节点的单链表L是一个递增有序表，试写一个函数，将x插入L中，并使L仍是一个有序表。望采纳！

Ⅳ c语言采用头插法或尾插法建立链表，从键盘输入递增有序的数据建立 链表

void DeleteRepetedNode(PNode head)
{
int a[100]={0};
int i = 0,j;
int flag = 1;
PNode p,q,pre;
pre = head;
p = pre->next;
q = p->next;
while(p)
{
a[i++] = pre->data;
for(j=0;j<i;j++)
if(a[j]==p->data)
{
pre->next = q;
free(p);
p = q;
flag = 0;
break;
}
if(flag)
pre = p;
if(q&&p)
{
p = q;
q = q->next;
}
flag = 1;
}
}

Ⅵ 用c语言实现一个有序单链表

不多说，直接看代码：

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
typedefstructyinshu{
unsignedintyz;
structyinshu*next;
}YSNode,*YinShu;//定义链表节点类型YSNode，和指针YinShu

voidInsertNode(unsignedintn,YinShu&L){
//在L链表的第一个节点之后插入一个节点，值为n
YinShup;
p=(YinShu)malloc(sizeof(YSNode));//分配节点空间
p->yz=n;
p->next=L->next;
L->next=p;
}

voidYinShuFenJie(unsignedintn,YinShu&L){
//对n进行质因数分解，并存在链表L中
unsignedintj,k;
k=(unsignedint)sqrt(n);
for(j=2;j<=k;++j){
if(n%j==0){//遇到一个质因数j
InsertNode(j,L);
n/=j;
k=(unsignedint)sqrt(n);
--j;
}
}
InsertNode(n,L);//插入剩下的质因数n
}

intmain(){
unsignedintn;
YinShuL,p,q;
scanf("%d",&n);
L=(YinShu)malloc(sizeof(YSNode));
L->yz=n;
L->next=NULL;//第一个节点存放n的值
YinShuFenJie(n,L);
p=L->next;q=p->next;
printf("%u=%u",L->yz,p->yz);
free(L);free(p);//释放第一、二个节点
while(q){
p=q;
printf("*%u",p->yz);
q=p->next;
free(p);
}
printf("
Finished.
");
getch();
return0;
}

希望能帮到你！

Ⅶ c语言创建链表

1、你使用了malloc函数但没有导入头文件malloc.h。
2、函数DATA *create(int n);没有申明就直接调用。
（另外main函数中DATA* head;给个初值NULL，避免野指针。）
修改以上内容，亲测可运行。

Ⅷ 有序单链表的实现 用c语言编程

#include <stdio.h> /*该文件包含pringtf()等函数*/
#define MaxSize 100 /*定义MaxSize为100*/
typedef int DataType;
typedef struct
{
DataType list[MaxSize];
int size;
} SeqList;

/*定义DataType为int*/

void ListInitiate(SeqList *L) /*初始化顺序表L*/
{
L->size = 0; /*定义初始数据元素个数*/
}

int ListInsert(SeqList *L, DataType x)
/*在顺序表L插入数据元素值x*/
/*插入成功返回1，插入失败返回0*/
{
int i=0,j;

if(L->size >= MaxSize)
{
printf("顺序表已满无法插入! \n");
return 0;
}

for(i=0;i<L->size;i++)
if (x<L->list[i]) break;

for(j = L->size; j > i; j--) L->list[j] = L->list[j-1]; /*为插入做准备*/
L->list[i] = x; /*插入*/
L->size ++; /*元素个数加1*/
return 1;

}

int ListDelete(SeqList *L, DataType x)
/*删除顺序表L中的数据元素值x*/
/*删除成功返回1，删除失败返回0*/
{ int i, j;
if(L->size <= 0)
{
printf("顺序表已空无数据元素可删! \n");
return 0;
}
for(i = 0; i < L->size; i++)
if(x == L->list[i]) break;

if(i == L->size) return 0;
else
{ for(j = i; j < L->size; j++)
L->list[j] = L->list[j+1];

L->size--; return 1;
}
}

void main(void)
{
SeqList myList;
int i,x;
ListInitiate(&myList); /*初始化*/
printf("请输入10个数据元素\n");
for(i = 0; i<10; i++)
{
scanf("%d",&x);
if(ListInsert(&myList, x) == 0) /*插入10个数据元素*/
{
printf("错误! \n");
return;
}
}

for(i = 0; i < myList.size; i++)
printf("%d ", myList.list[i]);
printf("请输入要删除的数据元素\n");
scanf("%d",&x);
if(ListDelete(&myList,x) == 0) /*删除某个数据元素*/
{
printf("删除不成功，数据元素可能不存在 \n");
return;
}

printf("删除后\n");
for(i = 0; i < myList.size; i++)
printf("%d ", myList.list[i]); /*显示数据元素*/

}

Ⅸ C语言如何创建单链表

C语言创建单链表如下：

#include"stdio.h"

#include"stdlib.h"

#include"malloc.h"

#include "iostream.h"

typedef struct node

{

intdata;

node * next;

}node , * List;

void create(int n)

{

int c;

List s,L;

L=(List)malloc(sizeof(node));

L->next=NULL;

printf("请输入第1个数据：");

scanf("%d",&c);

L->data=c;

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

{

s=(List)malloc(sizeof(node));

printf("请输入第%d个数据：",i);

scanf("%d",&c);

s->data=c;

s->next=L;

L->next =s;

}

printf("链表创建成功！");

}

void main()

{

int n;

printf("请你输入链表的个数：");

scanf("%d",&n);

create(n);

}